lib/libjail/jail.c

   1 /*-
   2  * Copyright (c) 2009 James Gritton.
   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 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31 #include <sys/types.h>
  32 #include <sys/jail.h>
  33 #include <sys/socket.h>
  34 #include <sys/sysctl.h>
  35
  36 #include <arpa/inet.h>
  37 #include <netinet/in.h>
  38
  39 #include <errno.h>
  40 #include <inttypes.h>
  41 #include <stdio.h>
  42 #include <stdarg.h>
  43 #include <stdlib.h>
  44 #include <string.h>
  45
  46 #include "jail.h"
  47
  48 #define SJPARAM         "security.jail.param"
  49
  50 #define JPS_IN_ADDR     1
  51 #define JPS_IN6_ADDR    2
  52
  53 #define ARRAY_SANITY    5
  54 #define ARRAY_SLOP      5
  55
  56
  57 static int jailparam_import_enum(const char **values, int nvalues,
  58     const char *valstr, size_t valsize, int *value);
  59 static int jailparam_type(struct jailparam *jp);
  60 static char *noname(const char *name);
  61 static char *nononame(const char *name);
  62
  63 char jail_errmsg[JAIL_ERRMSGLEN];
  64
  65 static const char *bool_values[] = { "false", "true" };
  66 static const char *jailsys_values[] = { "disable", "new", "inherit" };
  67
  68
  69 /*
  70  * Import a null-terminated parameter list and set a jail with the flags
  71  * and parameters.
  72  */
  73 int
  74 jail_setv(int flags, ...)
  75 {
  76         va_list ap, tap;
  77         struct jailparam *jp;
  78         const char *name, *value;
  79         int njp, jid;
  80
  81         /* Create the parameter list and import the parameters. */
  82         va_start(ap, flags);
  83         va_copy(tap, ap);
  84         for (njp = 0; va_arg(tap, char *) != NULL; njp++)
  85                 (void)va_arg(tap, char *);
  86         va_end(tap);
  87         jp = alloca(njp * sizeof(struct jailparam));
  88         for (njp = 0; (name = va_arg(ap, char *)) != NULL; njp++) {
  89                 value = va_arg(ap, char *);
  90                 if (jailparam_init(jp + njp, name) < 0 ||
  91                     jailparam_import(jp + njp, value) < 0) {
  92                         jailparam_free(jp, njp);
  93                         va_end(ap);
  94                         return (-1);
  95                 }
  96         }
  97         va_end(ap);
  98         jid = jailparam_set(jp, njp, flags);
  99         jailparam_free(jp, njp);
 100         return (jid);
 101 }
 102
 103 /*
 104  * Read a null-terminated parameter list, get the referenced jail, and export
 105  * the parameters to the list.
 106  */
 107 int
 108 jail_getv(int flags, ...)
 109 {
 110         va_list ap, tap;
 111         struct jailparam *jp, *jp_lastjid, *jp_jid, *jp_name, *jp_key;
 112         char *valarg, *value;
 113         const char *name, *key_value, *lastjid_value, *jid_value, *name_value;
 114         int njp, i, jid;
 115
 116         /* Create the parameter list and find the key. */
 117         va_start(ap, flags);
 118         va_copy(tap, ap);
 119         for (njp = 0; va_arg(tap, char *) != NULL; njp++)
 120                 (void)va_arg(tap, char *);
 121         va_end(tap);
 122
 123         jp = alloca(njp * sizeof(struct jailparam));
 124         va_copy(tap, ap);
 125         jp_lastjid = jp_jid = jp_name = NULL;
 126         lastjid_value = jid_value = name_value = NULL;
 127         for (njp = 0; (name = va_arg(tap, char *)) != NULL; njp++) {
 128                 value = va_arg(tap, char *);
 129                 if (jailparam_init(jp + njp, name) < 0) {
 130                         va_end(tap);
 131                         goto error;
 132                 }
 133                 if (!strcmp(jp[njp].jp_name, "lastjid")) {
 134                         jp_lastjid = jp + njp;
 135                         lastjid_value = value;
 136                 } else if (!strcmp(jp[njp].jp_name, "jid")) {
 137                         jp_jid = jp + njp;
 138                         jid_value = value;
 139                 } if (!strcmp(jp[njp].jp_name, "name")) {
 140                         jp_name = jp + njp;
 141                         name_value = value;
 142                 }
 143         }
 144         va_end(tap);
 145         /* Import the key parameter. */
 146         if (jp_lastjid != NULL) {
 147                 jp_key = jp_lastjid;
 148                 key_value = lastjid_value;
 149         } else if (jp_jid != NULL && strtol(jid_value, NULL, 10) != 0) {
 150                 jp_key = jp_jid;
 151                 key_value = jid_value;
 152         } else if (jp_name != NULL) {
 153                 jp_key = jp_name;
 154                 key_value = name_value;
 155         } else {
 156                 strlcpy(jail_errmsg, "no jail specified", JAIL_ERRMSGLEN);
 157                 errno = ENOENT;
 158                 goto error;
 159         }
 160         if (jailparam_import(jp_key, key_value) < 0)
 161                 goto error;
 162         /* Get the jail and export the parameters. */
 163         jid = jailparam_get(jp, njp, flags);
 164         if (jid < 0)
 165                 goto error;
 166         for (i = 0; i < njp; i++) {
 167                 (void)va_arg(ap, char *);
 168                 valarg = va_arg(ap, char *);
 169                 if (jp + i != jp_key) {
 170                         /* It's up to the caller to ensure there's room. */
 171                         if ((jp[i].jp_ctltype & CTLTYPE) == CTLTYPE_STRING)
 172                                 strcpy(valarg, jp[i].jp_value);
 173                         else {
 174                                 value = jailparam_export(jp + i);
 175                                 if (value == NULL)
 176                                         goto error;
 177                                 strcpy(valarg, value);
 178                                 free(value);
 179                         }
 180                 }
 181         }
 182         jailparam_free(jp, njp);
 183         va_end(ap);
 184         return (jid);
 185
 186  error:
 187         jailparam_free(jp, njp);
 188         va_end(ap);
 189         return (-1);
 190 }
 191
 192 /*
 193  * Return a list of all known parameters.
 194  */
 195 int
 196 jailparam_all(struct jailparam **jpp)
 197 {
 198         struct jailparam *jp;
 199         size_t mlen1, mlen2, buflen;
 200         int njp, nlist;
 201         int mib1[CTL_MAXNAME], mib2[CTL_MAXNAME - 2];
 202         char buf[MAXPATHLEN];
 203
 204         njp = 0;
 205         nlist = 32;
 206         jp = malloc(nlist * sizeof(*jp));
 207         if (jp == NULL) {
 208                 strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);
 209                 return (-1);
 210         }
 211         mib1[0] = 0;
 212         mib1[1] = 2;
 213         mlen1 = CTL_MAXNAME - 2;
 214         if (sysctlnametomib(SJPARAM, mib1 + 2, &mlen1) < 0) {
 215                 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
 216                     "sysctlnametomib(" SJPARAM "): %s", strerror(errno));
 217                 goto error;
 218         }
 219         for (;; njp++) {
 220                 /* Get the next parameter. */
 221                 mlen2 = sizeof(mib2);
 222                 if (sysctl(mib1, mlen1 + 2, mib2, &mlen2, NULL, 0) < 0) {
 223                         snprintf(jail_errmsg, JAIL_ERRMSGLEN,
 224                             "sysctl(0.2): %s", strerror(errno));
 225                         goto error;
 226                 }
 227                 if (mib2[0] != mib1[2] || mib2[1] != mib1[3] ||
 228                     mib2[2] != mib1[4])
 229                         break;
 230                 /* Convert it to an ascii name. */
 231                 memcpy(mib1 + 2, mib2, mlen2);
 232                 mlen1 = mlen2 / sizeof(int);
 233                 mib1[1] = 1;
 234                 buflen = sizeof(buf);
 235                 if (sysctl(mib1, mlen1 + 2, buf, &buflen, NULL, 0) < 0) {
 236                         snprintf(jail_errmsg, JAIL_ERRMSGLEN,
 237                             "sysctl(0.1): %s", strerror(errno));
 238                         goto error;
 239                 }
 240                 if (buf[buflen - 2] == '.')
 241                         buf[buflen - 2] = '\0';
 242                 /* Add the parameter to the list */
 243                 if (njp >= nlist) {
 244                         nlist *= 2;
 245                         jp = realloc(jp, nlist * sizeof(*jp));
 246                         if (jp == NULL) {
 247                                 jailparam_free(jp, njp);
 248                                 return (-1);
 249                         }
 250                 }
 251                 if (jailparam_init(jp + njp, buf + sizeof(SJPARAM)) < 0)
 252                         goto error;
 253                 mib1[1] = 2;
 254         }
 255         jp = realloc(jp, njp * sizeof(*jp));
 256         *jpp = jp;
 257         return (njp);
 258
 259  error:
 260         jailparam_free(jp, njp);
 261         free(jp);
 262         return (-1);
 263 }
 264
 265 /*
 266  * Clear a jail parameter and copy in its name.
 267  */
 268 int
 269 jailparam_init(struct jailparam *jp, const char *name)
 270 {
 271
 272         memset(jp, 0, sizeof(*jp));
 273         jp->jp_name = strdup(name);
 274         if (jp->jp_name == NULL) {
 275                 strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);
 276                 return (-1);
 277         }
 278         if (jailparam_type(jp) < 0) {
 279                 jailparam_free(jp, 1);
 280                 return (-1);
 281         }
 282         return (0);
 283 }
 284
 285 /*
 286  * Put a name and value into a jail parameter element, converting the value
 287  * to internal form.
 288  */
 289 int
 290 jailparam_import(struct jailparam *jp, const char *value)
 291 {
 292         char *p, *ep, *tvalue;
 293         const char *avalue;
 294         int i, nval, fw;
 295
 296         if (value == NULL)
 297                 return (0);
 298         if ((jp->jp_ctltype & CTLTYPE) == CTLTYPE_STRING) {
 299                 jp->jp_value = strdup(value);
 300                 if (jp->jp_value == NULL) {
 301                         strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);
 302                         return (-1);
 303                 }
 304                 return (0);
 305         }
 306         nval = 1;
 307         if (jp->jp_elemlen) {
 308                 if (value[0] == '\0' || (value[0] == '-' && value[1] == '\0')) {
 309                         jp->jp_value = strdup("");
 310                         if (jp->jp_value == NULL) {
 311                                 strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);
 312                                 return (-1);
 313                         }
 314                         jp->jp_valuelen = 0;
 315                         return (0);
 316                 }
 317                 for (p = strchr(value, ','); p; p = strchr(p + 1, ','))
 318                         nval++;
 319                 jp->jp_valuelen = jp->jp_elemlen * nval;
 320         }
 321         jp->jp_value = malloc(jp->jp_valuelen);
 322         if (jp->jp_value == NULL) {
 323                 strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);
 324                 return (-1);
 325         }
 326         avalue = value;
 327         for (i = 0; i < nval; i++) {
 328                 fw = nval == 1 ? strlen(avalue) : strcspn(avalue, ",");
 329                 switch (jp->jp_ctltype & CTLTYPE) {
 330                 case CTLTYPE_INT:
 331                         if (jp->jp_flags & (JP_BOOL | JP_NOBOOL)) {
 332                                 if (!jailparam_import_enum(bool_values, 2,
 333                                     avalue, fw, &((int *)jp->jp_value)[i])) {
 334                                         snprintf(jail_errmsg,
 335                                             JAIL_ERRMSGLEN, "%s: "
 336                                             "unknown boolean value \"%.*s\"",
 337                                             jp->jp_name, fw, avalue);
 338                                         errno = EINVAL;
 339                                         goto error;
 340                                 }
 341                                 break;
 342                         }
 343                         if (jp->jp_flags & JP_JAILSYS) {
 344                                 /*
 345                                  * Allow setting a jailsys parameter to "new"
 346                                  * in a booleanesque fashion.
 347                                  */
 348                                 if (value[0] == '\0')
 349                                         ((int *)jp->jp_value)[i] = JAIL_SYS_NEW;
 350                                 else if (!jailparam_import_enum(jailsys_values,
 351                                     sizeof(jailsys_values) /
 352                                     sizeof(jailsys_values[0]), avalue, fw,
 353                                     &((int *)jp->jp_value)[i])) {
 354                                         snprintf(jail_errmsg,
 355                                             JAIL_ERRMSGLEN, "%s: "
 356                                             "unknown jailsys value \"%.*s\"",
 357                                             jp->jp_name, fw, avalue);
 358                                         errno = EINVAL;
 359                                         goto error;
 360                                 }
 361                                 break;
 362                         }
 363                         ((int *)jp->jp_value)[i] = strtol(avalue, &ep, 10);
 364                 integer_test:
 365                         if (ep != avalue + fw) {
 366                                 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
 367                                     "%s: non-integer value \"%.*s\"",
 368                                     jp->jp_name, fw, avalue);
 369                                 errno = EINVAL;
 370                                 goto error;
 371                         }
 372                         break;
 373                 case CTLTYPE_UINT:
 374                         ((unsigned *)jp->jp_value)[i] =
 375                             strtoul(avalue, &ep, 10);
 376                         goto integer_test;
 377                 case CTLTYPE_LONG:
 378                         ((long *)jp->jp_value)[i] = strtol(avalue, &ep, 10);
 379                         goto integer_test;
 380                 case CTLTYPE_ULONG:
 381                         ((unsigned long *)jp->jp_value)[i] =
 382                             strtoul(avalue, &ep, 10);
 383                         goto integer_test;
 384                 case CTLTYPE_QUAD:
 385                         ((int64_t *)jp->jp_value)[i] =
 386                             strtoimax(avalue, &ep, 10);
 387                         goto integer_test;
 388                 case CTLTYPE_STRUCT:
 389                         tvalue = alloca(fw + 1);
 390                         strlcpy(tvalue, avalue, fw + 1);
 391                         switch (jp->jp_structtype) {
 392                         case JPS_IN_ADDR:
 393                                 if (inet_pton(AF_INET, tvalue,
 394                                     &((struct in_addr *)jp->jp_value)[i]) != 1)
 395                                 {
 396                                         snprintf(jail_errmsg,
 397                                             JAIL_ERRMSGLEN,
 398                                             "%s: not an IPv4 address: %s",
 399                                             jp->jp_name, tvalue);
 400                                         errno = EINVAL;
 401                                         goto error;
 402                                 }
 403                                 break;
 404                         case JPS_IN6_ADDR:
 405                                 if (inet_pton(AF_INET6, tvalue,
 406                                     &((struct in6_addr *)jp->jp_value)[i]) != 1)
 407                                 {
 408                                         snprintf(jail_errmsg,
 409                                             JAIL_ERRMSGLEN,
 410                                             "%s: not an IPv6 address: %s",
 411                                             jp->jp_name, tvalue);
 412                                         errno = EINVAL;
 413                                         goto error;
 414                                 }
 415                                 break;
 416                         default:
 417                                 goto unknown_type;
 418                         }
 419                         break;
 420                 default:
 421                 unknown_type:
 422                         snprintf(jail_errmsg, JAIL_ERRMSGLEN,
 423                             "unknown type for %s", jp->jp_name);
 424                         errno = ENOENT;
 425                         goto error;
 426                 }
 427                 avalue += fw + 1;
 428         }
 429         return (0);
 430
 431  error:
 432         free(jp->jp_value);
 433         jp->jp_value = NULL;
 434         return (-1);
 435 }
 436
 437 static int
 438 jailparam_import_enum(const char **values, int nvalues, const char *valstr,
 439     size_t valsize, int *value)
 440 {
 441         char *ep;
 442         int i;
 443
 444         for (i = 0; i < nvalues; i++)
 445                 if (valsize == strlen(values[i]) &&
 446                     !strncasecmp(valstr, values[i], valsize)) {
 447                         *value = i;
 448                         return 1;
 449                 }
 450         *value = strtol(valstr, &ep, 10);
 451         return (ep == valstr + valsize);
 452 }
 453
 454 /*
 455  * Put a name and value into a jail parameter element, copying the value
 456  * but not altering it.
 457  */
 458 int
 459 jailparam_import_raw(struct jailparam *jp, void *value, size_t valuelen)
 460 {
 461
 462         jp->jp_value = value;
 463         jp->jp_valuelen = valuelen;
 464         jp->jp_flags |= JP_RAWVALUE;
 465         return (0);
 466 }
 467
 468 /*
 469  * Run the jail_set and jail_get system calls on a parameter list.
 470  */
 471 int
 472 jailparam_set(struct jailparam *jp, unsigned njp, int flags)
 473 {
 474         struct iovec *jiov;
 475         char *nname;
 476         int i, jid, bool0;
 477         unsigned j;
 478
 479         jiov = alloca(sizeof(struct iovec) * 2 * (njp + 1));
 480         bool0 = 0;
 481         for (i = j = 0; j < njp; j++) {
 482                 jiov[i].iov_base = jp[j].jp_name;
 483                 jiov[i].iov_len = strlen(jp[j].jp_name) + 1;
 484                 i++;
 485                 if (jp[j].jp_flags & (JP_BOOL | JP_NOBOOL)) {
 486                         /*
 487                          * Set booleans without values.  If one has a value of
 488                          * zero, change it to (or from) its "no" counterpart.
 489                          */
 490                         jiov[i].iov_base = NULL;
 491                         jiov[i].iov_len = 0;
 492                         if (jp[j].jp_value != NULL &&
 493                             jp[j].jp_valuelen == sizeof(int) &&
 494                             !*(int *)jp[j].jp_value) {
 495                                 bool0 = 1;
 496                                 nname = jp[j].jp_flags & JP_BOOL
 497                                     ? noname(jp[j].jp_name)
 498                                     : nononame(jp[j].jp_name);
 499                                 if (nname == NULL) {
 500                                         njp = j;
 501                                         jid = -1;
 502                                         goto done;
 503                                 }
 504                                 jiov[i - 1].iov_base = nname;
 505                                 jiov[i - 1].iov_len = strlen(nname) + 1;
 506
 507                         }
 508                 } else {
 509                         /*
 510                          * Try to fill in missing values with an empty string.
 511                          */
 512                         if (jp[j].jp_value == NULL && jp[j].jp_valuelen > 0 &&
 513                             jailparam_import(jp + j, "") < 0) {
 514                                 njp = j;
 515                                 jid = -1;
 516                                 goto done;
 517                         }
 518                         jiov[i].iov_base = jp[j].jp_value;
 519                         jiov[i].iov_len =
 520                             (jp[j].jp_ctltype & CTLTYPE) == CTLTYPE_STRING
 521                             ? strlen(jp[j].jp_value) + 1
 522                             : jp[j].jp_valuelen;
 523                 }
 524                 i++;
 525         }
 526         *(const void **)&jiov[i].iov_base = "errmsg";
 527         jiov[i].iov_len = sizeof("errmsg");
 528         i++;
 529         jiov[i].iov_base = jail_errmsg;
 530         jiov[i].iov_len = JAIL_ERRMSGLEN;
 531         i++;
 532         jail_errmsg[0] = 0;
 533         jid = jail_set(jiov, i, flags);
 534         if (jid < 0 && !jail_errmsg[0])
 535                 snprintf(jail_errmsg, sizeof(jail_errmsg), "jail_set: %s",
 536                     strerror(errno));
 537  done:
 538         if (bool0)
 539                 for (j = 0; j < njp; j++)
 540                         if ((jp[j].jp_flags & (JP_BOOL | JP_NOBOOL)) &&
 541                             jp[j].jp_value != NULL &&
 542                             jp[j].jp_valuelen == sizeof(int) &&
 543                             !*(int *)jp[j].jp_value)
 544                                 free(jiov[j * 2].iov_base);
 545         return (jid);
 546 }
 547
 548 int
 549 jailparam_get(struct jailparam *jp, unsigned njp, int flags)
 550 {
 551         struct iovec *jiov;
 552         struct jailparam *jp_lastjid, *jp_jid, *jp_name, *jp_key;
 553         int i, ai, ki, jid, arrays, sanity;
 554         unsigned j;
 555
 556         /*
 557          * Get the types for all parameters.
 558          * Find the key and any array parameters.
 559          */
 560         jiov = alloca(sizeof(struct iovec) * 2 * (njp + 1));
 561         jp_lastjid = jp_jid = jp_name = NULL;
 562         arrays = 0;
 563         for (ai = j = 0; j < njp; j++) {
 564                 if (!strcmp(jp[j].jp_name, "lastjid"))
 565                         jp_lastjid = jp + j;
 566                 else if (!strcmp(jp[j].jp_name, "jid"))
 567                         jp_jid = jp + j;
 568                 else if (!strcmp(jp[j].jp_name, "name"))
 569                         jp_name = jp + j;
 570                 else if (jp[j].jp_elemlen && !(jp[j].jp_flags & JP_RAWVALUE)) {
 571                         arrays = 1;
 572                         jiov[ai].iov_base = jp[j].jp_name;
 573                         jiov[ai].iov_len = strlen(jp[j].jp_name) + 1;
 574                         ai++;
 575                         jiov[ai].iov_base = NULL;
 576                         jiov[ai].iov_len = 0;
 577                         ai++;
 578                 }
 579         }
 580         jp_key = jp_lastjid ? jp_lastjid :
 581             jp_jid && jp_jid->jp_valuelen == sizeof(int) &&
 582             jp_jid->jp_value && *(int *)jp_jid->jp_value ? jp_jid : jp_name;
 583         if (jp_key == NULL || jp_key->jp_value == NULL) {
 584                 strlcpy(jail_errmsg, "no jail specified", JAIL_ERRMSGLEN);
 585                 errno = ENOENT;
 586                 return (-1);
 587         }
 588         ki = ai;
 589         jiov[ki].iov_base = jp_key->jp_name;
 590         jiov[ki].iov_len = strlen(jp_key->jp_name) + 1;
 591         ki++;
 592         jiov[ki].iov_base = jp_key->jp_value;
 593         jiov[ki].iov_len = (jp_key->jp_ctltype & CTLTYPE) == CTLTYPE_STRING
 594             ? strlen(jp_key->jp_value) + 1 : jp_key->jp_valuelen;
 595         ki++;
 596         *(const void **)&jiov[ki].iov_base = "errmsg";
 597         jiov[ki].iov_len = sizeof("errmsg");
 598         ki++;
 599         jiov[ki].iov_base = jail_errmsg;
 600         jiov[ki].iov_len = JAIL_ERRMSGLEN;
 601         ki++;
 602         jail_errmsg[0] = 0;
 603         if (arrays && jail_get(jiov, ki, flags) < 0) {
 604                 if (!jail_errmsg[0])
 605                         snprintf(jail_errmsg, sizeof(jail_errmsg),
 606                             "jail_get: %s", strerror(errno));
 607                 return (-1);
 608         }
 609         /* Allocate storage for all parameters. */
 610         for (ai = j = 0, i = ki; j < njp; j++) {
 611                 if (jp[j].jp_elemlen && !(jp[j].jp_flags & JP_RAWVALUE)) {
 612                         ai++;
 613                         jiov[ai].iov_len += jp[j].jp_elemlen * ARRAY_SLOP;
 614                         if (jp[j].jp_valuelen >= jiov[ai].iov_len)
 615                                 jiov[ai].iov_len = jp[j].jp_valuelen;
 616                         else {
 617                                 jp[j].jp_valuelen = jiov[ai].iov_len;
 618                                 if (jp[j].jp_value != NULL)
 619                                         free(jp[j].jp_value);
 620                                 jp[j].jp_value = malloc(jp[j].jp_valuelen);
 621                                 if (jp[j].jp_value == NULL) {
 622                                         strerror_r(errno, jail_errmsg,
 623                                             JAIL_ERRMSGLEN);
 624                                         return (-1);
 625                                 }
 626                         }
 627                         jiov[ai].iov_base = jp[j].jp_value;
 628                         memset(jiov[ai].iov_base, 0, jiov[ai].iov_len);
 629                         ai++;
 630                 } else if (jp + j != jp_key) {
 631                         jiov[i].iov_base = jp[j].jp_name;
 632                         jiov[i].iov_len = strlen(jp[j].jp_name) + 1;
 633                         i++;
 634                         if (jp[j].jp_value == NULL &&
 635                             !(jp[j].jp_flags & JP_RAWVALUE)) {
 636                                 jp[j].jp_value = malloc(jp[j].jp_valuelen);
 637                                 if (jp[j].jp_value == NULL) {
 638                                         strerror_r(errno, jail_errmsg,
 639                                             JAIL_ERRMSGLEN);
 640                                         return (-1);
 641                                 }
 642                         }
 643                         jiov[i].iov_base = jp[j].jp_value;
 644                         jiov[i].iov_len = jp[j].jp_valuelen;
 645                         memset(jiov[i].iov_base, 0, jiov[i].iov_len);
 646                         i++;
 647                 }
 648         }
 649         /*
 650          * Get the prison.  If there are array elements, retry a few times
 651          * in case their sizes changed from under us.
 652          */
 653         for (sanity = 0;; sanity++) {
 654                 jid = jail_get(jiov, i, flags);
 655                 if (jid >= 0 || !arrays || sanity == ARRAY_SANITY ||
 656                     errno != EINVAL || jail_errmsg[0])
 657                         break;
 658                 for (ai = j = 0; j < njp; j++) {
 659                         if (jp[j].jp_elemlen &&
 660                             !(jp[j].jp_flags & JP_RAWVALUE)) {
 661                                 ai++;
 662                                 jiov[ai].iov_base = NULL;
 663                                 jiov[ai].iov_len = 0;
 664                                 ai++;
 665                         }
 666                 }
 667                 if (jail_get(jiov, ki, flags) < 0)
 668                         break;
 669                 for (ai = j = 0; j < njp; j++) {
 670                         if (jp[j].jp_elemlen &&
 671                             !(jp[j].jp_flags & JP_RAWVALUE)) {
 672                                 ai++;
 673                                 jiov[ai].iov_len +=
 674                                     jp[j].jp_elemlen * ARRAY_SLOP;
 675                                 if (jp[j].jp_valuelen >= jiov[ai].iov_len)
 676                                         jiov[ai].iov_len = jp[j].jp_valuelen;
 677                                 else {
 678                                         jp[j].jp_valuelen = jiov[ai].iov_len;
 679                                         if (jp[j].jp_value != NULL)
 680                                                 free(jp[j].jp_value);
 681                                         jp[j].jp_value =
 682                                             malloc(jiov[ai].iov_len);
 683                                         if (jp[j].jp_value == NULL) {
 684                                                 strerror_r(errno, jail_errmsg,
 685                                                     JAIL_ERRMSGLEN);
 686                                                 return (-1);
 687                                         }
 688                                 }
 689                                 jiov[ai].iov_base = jp[j].jp_value;
 690                                 memset(jiov[ai].iov_base, 0, jiov[ai].iov_len);
 691                                 ai++;
 692                         }
 693                 }
 694         }
 695         if (jid < 0 && !jail_errmsg[0])
 696                 snprintf(jail_errmsg, sizeof(jail_errmsg),
 697                     "jail_get: %s", strerror(errno));
 698         for (ai = j = 0, i = ki; j < njp; j++) {
 699                 if (jp[j].jp_elemlen && !(jp[j].jp_flags & JP_RAWVALUE)) {
 700                         ai++;
 701                         jp[j].jp_valuelen = jiov[ai].iov_len;
 702                         ai++;
 703                 } else if (jp + j != jp_key) {
 704                         i++;
 705                         jp[j].jp_valuelen = jiov[i].iov_len;
 706                         i++;
 707                 }
 708         }
 709         return (jid);
 710 }
 711
 712 /*
 713  * Convert a jail parameter's value to external form.
 714  */
 715 char *
 716 jailparam_export(struct jailparam *jp)
 717 {
 718         size_t *valuelens;
 719         char *value, *tvalue, **values;
 720         size_t valuelen;
 721         int i, nval, ival;
 722         char valbuf[INET6_ADDRSTRLEN];
 723
 724         if ((jp->jp_ctltype & CTLTYPE) == CTLTYPE_STRING) {
 725                 value = strdup(jp->jp_value);
 726                 if (value == NULL)
 727                         strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);
 728                 return (value);
 729         }
 730         nval = jp->jp_elemlen ? jp->jp_valuelen / jp->jp_elemlen : 1;
 731         if (nval == 0) {
 732                 value = strdup("");
 733                 if (value == NULL)
 734                         strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);
 735                 return (value);
 736         }
 737         values = alloca(nval * sizeof(char *));
 738         valuelens = alloca(nval * sizeof(size_t));
 739         valuelen = 0;
 740         for (i = 0; i < nval; i++) {
 741                 switch (jp->jp_ctltype & CTLTYPE) {
 742                 case CTLTYPE_INT:
 743                         ival = ((int *)jp->jp_value)[i];
 744                         if ((jp->jp_flags & (JP_BOOL | JP_NOBOOL)) &&
 745                             (unsigned)ival < 2) {
 746                                 strlcpy(valbuf, bool_values[ival],
 747                                     sizeof(valbuf));
 748                                 break;
 749                         }
 750                         if ((jp->jp_flags & JP_JAILSYS) &&
 751                             (unsigned)ival < sizeof(jailsys_values) /
 752                             sizeof(jailsys_values[0])) {
 753                                 strlcpy(valbuf, jailsys_values[ival],
 754                                     sizeof(valbuf));
 755                                 break;
 756                         }
 757                         snprintf(valbuf, sizeof(valbuf), "%d", ival);
 758                         break;
 759                 case CTLTYPE_UINT:
 760                         snprintf(valbuf, sizeof(valbuf), "%u",
 761                             ((unsigned *)jp->jp_value)[i]);
 762                         break;
 763                 case CTLTYPE_LONG:
 764                         snprintf(valbuf, sizeof(valbuf), "%ld",
 765                             ((long *)jp->jp_value)[i]);
 766                         break;
 767                 case CTLTYPE_ULONG:
 768                         snprintf(valbuf, sizeof(valbuf), "%lu",
 769                             ((unsigned long *)jp->jp_value)[i]);
 770                         break;
 771                 case CTLTYPE_QUAD:
 772                         snprintf(valbuf, sizeof(valbuf), "%jd",
 773                             (intmax_t)((int64_t *)jp->jp_value)[i]);
 774                         break;
 775                 case CTLTYPE_STRUCT:
 776                         switch (jp->jp_structtype) {
 777                         case JPS_IN_ADDR:
 778                                 if (inet_ntop(AF_INET,
 779                                     &((struct in_addr *)jp->jp_value)[i],
 780                                     valbuf, sizeof(valbuf)) == NULL) {
 781                                         strerror_r(errno, jail_errmsg,
 782                                             JAIL_ERRMSGLEN);
 783                                         return (NULL);
 784                                 }
 785                                 break;
 786                         case JPS_IN6_ADDR:
 787                                 if (inet_ntop(AF_INET6,
 788                                     &((struct in6_addr *)jp->jp_value)[i],
 789                                     valbuf, sizeof(valbuf)) == NULL) {
 790                                         strerror_r(errno, jail_errmsg,
 791                                             JAIL_ERRMSGLEN);
 792                                         return (NULL);
 793                                 }
 794                                 break;
 795                         default:
 796                                 goto unknown_type;
 797                         }
 798                         break;
 799                 default:
 800                 unknown_type:
 801                         snprintf(jail_errmsg, JAIL_ERRMSGLEN,
 802                             "unknown type for %s", jp->jp_name);
 803                         errno = ENOENT;
 804                         return (NULL);
 805                 }
 806                 valuelens[i] = strlen(valbuf) + 1;
 807                 valuelen += valuelens[i];
 808                 values[i] = alloca(valuelens[i]);
 809                 strcpy(values[i], valbuf);
 810         }
 811         value = malloc(valuelen);
 812         if (value == NULL)
 813                 strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);
 814         else {
 815                 tvalue = value;
 816                 for (i = 0; i < nval; i++) {
 817                         strcpy(tvalue, values[i]);
 818                         if (i < nval - 1) {
 819                                 tvalue += valuelens[i];
 820                                 tvalue[-1] = ',';
 821                         }
 822                 }
 823         }
 824         return (value);
 825 }
 826
 827 /*
 828  * Free the contents of a jail parameter list (but not the list itself).
 829  */
 830 void
 831 jailparam_free(struct jailparam *jp, unsigned njp)
 832 {
 833         unsigned j;
 834
 835         for (j = 0; j < njp; j++) {
 836                 free(jp[j].jp_name);
 837                 if (!(jp[j].jp_flags & JP_RAWVALUE))
 838                         free(jp[j].jp_value);
 839         }
 840 }
 841
 842 /*
 843  * Find a parameter's type and size from its MIB.
 844  */
 845 static int
 846 jailparam_type(struct jailparam *jp)
 847 {
 848         char *p, *nname;
 849         size_t miblen, desclen;
 850         int isarray;
 851         struct {
 852             int i;
 853             char s[MAXPATHLEN];
 854         } desc;
 855         int mib[CTL_MAXNAME];
 856
 857         /* The "lastjid" parameter isn't real. */
 858         if (!strcmp(jp->jp_name, "lastjid")) {
 859                 jp->jp_valuelen = sizeof(int);
 860                 jp->jp_ctltype = CTLTYPE_INT | CTLFLAG_WR;
 861                 return (0);
 862         }
 863
 864         /* Find the sysctl that describes the parameter. */
 865         mib[0] = 0;
 866         mib[1] = 3;
 867         snprintf(desc.s, sizeof(desc.s), SJPARAM ".%s", jp->jp_name);
 868         miblen = sizeof(mib) - 2 * sizeof(int);
 869         if (sysctl(mib, 2, mib + 2, &miblen, desc.s, strlen(desc.s)) < 0) {
 870                 if (errno != ENOENT) {
 871                         snprintf(jail_errmsg, JAIL_ERRMSGLEN,
 872                             "sysctl(0.3.%s): %s", jp->jp_name, strerror(errno));
 873                         return (-1);
 874                 }
 875                 /*
 876                  * The parameter probably doesn't exist.  But it might be
 877                  * the "no" counterpart to a boolean.
 878                  */
 879                 nname = nononame(jp->jp_name);
 880                 if (nname != NULL) {
 881                         snprintf(desc.s, sizeof(desc.s), SJPARAM ".%s", nname);
 882                         free(nname);
 883                         miblen = sizeof(mib) - 2 * sizeof(int);
 884                         if (sysctl(mib, 2, mib + 2, &miblen, desc.s,
 885                             strlen(desc.s)) >= 0) {
 886                                 mib[1] = 4;
 887                                 desclen = sizeof(desc);
 888                                 if (sysctl(mib, (miblen / sizeof(int)) + 2,
 889                                     &desc, &desclen, NULL, 0) < 0) {
 890                                         snprintf(jail_errmsg,
 891                                             JAIL_ERRMSGLEN,
 892                                             "sysctl(0.4.%s): %s", desc.s,
 893                                             strerror(errno));
 894                                         return (-1);
 895                                 }
 896                                 if ((desc.i & CTLTYPE) == CTLTYPE_INT &&
 897                                     desc.s[0] == 'B') {
 898                                         jp->jp_ctltype = desc.i;
 899                                         jp->jp_flags |= JP_NOBOOL;
 900                                         jp->jp_valuelen = sizeof(int);
 901                                         return (0);
 902                                 }
 903                         }
 904                 }
 905         unknown_parameter:
 906                 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
 907                     "unknown parameter: %s", jp->jp_name);
 908                 errno = ENOENT;
 909                 return (-1);
 910         }
 911  mib_desc:
 912         mib[1] = 4;
 913         desclen = sizeof(desc);
 914         if (sysctl(mib, (miblen / sizeof(int)) + 2, &desc, &desclen,
 915             NULL, 0) < 0) {
 916                 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
 917                     "sysctl(0.4.%s): %s", jp->jp_name, strerror(errno));
 918                 return (-1);
 919         }
 920         /* See if this is an array type. */
 921         p = strchr(desc.s, '\0');
 922         isarray  = 0;
 923         if (p - 2 < desc.s || strcmp(p - 2, ",a"))
 924                 isarray = 0;
 925         else {
 926                 isarray = 1;
 927                 p[-2] = 0;
 928         }
 929         /* Look for types we understand. */
 930         jp->jp_ctltype = desc.i;
 931         switch (desc.i & CTLTYPE) {
 932         case CTLTYPE_INT:
 933                 if (desc.s[0] == 'B')
 934                         jp->jp_flags |= JP_BOOL;
 935                 else if (!strcmp(desc.s, "E,jailsys"))
 936                         jp->jp_flags |= JP_JAILSYS;
 937         case CTLTYPE_UINT:
 938                 jp->jp_valuelen = sizeof(int);
 939                 break;
 940         case CTLTYPE_LONG:
 941         case CTLTYPE_ULONG:
 942                 jp->jp_valuelen = sizeof(long);
 943                 break;
 944         case CTLTYPE_QUAD:
 945                 jp->jp_valuelen = sizeof(int64_t);
 946                 break;
 947         case CTLTYPE_STRING:
 948                 desc.s[0] = 0;
 949                 desclen = sizeof(desc.s);
 950                 if (sysctl(mib + 2, miblen / sizeof(int), desc.s, &desclen,
 951                     NULL, 0) < 0) {
 952                         snprintf(jail_errmsg, JAIL_ERRMSGLEN,
 953                             "sysctl(" SJPARAM ".%s): %s", jp->jp_name,
 954                             strerror(errno));
 955                         return (-1);
 956                 }
 957                 jp->jp_valuelen = strtoul(desc.s, NULL, 10);
 958                 break;
 959         case CTLTYPE_STRUCT:
 960                 if (!strcmp(desc.s, "S,in_addr")) {
 961                         jp->jp_structtype = JPS_IN_ADDR;
 962                         jp->jp_valuelen = sizeof(struct in_addr);
 963                 } else if (!strcmp(desc.s, "S,in6_addr")) {
 964                         jp->jp_structtype = JPS_IN6_ADDR;
 965                         jp->jp_valuelen = sizeof(struct in6_addr);
 966                 } else {
 967                         desclen = 0;
 968                         if (sysctl(mib + 2, miblen / sizeof(int),
 969                             NULL, &jp->jp_valuelen, NULL, 0) < 0) {
 970                                 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
 971                                     "sysctl(" SJPARAM ".%s): %s", jp->jp_name,
 972                                     strerror(errno));
 973                                 return (-1);
 974                         }
 975                 }
 976                 break;
 977         case CTLTYPE_NODE:
 978                 /* A node might be described by an empty-named child. */
 979                 mib[1] = 1;
 980                 mib[(miblen / sizeof(int)) + 2] =
 981                     mib[(miblen / sizeof(int)) + 1] - 1;
 982                 miblen += sizeof(int);
 983                 desclen = sizeof(desc.s);
 984                 if (sysctl(mib, (miblen / sizeof(int)) + 2, desc.s, &desclen,
 985                     NULL, 0) < 0) {
 986                         snprintf(jail_errmsg, JAIL_ERRMSGLEN,
 987                             "sysctl(0.1): %s", strerror(errno));
 988                         return (-1);
 989                 }
 990                 if (desc.s[desclen - 2] != '.')
 991                         goto unknown_parameter;
 992                 goto mib_desc;
 993         default:
 994                 snprintf(jail_errmsg, JAIL_ERRMSGLEN,
 995                     "unknown type for %s", jp->jp_name);
 996                 errno = ENOENT;
 997                 return (-1);
 998         }
 999         if (isarray) {
1000                 jp->jp_elemlen = jp->jp_valuelen;
1001                 jp->jp_valuelen = 0;
1002         }
1003         return (0);
1004 }
1005
1006 /*
1007  * Change a boolean parameter name into its "no" counterpart or vice versa.
1008  */
1009 static char *
1010 noname(const char *name)
1011 {
1012         char *nname, *p;
1013
1014         nname = malloc(strlen(name) + 3);
1015         if (nname == NULL) {
1016                 strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);
1017                 return (NULL);
1018         }
1019         p = strrchr(name, '.');
1020         if (p != NULL)
1021                 sprintf(nname, "%.*s.no%s", (int)(p - name), name, p + 1);
1022         else
1023                 sprintf(nname, "no%s", name);
1024         return (nname);
1025 }
1026
1027 static char *
1028 nononame(const char *name)
1029 {
1030         char *p, *nname;
1031
1032         p = strrchr(name, '.');
1033         if (strncmp(p ? p + 1 : name, "no", 2)) {
1034                 snprintf(jail_errmsg, sizeof(jail_errmsg),
1035                     "mismatched boolean: %s", name);
1036                 errno = EINVAL;
1037                 return (NULL);
1038         }
1039         nname = malloc(strlen(name) - 1);
1040         if (nname == NULL) {
1041                 strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);
1042                 return (NULL);
1043         }
1044         if (p != NULL)
1045                 sprintf(nname, "%.*s.%s", (int)(p - name), name, p + 3);
1046         else
1047                 strcpy(nname, name + 2);
1048         return (nname);
1049 }