[BACK]Return to sysctl.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sbin / sysctl

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sbin/sysctl/sysctl.c between version 1.143.2.2 and 1.144

version 1.143.2.2, 2014/08/20 00:02:28 version 1.144, 2012/11/29 02:06:17
Line 72  __RCSID("$NetBSD$");
Line 72  __RCSID("$NetBSD$");
 #endif  #endif
 #endif /* not lint */  #endif /* not lint */
   
   #define FD_SETSIZE 0x10000
   #include <sys/fd_set.h>
 #include <sys/types.h>  #include <sys/types.h>
 #include <sys/param.h>  #include <sys/param.h>
 #include <sys/sysctl.h>  #include <sys/sysctl.h>
Line 80  __RCSID("$NetBSD$");
Line 82  __RCSID("$NetBSD$");
 #include <sys/stat.h>  #include <sys/stat.h>
 #include <sys/sched.h>  #include <sys/sched.h>
 #include <sys/socket.h>  #include <sys/socket.h>
 #include <sys/bitops.h>  
 #include <netinet/in.h>  #include <netinet/in.h>
 #include <netinet/ip_var.h>  #include <netinet/ip_var.h>
 #include <netinet/tcp.h>  #include <netinet/tcp.h>
Line 212  static const struct handlespec {
Line 213  static const struct handlespec {
         { "/net/(inet|inet6)/[^/]+/stats",      printother, NULL, "netstat"},          { "/net/(inet|inet6)/[^/]+/stats",      printother, NULL, "netstat"},
         { "/net/bpf/(stats|peers)",             printother, NULL, "netstat"},          { "/net/bpf/(stats|peers)",             printother, NULL, "netstat"},
   
         { "/net/inet.*/tcp.*/deb.*",            printother, NULL, "trpt" },  
   
         { "/net/inet.*/ip.*/anonportalgo/reserve", reserve, reserve, NULL },          { "/net/inet.*/ip.*/anonportalgo/reserve", reserve, reserve, NULL },
   
         { "/net/ns/spp/deb.*",                  printother, NULL, "trsp" },          { "/net/ns/spp/deb.*",                  printother, NULL, "trsp" },
Line 242  static const struct handlespec {
Line 241  static const struct handlespec {
   
 struct sysctlnode my_root = {  struct sysctlnode my_root = {
         .sysctl_flags = SYSCTL_VERSION|CTLFLAG_ROOT|CTLTYPE_NODE,          .sysctl_flags = SYSCTL_VERSION|CTLFLAG_ROOT|CTLTYPE_NODE,
         .sysctl_size = sizeof(struct sysctlnode),          sysc_init_field(_sysctl_size, sizeof(struct sysctlnode)),
         .sysctl_num = 0,          .sysctl_num = 0,
         .sysctl_name = "(prog_root)",          .sysctl_name = "(prog_root)",
 };  };
Line 253  char *fn;
Line 252  char *fn;
 int     req, stale, errs;  int     req, stale, errs;
 FILE    *warnfp = stderr;  FILE    *warnfp = stderr;
   
 #define MAXPORTS        0x10000  
   
 /*  /*
  * vah-riables n stuff   * vah-riables n stuff
  */   */
Line 337  main(int argc, char *argv[])
Line 334  main(int argc, char *argv[])
                 aflag = 1;                  aflag = 1;
   
         if (prog_init && prog_init() == -1)          if (prog_init && prog_init() == -1)
                 err(EXIT_FAILURE, "prog init failed");                  err(1, "prog init failed");
   
         if (Aflag)          if (Aflag)
                 warnfp = stdout;                  warnfp = stdout;
         stale = req = 0;          stale = req = 0;
   
         if ((re = malloc(sizeof(*re) * __arraycount(handlers))) == NULL)          if ((re = malloc(sizeof(*re) * __arraycount(handlers))) == NULL)
                 err(EXIT_FAILURE, "malloc regex");                  err(1, "malloc regex");
   
         if (aflag) {          if (aflag) {
                 print_tree(&name[0], 0, NULL, CTLTYPE_NODE, 1,                  print_tree(&name[0], 0, NULL, CTLTYPE_NODE, 1,
Line 359  main(int argc, char *argv[])
Line 356  main(int argc, char *argv[])
   
                 fp = fopen(fn, "r");                  fp = fopen(fn, "r");
                 if (fp == NULL) {                  if (fp == NULL) {
                         err(EXIT_FAILURE, "%s", fn);                          err(1, "%s", fn);
                 } else {                  } else {
                         nr = 0;                          nr = 0;
                         while ((l = fparseln(fp, NULL, &nr, NULL, 0)) != NULL)                          while ((l = fparseln(fp, NULL, &nr, NULL, 0)) != NULL)
Line 380  main(int argc, char *argv[])
Line 377  main(int argc, char *argv[])
         while (argc-- > 0)          while (argc-- > 0)
                 parse(*argv++, re, &lastcompiled);                  parse(*argv++, re, &lastcompiled);
   
         return errs ? EXIT_FAILURE : EXIT_SUCCESS;          return errs ? 1 : 0;
 }  }
   
 /*  /*
Line 405  findhandler(const char *s, regex_t *re, 
Line 402  findhandler(const char *s, regex_t *re, 
                         j = regcomp(&re[i], p[i].ps_re, REG_EXTENDED);                          j = regcomp(&re[i], p[i].ps_re, REG_EXTENDED);
                         if (j != 0) {                          if (j != 0) {
                                 regerror(j, &re[i], eb, sizeof(eb));                                  regerror(j, &re[i], eb, sizeof(eb));
                                 errx(EXIT_FAILURE, "regcomp: %s: %s", p[i].ps_re, eb);                                  errx(1, "regcomp: %s: %s", p[i].ps_re, eb);
                         }                          }
                         *lastcompiled = i + 1;                          *lastcompiled = i + 1;
                 }                  }
Line 416  findhandler(const char *s, regex_t *re, 
Line 413  findhandler(const char *s, regex_t *re, 
                 }                  }
                 else if (j != REG_NOMATCH) {                  else if (j != REG_NOMATCH) {
                         regerror(j, &re[i], eb, sizeof(eb));                          regerror(j, &re[i], eb, sizeof(eb));
                         errx(EXIT_FAILURE, "regexec: %s: %s", p[i].ps_re, eb);                          errx(1, "regexec: %s: %s", p[i].ps_re, eb);
                 }                  }
         }          }
   
Line 679  print_tree(int *name, u_int namelen, str
Line 676  print_tree(int *name, u_int namelen, str
                 if (p->ps_p == NULL) {                  if (p->ps_p == NULL) {
                         sysctlperror("Cannot print `%s': %s\n", gsname,                          sysctlperror("Cannot print `%s': %s\n", gsname,
                             strerror(EOPNOTSUPP));                              strerror(EOPNOTSUPP));
                         exit(EXIT_FAILURE);                          exit(1);
                 }                  }
                 (*p->ps_p)(gsname, gdname, NULL, name, namelen, pnode, type,                  (*p->ps_p)(gsname, gdname, NULL, name, namelen, pnode, type,
                            __UNCONST(p->ps_d));                             __UNCONST(p->ps_d));
Line 890  parse(char *l, regex_t *re, size_t *last
Line 887  parse(char *l, regex_t *re, size_t *last
                 if (optional)                  if (optional)
                         return;                          return;
                 sysctlparseerror(namelen, l);                  sysctlparseerror(namelen, l);
                 EXIT(EXIT_FAILURE);                  EXIT(1);
         }          }
   
         type = SYSCTL_TYPE(node->sysctl_flags);          type = SYSCTL_TYPE(node->sysctl_flags);
Line 910  parse(char *l, regex_t *re, size_t *last
Line 907  parse(char *l, regex_t *re, size_t *last
   
         if (!wflag) {          if (!wflag) {
                 sysctlperror("Must specify -w to set variables\n");                  sysctlperror("Must specify -w to set variables\n");
                 exit(EXIT_FAILURE);                  exit(1);
         }          }
   
         canonicalize(gsname, canonname);          canonicalize(gsname, canonname);
Line 919  parse(char *l, regex_t *re, size_t *last
Line 916  parse(char *l, regex_t *re, size_t *last
                 if (w->ps_w == NULL) {                  if (w->ps_w == NULL) {
                         sysctlperror("Cannot write `%s': %s\n", gsname,                          sysctlperror("Cannot write `%s': %s\n", gsname,
                             strerror(EOPNOTSUPP));                              strerror(EOPNOTSUPP));
                         exit(EXIT_FAILURE);                          exit(1);
                 }                  }
                 (*w->ps_w)(gsname, gdname, value, name, namelen, node, type,                  (*w->ps_w)(gsname, gdname, value, name, namelen, node, type,
                            __UNCONST(w->ps_d));                             __UNCONST(w->ps_d));
Line 987  parse_create(char *l)
Line 984  parse_create(char *l)
   
         if (!wflag) {          if (!wflag) {
                 sysctlperror("Must specify -w to create nodes\n");                  sysctlperror("Must specify -w to create nodes\n");
                 exit(EXIT_FAILURE);                  exit(1);
         }          }
   
         /*          /*
Line 1068  parse_create(char *l)
Line 1065  parse_create(char *l)
                                     "%s: already have %s for new node\n",                                      "%s: already have %s for new node\n",
                                     nname,                                      nname,
                                     method == CTL_CREATE ? "addr" : "symbol");                                      method == CTL_CREATE ? "addr" : "symbol");
                                 EXIT(EXIT_FAILURE);                                  EXIT(1);
                         }                          }
                         if (value == NULL) {                          if (value == NULL) {
                                 sysctlperror("%s: missing value\n", nname);                                  sysctlperror("%s: missing value\n", nname);
                                 EXIT(EXIT_FAILURE);                                  EXIT(1);
                         }                          }
                         errno = 0;                          errno = 0;
                         addr = (void*)strtoul(value, &t, 0);                          addr = (void*)strtoul(value, &t, 0);
Line 1080  parse_create(char *l)
Line 1077  parse_create(char *l)
                                 sysctlperror(                                  sysctlperror(
                                     "%s: '%s' is not a valid address\n",                                      "%s: '%s' is not a valid address\n",
                                     nname, value);                                      nname, value);
                                 EXIT(EXIT_FAILURE);                                  EXIT(1);
                         }                          }
                         method = CTL_CREATE;                          method = CTL_CREATE;
                 }                  }
Line 1090  parse_create(char *l)
Line 1087  parse_create(char *l)
                                     "%s: already have %s for new node\n",                                      "%s: already have %s for new node\n",
                                     nname,                                      nname,
                                     method == CTL_CREATE ? "addr" : "symbol");                                      method == CTL_CREATE ? "addr" : "symbol");
                                 EXIT(EXIT_FAILURE);                                  EXIT(1);
                         }                          }
                         addr = value;                          addr = value;
                         method = CTL_CREATESYM;                          method = CTL_CREATESYM;
Line 1098  parse_create(char *l)
Line 1095  parse_create(char *l)
                 else if (strcmp(key, "type") == 0) {                  else if (strcmp(key, "type") == 0) {
                         if (value == NULL) {                          if (value == NULL) {
                                 sysctlperror("%s: missing value\n", nname);                                  sysctlperror("%s: missing value\n", nname);
                                 EXIT(EXIT_FAILURE);                                  EXIT(1);
                         }                          }
                         if (strcmp(value, "node") == 0)                          if (strcmp(value, "node") == 0)
                                 type = CTLTYPE_NODE;                                  type = CTLTYPE_NODE;
Line 1122  parse_create(char *l)
Line 1119  parse_create(char *l)
                                 sysctlperror(                                  sysctlperror(
                                         "%s: '%s' is not a valid type\n",                                          "%s: '%s' is not a valid type\n",
                                         nname, value);                                          nname, value);
                                 EXIT(EXIT_FAILURE);                                  EXIT(1);
                         }                          }
                 }                  }
                 else if (strcmp(key, "size") == 0) {                  else if (strcmp(key, "size") == 0) {
                         if (value == NULL) {                          if (value == NULL) {
                                 sysctlperror("%s: missing value\n", nname);                                  sysctlperror("%s: missing value\n", nname);
                                 EXIT(EXIT_FAILURE);                                  EXIT(1);
                         }                          }
                         errno = 0;                          errno = 0;
                         /*                          /*
Line 1141  parse_create(char *l)
Line 1138  parse_create(char *l)
                                 sysctlperror(                                  sysctlperror(
                                         "%s: '%s' is not a valid size\n",                                          "%s: '%s' is not a valid size\n",
                                         nname, value);                                          nname, value);
                                 EXIT(EXIT_FAILURE);                                  EXIT(1);
                         }                          }
                 }                  }
                 else if (strcmp(key, "n") == 0) {                  else if (strcmp(key, "n") == 0) {
                         if (value == NULL) {                          if (value == NULL) {
                                 sysctlperror("%s: missing value\n", nname);                                  sysctlperror("%s: missing value\n", nname);
                                 EXIT(EXIT_FAILURE);                                  EXIT(1);
                         }                          }
                         errno = 0;                          errno = 0;
                         q = strtoll(value, &t, 0);                          q = strtoll(value, &t, 0);
Line 1156  parse_create(char *l)
Line 1153  parse_create(char *l)
                                 sysctlperror(                                  sysctlperror(
                                     "%s: '%s' is not a valid mib number\n",                                      "%s: '%s' is not a valid mib number\n",
                                     nname, value);                                      nname, value);
                                 EXIT(EXIT_FAILURE);                                  EXIT(1);
                         }                          }
                         node.sysctl_num = (int)q;                          node.sysctl_num = (int)q;
                 }                  }
                 else if (strcmp(key, "flags") == 0) {                  else if (strcmp(key, "flags") == 0) {
                         if (value == NULL) {                          if (value == NULL) {
                                 sysctlperror("%s: missing value\n", nname);                                  sysctlperror("%s: missing value\n", nname);
                                 EXIT(EXIT_FAILURE);                                  EXIT(1);
                         }                          }
                         t = value;                          t = value;
                         while (*t != '\0') {                          while (*t != '\0') {
Line 1200  parse_create(char *l)
Line 1197  parse_create(char *l)
                                         sysctlperror(                                          sysctlperror(
                                            "%s: '%c' is not a valid flag\n",                                             "%s: '%c' is not a valid flag\n",
                                             nname, *t);                                              nname, *t);
                                         EXIT(EXIT_FAILURE);                                          EXIT(1);
                                 }                                  }
                                 t++;                                  t++;
                         }                          }
Line 1208  parse_create(char *l)
Line 1205  parse_create(char *l)
                 else {                  else {
                         sysctlperror("%s: unrecognized keyword '%s'\n",                          sysctlperror("%s: unrecognized keyword '%s'\n",
                                      nname, key);                                       nname, key);
                         EXIT(EXIT_FAILURE);                          EXIT(1);
                 }                  }
         }          }
   
Line 1228  parse_create(char *l)
Line 1225  parse_create(char *l)
                         sysctlperror(                          sysctlperror(
                                 "%s: cannot specify both value and "                                  "%s: cannot specify both value and "
                                 "address\n", nname);                                  "address\n", nname);
                         EXIT(EXIT_FAILURE);                          EXIT(1);
                 }                  }
   
                 switch (type) {                  switch (type) {
Line 1240  parse_create(char *l)
Line 1237  parse_create(char *l)
                                 sysctlperror(                                  sysctlperror(
                                     "%s: '%s' is not a valid integer\n",                                      "%s: '%s' is not a valid integer\n",
                                     nname, value);                                      nname, value);
                                 EXIT(EXIT_FAILURE);                                  EXIT(1);
                         }                          }
                         i = (int)q;                          i = (int)q;
                         if (!(flags & CTLFLAG_OWNDATA)) {                          if (!(flags & CTLFLAG_OWNDATA)) {
Line 1260  parse_create(char *l)
Line 1257  parse_create(char *l)
                                 sysctlperror(                                  sysctlperror(
                                     "%s: '%s' is not a valid bool\n",                                      "%s: '%s' is not a valid bool\n",
                                     nname, value);                                      nname, value);
                                 EXIT(EXIT_FAILURE);                                  EXIT(1);
                         }                          }
                         b = q == 1;                          b = q == 1;
                         if (!(flags & CTLFLAG_OWNDATA)) {                          if (!(flags & CTLFLAG_OWNDATA)) {
Line 1291  parse_create(char *l)
Line 1288  parse_create(char *l)
                                 sysctlperror(                                  sysctlperror(
                                         "%s: '%s' is not a valid quad\n",                                          "%s: '%s' is not a valid quad\n",
                                         nname, value);                                          nname, value);
                                 EXIT(EXIT_FAILURE);                                  EXIT(1);
                         }                          }
                         if (!(flags & CTLFLAG_OWNDATA)) {                          if (!(flags & CTLFLAG_OWNDATA)) {
                                 flags |= CTLFLAG_IMMEDIATE;                                  flags |= CTLFLAG_IMMEDIATE;
Line 1305  parse_create(char *l)
Line 1302  parse_create(char *l)
                 case CTLTYPE_STRUCT:                  case CTLTYPE_STRUCT:
                         sysctlperror("%s: struct not initializable\n",                          sysctlperror("%s: struct not initializable\n",
                                      nname);                                       nname);
                         EXIT(EXIT_FAILURE);                          EXIT(1);
                 }                  }
   
                 /*                  /*
Line 1330  parse_create(char *l)
Line 1327  parse_create(char *l)
                         sysctlperror(                          sysctlperror(
                             "%s: need a size or a starting value\n",                              "%s: need a size or a starting value\n",
                             nname);                              nname);
                         EXIT(EXIT_FAILURE);                          EXIT(1);
                 }                  }
                 if (!(flags & CTLFLAG_IMMEDIATE))                  if (!(flags & CTLFLAG_IMMEDIATE))
                         flags |= CTLFLAG_OWNDATA;                          flags |= CTLFLAG_OWNDATA;
Line 1345  parse_create(char *l)
Line 1342  parse_create(char *l)
                 sysctlperror("%s: cannot make an immediate %s\n",                  sysctlperror("%s: cannot make an immediate %s\n",
                              nname,                               nname,
                              (type == CTLTYPE_STRING) ? "string" : "struct");                               (type == CTLTYPE_STRING) ? "string" : "struct");
                 EXIT(EXIT_FAILURE);                  EXIT(1);
         }          }
         if (type == CTLTYPE_NODE && node.sysctl_data != NULL) {          if (type == CTLTYPE_NODE && node.sysctl_data != NULL) {
                 sysctlperror("%s: nodes do not have data\n", nname);                  sysctlperror("%s: nodes do not have data\n", nname);
                 EXIT(EXIT_FAILURE);                  EXIT(1);
         }          }
   
         /*          /*
Line 1361  parse_create(char *l)
Line 1358  parse_create(char *l)
                     (type == CTLTYPE_QUAD && sz != sizeof(u_quad_t)) ||                      (type == CTLTYPE_QUAD && sz != sizeof(u_quad_t)) ||
                     (type == CTLTYPE_NODE && sz != 0)) {                      (type == CTLTYPE_NODE && sz != 0)) {
                         sysctlperror("%s: wrong size for type\n", nname);                          sysctlperror("%s: wrong size for type\n", nname);
                         EXIT(EXIT_FAILURE);                          EXIT(1);
                 }                  }
         }          }
         else if (type == CTLTYPE_STRUCT) {          else if (type == CTLTYPE_STRUCT) {
                 sysctlperror("%s: struct must have size\n", nname);                  sysctlperror("%s: struct must have size\n", nname);
                 EXIT(EXIT_FAILURE);                  EXIT(1);
         }          }
   
         /*          /*
Line 1387  parse_create(char *l)
Line 1384  parse_create(char *l)
          * writeable by us.           * writeable by us.
         if (rw != CTLFLAG_READONLY && addr) {          if (rw != CTLFLAG_READONLY && addr) {
                 sysctlperror("%s: kernel data can only be readable\n", nname);                  sysctlperror("%s: kernel data can only be readable\n", nname);
                 EXIT(EXIT_FAILURE);                  EXIT(1);
         }          }
          */           */
   
Line 1435  parse_create(char *l)
Line 1432  parse_create(char *l)
                 *t = sep[0];                  *t = sep[0];
                 if (rc == -1) {                  if (rc == -1) {
                         sysctlparseerror(namelen, nname);                          sysctlparseerror(namelen, nname);
                         EXIT(EXIT_FAILURE);                          EXIT(1);
                 }                  }
         }          }
   
Line 1453  parse_create(char *l)
Line 1450  parse_create(char *l)
         if (rc == -1) {          if (rc == -1) {
                 sysctlperror("%s: CTL_CREATE failed: %s\n",                  sysctlperror("%s: CTL_CREATE failed: %s\n",
                              nname, strerror(errno));                               nname, strerror(errno));
                 EXIT(EXIT_FAILURE);                  EXIT(1);
         }          }
         else {          else {
                 if (!qflag && !nflag)                  if (!qflag && !nflag)
Line 1472  parse_destroy(char *l)
Line 1469  parse_destroy(char *l)
   
         if (!wflag) {          if (!wflag) {
                 sysctlperror("Must specify -w to destroy nodes\n");                  sysctlperror("Must specify -w to destroy nodes\n");
                 exit(EXIT_FAILURE);                  exit(1);
         }          }
   
         memset(name, 0, sizeof(name));          memset(name, 0, sizeof(name));
Line 1482  parse_destroy(char *l)
Line 1479  parse_destroy(char *l)
                               SYSCTL_VERSION);                                SYSCTL_VERSION);
         if (rc == -1) {          if (rc == -1) {
                 sysctlparseerror(namelen, l);                  sysctlparseerror(namelen, l);
                 EXIT(EXIT_FAILURE);                  EXIT(1);
         }          }
   
         memset(&node, 0, sizeof(node));          memset(&node, 0, sizeof(node));
Line 1496  parse_destroy(char *l)
Line 1493  parse_destroy(char *l)
         if (rc == -1) {          if (rc == -1) {
                 sysctlperror("%s: CTL_DESTROY failed: %s\n",                  sysctlperror("%s: CTL_DESTROY failed: %s\n",
                              l, strerror(errno));                               l, strerror(errno));
                 EXIT(EXIT_FAILURE);                  EXIT(1);
         }          }
         else {          else {
                 if (!qflag && !nflag)                  if (!qflag && !nflag)
Line 1518  parse_describe(char *l)
Line 1515  parse_describe(char *l)
   
         if (!wflag) {          if (!wflag) {
                 sysctlperror("Must specify -w to set descriptions\n");                  sysctlperror("Must specify -w to set descriptions\n");
                 exit(EXIT_FAILURE);                  exit(1);
         }          }
   
         value = strchr(l, '=');          value = strchr(l, '=');
Line 1531  parse_describe(char *l)
Line 1528  parse_describe(char *l)
                               SYSCTL_VERSION);                                SYSCTL_VERSION);
         if (rc == -1) {          if (rc == -1) {
                 sysctlparseerror(namelen, l);                  sysctlparseerror(namelen, l);
                 EXIT(EXIT_FAILURE);                  EXIT(1);
         }          }
   
         sz = sizeof(buf);          sz = sizeof(buf);
Line 1573  usage(void)
Line 1570  usage(void)
                       progname, "[-dne] -A",                        progname, "[-dne] -A",
                       progname, "[-ne] -M",                        progname, "[-ne] -M",
                       progname, "[-dne] [-q] -f file");                        progname, "[-dne] [-q] -f file");
         exit(EXIT_FAILURE);          exit(1);
 }  }
   
 static void  static void
Line 1616  getdesc(int *name, u_int namelen, struct
Line 1613  getdesc(int *name, u_int namelen, struct
         struct sysctlnode *node = pnode->sysctl_child;          struct sysctlnode *node = pnode->sysctl_child;
         struct sysctldesc *d, *p, *plim;          struct sysctldesc *d, *p, *plim;
         char *desc;          char *desc;
         size_t i, sz, child_cnt;          size_t i, sz;
         int rc;          int rc;
   
         sz = 128 * pnode->sysctl_clen;          sz = 128 * pnode->sysctl_clen;
Line 1647  getdesc(int *name, u_int namelen, struct
Line 1644  getdesc(int *name, u_int namelen, struct
          * suffice for now           * suffice for now
          */           */
         plim = /*LINTED ptr cast*/(struct sysctldesc *)((char*)d + sz);          plim = /*LINTED ptr cast*/(struct sysctldesc *)((char*)d + sz);
         child_cnt = (pnode->sysctl_flags & CTLTYPE_NODE) ? pnode->sysctl_clen          for (i = 0; i < pnode->sysctl_clen; i++) {
             : 0;  
         for (i = 0; i < child_cnt; i++) {  
                 node = &pnode->sysctl_child[i];                  node = &pnode->sysctl_child[i];
                 for (p = d; p < plim; p = NEXT_DESCR(p))                  for (p = d; p < plim; p = NEXT_DESCR(p))
                         if (node->sysctl_num == p->descr_num)                          if (node->sysctl_num == p->descr_num)
Line 1710  sysctlerror(int soft)
Line 1705  sysctlerror(int soft)
         if (Aflag || req)          if (Aflag || req)
                 sysctlperror("%s: %s\n", gsname, strerror(errno));                  sysctlperror("%s: %s\n", gsname, strerror(errno));
         if (!soft)          if (!soft)
                 EXIT(EXIT_FAILURE);                  EXIT(1);
 }  }
   
 void  void
Line 1766  write_number(int *name, u_int namelen, s
Line 1761  write_number(int *name, u_int namelen, s
         qi = strtouq(value, &t, 0);          qi = strtouq(value, &t, 0);
         if (qi == UQUAD_MAX && errno == ERANGE) {          if (qi == UQUAD_MAX && errno == ERANGE) {
                 sysctlperror("%s: %s\n", value, strerror(errno));                  sysctlperror("%s: %s\n", value, strerror(errno));
                 EXIT(EXIT_FAILURE);                  EXIT(1);
         }          }
         if (t == value || *t != '\0') {          if (t == value || *t != '\0') {
                 sysctlperror("%s: not a number\n", value);                  sysctlperror("%s: not a number\n", value);
                 EXIT(EXIT_FAILURE);                  EXIT(1);
         }          }
   
         switch (SYSCTL_TYPE(node->sysctl_flags)) {          switch (SYSCTL_TYPE(node->sysctl_flags)) {
Line 1779  write_number(int *name, u_int namelen, s
Line 1774  write_number(int *name, u_int namelen, s
                 io = (u_int)(qi >> 32);                  io = (u_int)(qi >> 32);
                 if (io != (u_int)-1 && io != 0) {                  if (io != (u_int)-1 && io != 0) {
                         sysctlperror("%s: %s\n", value, strerror(ERANGE));                          sysctlperror("%s: %s\n", value, strerror(ERANGE));
                         EXIT(EXIT_FAILURE);                          EXIT(1);
                 }                  }
                 o = &io;                  o = &io;
                 so = sizeof(io);                  so = sizeof(io);
Line 1835  write_string(int *name, u_int namelen, s
Line 1830  write_string(int *name, u_int namelen, s
         so = node->sysctl_size;          so = node->sysctl_size;
         if (si > so && so != 0) {          if (si > so && so != 0) {
                 sysctlperror("%s: string too long\n", value);                  sysctlperror("%s: string too long\n", value);
                 EXIT(EXIT_FAILURE);                  EXIT(1);
         }          }
         o = malloc(so);          o = malloc(so);
         if (o == NULL) {          if (o == NULL) {
                 sysctlperror("%s: !malloc failed!\n", gsname);                  sysctlperror("%s: !malloc failed!\n", gsname);
                 exit(EXIT_FAILURE);                  exit(1);
         }          }
   
         rc = prog_sysctl(name, namelen, o, &so, i, si);          rc = prog_sysctl(name, namelen, o, &so, i, si);
Line 2153  kern_clockrate(HANDLER_ARGS)
Line 2148  kern_clockrate(HANDLER_ARGS)
                 return;                  return;
         }          }
         if (sz != sizeof(clkinfo))          if (sz != sizeof(clkinfo))
                 errx(EXIT_FAILURE, "%s: !returned size wrong!", sname);                  errx(1, "%s: !returned size wrong!", sname);
   
         if (xflag || rflag) {          if (xflag || rflag) {
                 display_struct(pnode, sname, &clkinfo, sz,                  display_struct(pnode, sname, &clkinfo, sz,
Line 2183  kern_boottime(HANDLER_ARGS)
Line 2178  kern_boottime(HANDLER_ARGS)
                 return;                  return;
         }          }
         if (sz != sizeof(timeval))          if (sz != sizeof(timeval))
                 errx(EXIT_FAILURE, "%s: !returned size wrong!", sname);                  errx(1, "%s: !returned size wrong!", sname);
   
         boottime = timeval.tv_sec;          boottime = timeval.tv_sec;
         if (xflag || rflag)          if (xflag || rflag)
Line 2214  kern_consdev(HANDLER_ARGS)
Line 2209  kern_consdev(HANDLER_ARGS)
                 return;                  return;
         }          }
         if (sz != sizeof(cons))          if (sz != sizeof(cons))
                 errx(EXIT_FAILURE, "%s: !returned size wrong!", sname);                  errx(1, "%s: !returned size wrong!", sname);
   
         if (xflag || rflag)          if (xflag || rflag)
                 display_struct(pnode, sname, &cons, sz,                  display_struct(pnode, sname, &cons, sz,
Line 2279  kern_cp_time(HANDLER_ARGS)
Line 2274  kern_cp_time(HANDLER_ARGS)
          * Check, but account for space we'll occupy with the sum.           * Check, but account for space we'll occupy with the sum.
          */           */
         if (osz != sz - (n != -1) * CPUSTATES * sizeof(u_int64_t))          if (osz != sz - (n != -1) * CPUSTATES * sizeof(u_int64_t))
                 errx(EXIT_FAILURE, "%s: !returned size wrong!", sname);                  errx(1, "%s: !returned size wrong!", sname);
   
         /*          /*
          * Compute the actual sum.  Two calls would be easier (we           * Compute the actual sum.  Two calls would be easier (we
Line 2349  kern_drivers(HANDLER_ARGS)
Line 2344  kern_drivers(HANDLER_ARGS)
         }          }
   
         if (sz % sizeof(*kd))          if (sz % sizeof(*kd))
                 err(EXIT_FAILURE, "bad size %zu for kern.drivers", sz);                  err(1, "bad size %zu for kern.drivers", sz);
   
         kd = malloc(sz);          kd = malloc(sz);
         if (kd == NULL) {          if (kd == NULL) {
Line 2360  kern_drivers(HANDLER_ARGS)
Line 2355  kern_drivers(HANDLER_ARGS)
         rc = prog_sysctl(name, namelen, kd, &sz, NULL, 0);          rc = prog_sysctl(name, namelen, kd, &sz, NULL, 0);
         if (rc == -1) {          if (rc == -1) {
                 sysctlerror(1);                  sysctlerror(1);
                 free(kd);  
                 return;                  return;
         }          }
   
Line 2424  kern_cp_id(HANDLER_ARGS)
Line 2418  kern_cp_id(HANDLER_ARGS)
          * Check that we got back what we asked for.           * Check that we got back what we asked for.
          */           */
         if (osz != sz)          if (osz != sz)
                 errx(EXIT_FAILURE, "%s: !returned size wrong!", sname);                  errx(1, "%s: !returned size wrong!", sname);
   
         /* pretend for output purposes */          /* pretend for output purposes */
         node.sysctl_flags = SYSCTL_FLAGS(pnode->sysctl_flags) |          node.sysctl_flags = SYSCTL_FLAGS(pnode->sysctl_flags) |
Line 2476  vm_loadavg(HANDLER_ARGS)
Line 2470  vm_loadavg(HANDLER_ARGS)
                 return;                  return;
         }          }
         if (sz != sizeof(loadavg))          if (sz != sizeof(loadavg))
                 errx(EXIT_FAILURE, "%s: !returned size wrong!", sname);                  errx(1, "%s: !returned size wrong!", sname);
   
         if (xflag || rflag) {          if (xflag || rflag) {
                 display_struct(pnode, sname, &loadavg, sz,                  display_struct(pnode, sname, &loadavg, sz,
Line 2515  proc_limit(HANDLER_ARGS)
Line 2509  proc_limit(HANDLER_ARGS)
                         if (t == value || *t != '\0' || errno != 0) {                          if (t == value || *t != '\0' || errno != 0) {
                                 sysctlperror("%s: '%s' is not a valid limit\n",                                  sysctlperror("%s: '%s' is not a valid limit\n",
                                              sname, value);                                               sname, value);
                                 EXIT(EXIT_FAILURE);                                  EXIT(1);
                         }                          }
                 }                  }
         }          }
Line 2644  mode_bits(HANDLER_ARGS)
Line 2638  mode_bits(HANDLER_ARGS)
                 if (foo == NULL) {                  if (foo == NULL) {
                         sysctlperror("%s: '%s' is an invalid mode\n", sname,                          sysctlperror("%s: '%s' is an invalid mode\n", sname,
                                      value);                                       value);
                         EXIT(EXIT_FAILURE);                          EXIT(1);
                 }                  }
                 old_umask = umask(0);                  old_umask = umask(0);
                 m = getmode(foo, (mode_t)tt);                  m = getmode(foo, (mode_t)tt);
Line 2652  mode_bits(HANDLER_ARGS)
Line 2646  mode_bits(HANDLER_ARGS)
                 if (errno) {                  if (errno) {
                         sysctlperror("%s: '%s' is an invalid mode\n", sname,                          sysctlperror("%s: '%s' is an invalid mode\n", sname,
                                      value);                                       value);
                         EXIT(EXIT_FAILURE);                          EXIT(1);
                 }                  }
         }          }
         else {          else {
Line 2695  mode_bits(HANDLER_ARGS)
Line 2689  mode_bits(HANDLER_ARGS)
         }          }
 }  }
   
 typedef __BITMAP_TYPE(, uint32_t, 0x10000) bitmap;  
   
 static char *  static char *
 bitmask_print(const bitmap *o)  bitmask_print(const fd_set *o)
 {  {
         char *s, *os;          char *s, *os;
   
         s = os = NULL;          s = os = NULL;
         for (size_t i = 0; i < MAXPORTS; i++)          for (size_t i = 0; i < FD_SETSIZE; i++)
                 if (__BITMAP_ISSET(i, o)) {                  if (FD_ISSET(i, o)) {
                         int rv;                          int rv;
   
                         if (os)                          if (os)
Line 2712  bitmask_print(const bitmap *o)
Line 2704  bitmask_print(const bitmap *o)
                         else                          else
                                 rv = asprintf(&s, "%zu", i);                                  rv = asprintf(&s, "%zu", i);
                         if (rv == -1)                          if (rv == -1)
                                 err(EXIT_FAILURE, "%s 1", __func__);                                  err(1, "");
                         free(os);                          free(os);
                         os = s;                          os = s;
                 }                  }
         if (s == NULL && (s = strdup("")) == NULL)          if (s == NULL && (s = strdup("")) == NULL)
                 err(EXIT_FAILURE, "%s 2", __func__);                  err(1, "");
         return s;          return s;
 }  }
   
 static void  static void
 bitmask_scan(const void *v, bitmap *o)  bitmask_scan(const void *v, fd_set *o)
 {  {
         char *s = strdup(v);          char *s = strdup(v);
         if (s == NULL)          if (s == NULL)
                 err(EXIT_FAILURE, "%s", __func__);                  err(1, "");
           FD_ZERO(o);
         __BITMAP_ZERO(o);  
         for (s = strtok(s, ","); s; s = strtok(NULL, ",")) {          for (s = strtok(s, ","); s; s = strtok(NULL, ",")) {
                 char *e;                  char *e;
                 errno = 0;                  errno = 0;
                 unsigned long l = strtoul(s, &e, 0);                  unsigned long l = strtoul(s, &e, 0);
                 if ((l == ULONG_MAX && errno == ERANGE) || s == e || *e)                  if ((l == ULONG_MAX && errno == ERANGE) || s == e || *e)
                         errx(EXIT_FAILURE, "Invalid port: %s", s);                          errx(1, "Invalid port: %s", s);
                 if (l >= MAXPORTS)                  if (l >= FD_SETSIZE)
                         errx(EXIT_FAILURE, "Port out of range: %s", s);                          errx(1, "Port out of range: %s", s);
                 __BITMAP_SET(l, o);                  FD_SET(l, o);
         }          }
 }  }
   
Line 2747  reserve(HANDLER_ARGS)
Line 2738  reserve(HANDLER_ARGS)
 {  {
         int rc;          int rc;
         size_t osz, nsz;          size_t osz, nsz;
         bitmap o, n;          fd_set o, n;
   
         if (fn)          if (fn)
                 trim_whitespace(value, 3);                  trim_whitespace(value, 3);

Legend:
Removed from v.1.143.2.2  
changed lines
  Added in v.1.144

CVSweb <webmaster@jp.NetBSD.org>