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