1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 1999 Poul-Henning Kamp. 5 * Copyright (c) 2009-2012 James Gritton 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 #include <sys/types.h> 31 #include <sys/stat.h> 32 #include <sys/socket.h> 33 #include <sys/sysctl.h> 34 35 #include <arpa/inet.h> 36 #include <netinet/in.h> 37 38 #include <err.h> 39 #include <errno.h> 40 #include <stdarg.h> 41 #include <stdio.h> 42 #include <stdlib.h> 43 #include <string.h> 44 #include <unistd.h> 45 46 #include "jailp.h" 47 48 #define JP_RDTUN(jp) (((jp)->jp_ctltype & CTLFLAG_RDTUN) == CTLFLAG_RDTUN) 49 50 struct permspec { 51 const char *name; 52 enum intparam ipnum; 53 int rev; 54 }; 55 56 int iflag; 57 int note_remove; 58 int verbose; 59 const char *separator = "\t"; 60 61 static void clear_persist(struct cfjail *j); 62 static int update_jail(struct cfjail *j); 63 static int rdtun_params(struct cfjail *j, int dofail); 64 static void running_jid(struct cfjail *j); 65 static void jail_quoted_warnx(const struct cfjail *j, const char *name_msg, 66 const char *noname_msg); 67 static int jailparam_set_note(const struct cfjail *j, struct jailparam *jp, 68 unsigned njp, int flags); 69 static void print_jail(FILE *fp, struct cfjail *j, int oldcl, int running); 70 static void print_param(FILE *fp, const struct cfparam *p, int sep, int doname); 71 static void show_jails(void); 72 static void quoted_print(FILE *fp, char *str); 73 static void usage(void) __dead2; 74 75 static struct permspec perm_sysctl[] = { 76 { "security.jail.set_hostname_allowed", KP_ALLOW_SET_HOSTNAME, 0 }, 77 { "security.jail.sysvipc_allowed", KP_ALLOW_SYSVIPC, 0 }, 78 { "security.jail.allow_raw_sockets", KP_ALLOW_RAW_SOCKETS, 0 }, 79 { "security.jail.chflags_allowed", KP_ALLOW_CHFLAGS, 0 }, 80 { "security.jail.mount_allowed", KP_ALLOW_MOUNT, 0 }, 81 { "security.jail.socket_unixiproute_only", KP_ALLOW_SOCKET_AF, 1 }, 82 }; 83 84 static const enum intparam startcommands[] = { 85 IP__NULL, 86 IP_EXEC_PREPARE, 87 #ifdef INET 88 IP__IP4_IFADDR, 89 #endif 90 #ifdef INET6 91 IP__IP6_IFADDR, 92 #endif 93 IP_MOUNT, 94 IP__MOUNT_FROM_FSTAB, 95 IP_MOUNT_DEVFS, 96 IP_MOUNT_FDESCFS, 97 IP_MOUNT_PROCFS, 98 IP_EXEC_PRESTART, 99 IP__OP, 100 IP_EXEC_CREATED, 101 IP_ZFS_DATASET, 102 IP_VNET_INTERFACE, 103 IP_EXEC_START, 104 IP_COMMAND, 105 IP_EXEC_POSTSTART, 106 IP__NULL 107 }; 108 109 static const enum intparam stopcommands[] = { 110 IP__NULL, 111 IP_EXEC_PRESTOP, 112 IP_EXEC_STOP, 113 IP_STOP_TIMEOUT, 114 IP__OP, 115 IP_EXEC_POSTSTOP, 116 IP_MOUNT_PROCFS, 117 IP_MOUNT_FDESCFS, 118 IP_MOUNT_DEVFS, 119 IP__MOUNT_FROM_FSTAB, 120 IP_MOUNT, 121 #ifdef INET6 122 IP__IP6_IFADDR, 123 #endif 124 #ifdef INET 125 IP__IP4_IFADDR, 126 #endif 127 IP_EXEC_RELEASE, 128 IP__NULL 129 }; 130 131 int 132 main(int argc, char **argv) 133 { 134 struct stat st; 135 FILE *jfp; 136 struct cfjail *j; 137 char *JidFile; 138 const char *cfname; 139 size_t sysvallen; 140 unsigned op, pi; 141 int ch, docf, dying_warned, error, i, oldcl, sysval; 142 int dflag, eflag, Rflag; 143 #if defined(INET) || defined(INET6) 144 char *cs, *ncs; 145 #endif 146 #if defined(INET) && defined(INET6) 147 struct in6_addr addr6; 148 #endif 149 150 op = 0; 151 dflag = eflag = Rflag = 0; 152 docf = 1; 153 cfname = CONF_FILE; 154 JidFile = NULL; 155 156 while ((ch = getopt(argc, argv, "cde:f:hiJ:lmn:p:qrRs:u:U:v")) != -1) { 157 switch (ch) { 158 case 'c': 159 op |= JF_START; 160 break; 161 case 'd': 162 dflag = 1; 163 break; 164 case 'e': 165 eflag = 1; 166 separator = optarg; 167 break; 168 case 'f': 169 cfname = optarg; 170 break; 171 case 'h': 172 #if defined(INET) || defined(INET6) 173 add_param(NULL, NULL, IP_IP_HOSTNAME, NULL); 174 #endif 175 docf = 0; 176 break; 177 case 'i': 178 iflag = 1; 179 verbose = -1; 180 break; 181 case 'J': 182 JidFile = optarg; 183 break; 184 case 'l': 185 add_param(NULL, NULL, IP_EXEC_CLEAN, NULL); 186 docf = 0; 187 break; 188 case 'm': 189 op |= JF_SET; 190 break; 191 case 'n': 192 add_param(NULL, NULL, KP_NAME, optarg); 193 docf = 0; 194 break; 195 case 'p': 196 paralimit = strtol(optarg, NULL, 10); 197 if (paralimit == 0) 198 paralimit = -1; 199 break; 200 case 'q': 201 verbose = -1; 202 break; 203 case 'r': 204 op |= JF_STOP; 205 break; 206 case 'R': 207 op |= JF_STOP; 208 Rflag = 1; 209 break; 210 case 's': 211 add_param(NULL, NULL, KP_SECURELEVEL, optarg); 212 docf = 0; 213 break; 214 case 'u': 215 add_param(NULL, NULL, IP_EXEC_JAIL_USER, optarg); 216 add_param(NULL, NULL, IP_EXEC_SYSTEM_JAIL_USER, NULL); 217 docf = 0; 218 break; 219 case 'U': 220 add_param(NULL, NULL, IP_EXEC_JAIL_USER, optarg); 221 add_param(NULL, NULL, IP_EXEC_SYSTEM_JAIL_USER, 222 "false"); 223 docf = 0; 224 break; 225 case 'v': 226 verbose = 1; 227 break; 228 default: 229 usage(); 230 } 231 } 232 argc -= optind; 233 argv += optind; 234 235 if (eflag) { 236 /* Just print list of all configured non-wildcard jails */ 237 if (op || argc > 0) 238 usage(); 239 load_config(cfname); 240 show_jails(); 241 exit(0); 242 } 243 244 /* Find out which of the command line styles this is. */ 245 oldcl = 0; 246 if (!op) { 247 /* Old-style command line with four fixed parameters */ 248 if (argc < 4 || argv[0][0] != '/') 249 usage(); 250 op = JF_START; 251 docf = 0; 252 oldcl = 1; 253 add_param(NULL, NULL, KP_PATH, argv[0]); 254 add_param(NULL, NULL, KP_HOST_HOSTNAME, argv[1]); 255 #if defined(INET) || defined(INET6) 256 if (argv[2][0] != '\0') { 257 for (cs = argv[2];; cs = ncs + 1) { 258 ncs = strchr(cs, ','); 259 if (ncs) 260 *ncs = '\0'; 261 add_param(NULL, NULL, 262 #if defined(INET) && defined(INET6) 263 inet_pton(AF_INET6, cs, &addr6) == 1 264 ? KP_IP6_ADDR : KP_IP4_ADDR, 265 #elif defined(INET) 266 KP_IP4_ADDR, 267 #elif defined(INET6) 268 KP_IP6_ADDR, 269 #endif 270 cs); 271 if (!ncs) 272 break; 273 } 274 } 275 #endif 276 for (i = 3; i < argc; i++) 277 add_param(NULL, NULL, IP_COMMAND, argv[i]); 278 /* Emulate the defaults from security.jail.* sysctls. */ 279 sysvallen = sizeof(sysval); 280 if (sysctlbyname("security.jail.jailed", &sysval, &sysvallen, 281 NULL, 0) == 0 && sysval == 0) { 282 for (pi = 0; pi < sizeof(perm_sysctl) / 283 sizeof(perm_sysctl[0]); pi++) { 284 sysvallen = sizeof(sysval); 285 if (sysctlbyname(perm_sysctl[pi].name, 286 &sysval, &sysvallen, NULL, 0) == 0) 287 add_param(NULL, NULL, 288 perm_sysctl[pi].ipnum, 289 (sysval ? 1 : 0) ^ 290 perm_sysctl[pi].rev 291 ? NULL : "false"); 292 } 293 } 294 } else if (op == JF_STOP) { 295 /* Jail remove, perhaps using the config file */ 296 if (!docf || argc == 0) 297 usage(); 298 if (!Rflag) 299 for (i = 0; i < argc; i++) 300 if (strchr(argv[i], '=')) 301 usage(); 302 if ((docf = !Rflag && 303 (!strcmp(cfname, "-") || stat(cfname, &st) == 0))) 304 load_config(cfname); 305 note_remove = docf || argc > 1 || wild_jail_name(argv[0]); 306 } else if (argc > 1 || (argc == 1 && strchr(argv[0], '='))) { 307 /* Single jail specified on the command line */ 308 if (Rflag) 309 usage(); 310 docf = 0; 311 for (i = 0; i < argc; i++) { 312 if (!strncmp(argv[i], "command", 7) && 313 (argv[i][7] == '\0' || argv[i][7] == '=')) { 314 if (argv[i][7] == '=') 315 add_param(NULL, NULL, IP_COMMAND, 316 argv[i] + 8); 317 for (i++; i < argc; i++) 318 add_param(NULL, NULL, IP_COMMAND, 319 argv[i]); 320 } 321 #ifdef INET 322 else if (!strncmp(argv[i], "ip4.addr=", 9)) { 323 for (cs = argv[i] + 9;; cs = ncs + 1) { 324 ncs = strchr(cs, ','); 325 if (ncs) 326 *ncs = '\0'; 327 add_param(NULL, NULL, KP_IP4_ADDR, cs); 328 if (!ncs) 329 break; 330 } 331 } 332 #endif 333 #ifdef INET6 334 else if (!strncmp(argv[i], "ip6.addr=", 9)) { 335 for (cs = argv[i] + 9;; cs = ncs + 1) { 336 ncs = strchr(cs, ','); 337 if (ncs) 338 *ncs = '\0'; 339 add_param(NULL, NULL, KP_IP6_ADDR, cs); 340 if (!ncs) 341 break; 342 } 343 } 344 #endif 345 else 346 add_param(NULL, NULL, 0, argv[i]); 347 } 348 } else { 349 /* From the config file, perhaps with a specified jail */ 350 if (Rflag || !docf) 351 usage(); 352 load_config(cfname); 353 } 354 355 /* Find out which jails will be run. */ 356 dep_setup(docf); 357 error = 0; 358 if (op == JF_STOP) { 359 for (i = 0; i < argc; i++) 360 if (start_state(argv[i], docf, op, Rflag) < 0) 361 error = 1; 362 } else { 363 if (start_state(argv[0], docf, op, 0) < 0) 364 exit(1); 365 } 366 367 jfp = NULL; 368 if (JidFile != NULL) { 369 jfp = fopen(JidFile, "w"); 370 if (jfp == NULL) 371 err(1, "open %s", JidFile); 372 setlinebuf(jfp); 373 } 374 setlinebuf(stdout); 375 376 /* 377 * The main loop: Get an available jail and perform the required 378 * operation on it. When that is done, the jail may be finished, 379 * or it may go back for the next step. 380 */ 381 dying_warned = 0; 382 while ((j = next_jail())) 383 { 384 if (j->flags & JF_FAILED) { 385 error = 1; 386 if (j->comparam == NULL) { 387 dep_done(j, 0); 388 continue; 389 } 390 } 391 if (!(j->flags & JF_PARAMS)) 392 { 393 j->flags |= JF_PARAMS; 394 if (dflag) 395 add_param(j, NULL, IP_ALLOW_DYING, NULL); 396 if (check_intparams(j) < 0) 397 continue; 398 if ((j->flags & (JF_START | JF_SET)) && 399 import_params(j) < 0) 400 continue; 401 } 402 if (j->intparams[IP_ALLOW_DYING] && !dying_warned) { 403 warnx("%s", "the 'allow.dying' parameter and '-d' flag " 404 "are deprecated and have no effect."); 405 dying_warned = 1; 406 } 407 if (!j->jid) 408 running_jid(j); 409 if (finish_command(j)) 410 continue; 411 412 switch (j->flags & JF_OP_MASK) { 413 /* 414 * These operations just turn into a different op 415 * depending on the jail's current status. 416 */ 417 case JF_START_SET: 418 j->flags = j->jid < 0 ? JF_START : JF_SET; 419 break; 420 case JF_SET_RESTART: 421 if (j->jid < 0) { 422 jail_quoted_warnx(j, "not found", 423 "no jail specified"); 424 failed(j); 425 continue; 426 } 427 j->flags = rdtun_params(j, 0) ? JF_RESTART : JF_SET; 428 if (j->flags == JF_RESTART) 429 dep_reset(j); 430 break; 431 case JF_START_SET_RESTART: 432 j->flags = j->jid < 0 ? JF_START 433 : rdtun_params(j, 0) ? JF_RESTART : JF_SET; 434 if (j->flags == JF_RESTART) 435 dep_reset(j); 436 } 437 438 switch (j->flags & JF_OP_MASK) { 439 case JF_START: 440 if (j->comparam == NULL) { 441 if (j->jid > 0 && 442 !(j->flags & (JF_DEPEND | JF_WILD))) { 443 jail_quoted_warnx(j, "already exists", 444 NULL); 445 failed(j); 446 continue; 447 } 448 if (dep_check(j)) 449 continue; 450 if (j->jid > 0) 451 goto jail_create_done; 452 j->comparam = startcommands; 453 j->comstring = NULL; 454 } 455 if (next_command(j)) 456 continue; 457 jail_create_done: 458 clear_persist(j); 459 if (jfp != NULL) 460 print_jail(jfp, j, oldcl, 1); 461 dep_done(j, 0); 462 break; 463 464 case JF_SET: 465 if (j->jid < 0 && !(j->flags & JF_DEPEND)) { 466 jail_quoted_warnx(j, "not found", 467 "no jail specified"); 468 failed(j); 469 continue; 470 } 471 if (dep_check(j)) 472 continue; 473 if (!(j->flags & JF_DEPEND)) { 474 if (rdtun_params(j, 1) < 0 || 475 update_jail(j) < 0) 476 continue; 477 if (verbose >= 0 && (j->name || verbose > 0)) 478 jail_note(j, "updated\n"); 479 } 480 dep_done(j, 0); 481 break; 482 483 case JF_STOP: 484 case JF_RESTART: 485 if (j->comparam == NULL) { 486 if (dep_check(j)) 487 continue; 488 if (j->jid < 0) { 489 if (!(j->flags & (JF_DEPEND|JF_WILD))) { 490 if (verbose >= 0) 491 jail_quoted_warnx(j, 492 "not found", NULL); 493 failed(j); 494 } 495 goto jail_remove_done; 496 } 497 j->comparam = stopcommands; 498 j->comstring = NULL; 499 } else if ((j->flags & JF_FAILED) && j->jid > 0) 500 goto jail_remove_done; 501 if (next_command(j)) 502 continue; 503 jail_remove_done: 504 dep_done(j, 0); 505 if ((j->flags & (JF_START | JF_FAILED)) == JF_START) { 506 j->comparam = NULL; 507 j->flags &= ~JF_STOP; 508 dep_reset(j); 509 requeue(j, j->ndeps ? &depend : &ready); 510 } 511 break; 512 } 513 } 514 515 if (jfp != NULL) 516 fclose(jfp); 517 exit(error); 518 } 519 520 /* 521 * Mark a jail's failure for future handling. 522 */ 523 void 524 failed(struct cfjail *j) 525 { 526 j->flags |= JF_FAILED; 527 TAILQ_REMOVE(j->queue, j, tq); 528 TAILQ_INSERT_HEAD(&ready, j, tq); 529 j->queue = &ready; 530 } 531 532 /* 533 * Exit slightly more gracefully when out of memory. 534 */ 535 void * 536 emalloc(size_t size) 537 { 538 void *p; 539 540 p = malloc(size); 541 if (!p) 542 err(1, "malloc"); 543 return p; 544 } 545 546 void * 547 erealloc(void *ptr, size_t size) 548 { 549 void *p; 550 551 p = realloc(ptr, size); 552 if (!p) 553 err(1, "malloc"); 554 return p; 555 } 556 557 char * 558 estrdup(const char *str) 559 { 560 char *ns; 561 562 ns = strdup(str); 563 if (!ns) 564 err(1, "malloc"); 565 return ns; 566 } 567 568 /* 569 * Print a message including an optional jail name. 570 */ 571 void 572 jail_note(const struct cfjail *j, const char *fmt, ...) 573 { 574 va_list ap, tap; 575 char *cs; 576 size_t len; 577 578 va_start(ap, fmt); 579 va_copy(tap, ap); 580 len = vsnprintf(NULL, 0, fmt, tap); 581 va_end(tap); 582 cs = alloca(len + 1); 583 (void)vsnprintf(cs, len + 1, fmt, ap); 584 va_end(ap); 585 if (j->name) 586 printf("%s: %s", j->name, cs); 587 else 588 printf("%s", cs); 589 } 590 591 /* 592 * Print a warning message including an optional jail name. 593 */ 594 void 595 jail_warnx(const struct cfjail *j, const char *fmt, ...) 596 { 597 va_list ap, tap; 598 char *cs; 599 size_t len; 600 601 va_start(ap, fmt); 602 va_copy(tap, ap); 603 len = vsnprintf(NULL, 0, fmt, tap); 604 va_end(tap); 605 cs = alloca(len + 1); 606 (void)vsnprintf(cs, len + 1, fmt, ap); 607 va_end(ap); 608 if (j->name) 609 warnx("%s: %s", j->name, cs); 610 else 611 warnx("%s", cs); 612 } 613 614 /* 615 * Create a new jail. 616 */ 617 int 618 create_jail(struct cfjail *j) 619 { 620 struct stat st; 621 struct jailparam *jp, *setparams, *sjp; 622 const char *path; 623 int dopersist, ns; 624 625 /* 626 * Check the jail's path, with a better error message than jail_set 627 * gives. 628 */ 629 if ((path = string_param(j->intparams[KP_PATH]))) { 630 if (j->name != NULL && path[0] != '/') { 631 jail_warnx(j, "path %s: not an absolute pathname", 632 path); 633 return -1; 634 } 635 if (stat(path, &st) < 0) { 636 jail_warnx(j, "path %s: %s", path, strerror(errno)); 637 return -1; 638 } 639 if (!S_ISDIR(st.st_mode)) { 640 jail_warnx(j, "path %s: %s", path, strerror(ENOTDIR)); 641 return -1; 642 } 643 } 644 645 /* 646 * Copy all the parameters, except that "persist" is always set when 647 * there are commands to run later. 648 */ 649 dopersist = !bool_param(j->intparams[KP_PERSIST]) && 650 (j->intparams[IP_EXEC_START] || j->intparams[IP_COMMAND] || 651 j->intparams[IP_EXEC_POSTSTART]); 652 sjp = setparams = 653 alloca((j->njp + dopersist) * sizeof(struct jailparam)); 654 if (dopersist && jailparam_init(sjp++, "persist") < 0) { 655 jail_warnx(j, "%s", jail_errmsg); 656 return -1; 657 } 658 for (jp = j->jp; jp < j->jp + j->njp; jp++) 659 if (!dopersist || !equalopts(jp->jp_name, "persist")) 660 *sjp++ = *jp; 661 ns = sjp - setparams; 662 663 j->jid = jailparam_set_note(j, setparams, ns, JAIL_CREATE); 664 if (j->jid < 0) { 665 jail_warnx(j, "%s", jail_errmsg); 666 failed(j); 667 } 668 if (dopersist) { 669 jailparam_free(setparams, 1); 670 if (j->jid > 0) 671 j->flags |= JF_PERSIST; 672 } 673 return j->jid; 674 } 675 676 /* 677 * Remove a temporarily set "persist" parameter. 678 */ 679 static void 680 clear_persist(struct cfjail *j) 681 { 682 struct iovec jiov[4]; 683 int jid; 684 685 if (!(j->flags & JF_PERSIST)) 686 return; 687 j->flags &= ~JF_PERSIST; 688 jiov[0].iov_base = __DECONST(char *, "jid"); 689 jiov[0].iov_len = sizeof("jid"); 690 jiov[1].iov_base = &j->jid; 691 jiov[1].iov_len = sizeof(j->jid); 692 jiov[2].iov_base = __DECONST(char *, "nopersist"); 693 jiov[2].iov_len = sizeof("nopersist"); 694 jiov[3].iov_base = NULL; 695 jiov[3].iov_len = 0; 696 jid = jail_set(jiov, 4, JAIL_UPDATE); 697 if (verbose > 0) 698 jail_note(j, "jail_set(JAIL_UPDATE) jid=%d nopersist%s%s\n", 699 j->jid, jid < 0 ? ": " : "", 700 jid < 0 ? strerror(errno) : ""); 701 } 702 703 /* 704 * Set a jail's parameters. 705 */ 706 static int 707 update_jail(struct cfjail *j) 708 { 709 struct jailparam *jp, *setparams, *sjp; 710 int ns, jid; 711 712 ns = 0; 713 for (jp = j->jp; jp < j->jp + j->njp; jp++) 714 if (!JP_RDTUN(jp)) 715 ns++; 716 if (ns == 0) 717 return 0; 718 sjp = setparams = alloca(++ns * sizeof(struct jailparam)); 719 if (jailparam_init(sjp, "jid") < 0 || 720 jailparam_import_raw(sjp, &j->jid, sizeof j->jid) < 0) { 721 jail_warnx(j, "%s", jail_errmsg); 722 failed(j); 723 return -1; 724 } 725 for (jp = j->jp; jp < j->jp + j->njp; jp++) 726 if (!JP_RDTUN(jp)) 727 *++sjp = *jp; 728 729 jid = jailparam_set_note(j, setparams, ns, JAIL_UPDATE); 730 if (jid < 0) { 731 jail_warnx(j, "%s", jail_errmsg); 732 failed(j); 733 } 734 jailparam_free(setparams, 1); 735 return jid; 736 } 737 738 /* 739 * Return if a jail set would change any create-only parameters. 740 */ 741 static int 742 rdtun_params(struct cfjail *j, int dofail) 743 { 744 struct jailparam *jp, *rtparams, *rtjp; 745 const void *jp_value; 746 size_t jp_valuelen; 747 int nrt, rval, bool_true; 748 749 if (j->flags & JF_RDTUN) 750 return 0; 751 j->flags |= JF_RDTUN; 752 nrt = 0; 753 for (jp = j->jp; jp < j->jp + j->njp; jp++) 754 if (JP_RDTUN(jp) && strcmp(jp->jp_name, "jid")) 755 nrt++; 756 if (nrt == 0) 757 return 0; 758 rtjp = rtparams = alloca(++nrt * sizeof(struct jailparam)); 759 if (jailparam_init(rtjp, "jid") < 0 || 760 jailparam_import_raw(rtjp, &j->jid, sizeof j->jid) < 0) { 761 jail_warnx(j, "%s", jail_errmsg); 762 exit(1); 763 } 764 for (jp = j->jp; jp < j->jp + j->njp; jp++) 765 if (JP_RDTUN(jp) && strcmp(jp->jp_name, "jid")) { 766 *++rtjp = *jp; 767 rtjp->jp_value = NULL; 768 } 769 rval = 0; 770 if (jailparam_get(rtparams, nrt, 0) > 0) { 771 rtjp = rtparams + 1; 772 for (jp = j->jp; rtjp < rtparams + nrt; jp++) { 773 if (JP_RDTUN(jp) && strcmp(jp->jp_name, "jid")) { 774 jp_value = jp->jp_value; 775 jp_valuelen = jp->jp_valuelen; 776 if (jp_value == NULL && jp_valuelen > 0) { 777 if (jp->jp_flags & (JP_BOOL | 778 JP_NOBOOL | JP_JAILSYS)) { 779 bool_true = 1; 780 jp_value = &bool_true; 781 jp_valuelen = sizeof(bool_true); 782 } else if ((jp->jp_ctltype & CTLTYPE) == 783 CTLTYPE_STRING) 784 jp_value = ""; 785 else 786 jp_valuelen = 0; 787 } 788 if (rtjp->jp_valuelen != jp_valuelen || 789 (CTLTYPE_STRING ? strncmp(rtjp->jp_value, 790 jp_value, jp_valuelen) 791 : memcmp(rtjp->jp_value, jp_value, 792 jp_valuelen))) { 793 if (dofail) { 794 jail_warnx(j, "%s cannot be " 795 "changed after creation", 796 jp->jp_name); 797 failed(j); 798 rval = -1; 799 } else 800 rval = 1; 801 break; 802 } 803 rtjp++; 804 } 805 } 806 } 807 for (rtjp = rtparams + 1; rtjp < rtparams + nrt; rtjp++) 808 rtjp->jp_name = NULL; 809 jailparam_free(rtparams, nrt); 810 return rval; 811 } 812 813 /* 814 * Get the jail's jid if it is running. 815 */ 816 static void 817 running_jid(struct cfjail *j) 818 { 819 struct iovec jiov[2]; 820 const char *pval; 821 char *ep; 822 int jid; 823 824 if ((pval = string_param(j->intparams[KP_JID]))) { 825 if (!(jid = strtol(pval, &ep, 10)) || *ep) { 826 j->jid = -1; 827 return; 828 } 829 jiov[0].iov_base = __DECONST(char *, "jid"); 830 jiov[0].iov_len = sizeof("jid"); 831 jiov[1].iov_base = &jid; 832 jiov[1].iov_len = sizeof(jid); 833 } else if ((pval = string_param(j->intparams[KP_NAME]))) { 834 jiov[0].iov_base = __DECONST(char *, "name"); 835 jiov[0].iov_len = sizeof("name"); 836 jiov[1].iov_len = strlen(pval) + 1; 837 jiov[1].iov_base = alloca(jiov[1].iov_len); 838 strcpy(jiov[1].iov_base, pval); 839 } else { 840 j->jid = -1; 841 return; 842 } 843 j->jid = jail_get(jiov, 2, 0); 844 } 845 846 static void 847 jail_quoted_warnx(const struct cfjail *j, const char *name_msg, 848 const char *noname_msg) 849 { 850 const char *pval; 851 852 if ((pval = j->name) || (pval = string_param(j->intparams[KP_JID])) || 853 (pval = string_param(j->intparams[KP_NAME]))) 854 warnx("\"%s\" %s", pval, name_msg); 855 else 856 warnx("%s", noname_msg); 857 } 858 859 /* 860 * Set jail parameters and possibly print them out. 861 */ 862 static int 863 jailparam_set_note(const struct cfjail *j, struct jailparam *jp, unsigned njp, 864 int flags) 865 { 866 char *value; 867 int jid; 868 unsigned i; 869 870 jid = jailparam_set(jp, njp, flags); 871 if (verbose > 0) { 872 jail_note(j, "jail_set(%s)", 873 (flags & (JAIL_CREATE | JAIL_UPDATE)) == JAIL_CREATE 874 ? "JAIL_CREATE" : "JAIL_UPDATE"); 875 for (i = 0; i < njp; i++) { 876 printf(" %s", jp[i].jp_name); 877 if (jp[i].jp_value == NULL) 878 continue; 879 putchar('='); 880 value = jailparam_export(jp + i); 881 if (value == NULL) 882 err(1, "jailparam_export"); 883 quoted_print(stdout, value); 884 free(value); 885 } 886 if (jid < 0) 887 printf(": %s", strerror(errno)); 888 printf("\n"); 889 } 890 return jid; 891 } 892 893 /* 894 * Print a jail record. 895 */ 896 static void 897 print_jail(FILE *fp, struct cfjail *j, int oldcl, int running) 898 { 899 struct cfparam *p; 900 int printsep; 901 902 if (oldcl) { 903 if (running) 904 fprintf(fp, "%d%s", j->jid, separator); 905 print_param(fp, j->intparams[KP_PATH], ',', 0); 906 fputs(separator, fp); 907 print_param(fp, j->intparams[KP_HOST_HOSTNAME], ',', 0); 908 fputs(separator, fp); 909 #ifdef INET 910 print_param(fp, j->intparams[KP_IP4_ADDR], ',', 0); 911 #ifdef INET6 912 if (j->intparams[KP_IP4_ADDR] && 913 !TAILQ_EMPTY(&j->intparams[KP_IP4_ADDR]->val) && 914 j->intparams[KP_IP6_ADDR] && 915 !TAILQ_EMPTY(&j->intparams[KP_IP6_ADDR]->val)) 916 putc(',', fp); 917 #endif 918 #endif 919 #ifdef INET6 920 print_param(fp, j->intparams[KP_IP6_ADDR], ',', 0); 921 #endif 922 fputs(separator, fp); 923 print_param(fp, j->intparams[IP_COMMAND], ' ', 0); 924 } else { 925 printsep = 0; 926 if (running) { 927 fprintf(fp, "jid=%d", j->jid); 928 printsep = 1; 929 } 930 TAILQ_FOREACH(p, &j->params, tq) 931 if (strcmp(p->name, "jid")) { 932 if (printsep) 933 fputs(separator, fp); 934 else 935 printsep = 1; 936 print_param(fp, p, ',', 1); 937 } 938 } 939 putc('\n', fp); 940 } 941 942 /* 943 * Exhibit list of all configured non-wildcard jails 944 */ 945 static void 946 show_jails(void) 947 { 948 struct cfjail *j; 949 950 TAILQ_FOREACH(j, &cfjails, tq) 951 print_jail(stdout, j, 0, 0); 952 } 953 954 /* 955 * Print a parameter value, or a name=value pair. 956 */ 957 static void 958 print_param(FILE *fp, const struct cfparam *p, int sep, int doname) 959 { 960 const struct cfstring *s, *ts; 961 962 if (doname) 963 fputs(p->name, fp); 964 if (p == NULL || TAILQ_EMPTY(&p->val)) 965 return; 966 if (doname) 967 putc('=', fp); 968 TAILQ_FOREACH_SAFE(s, &p->val, tq, ts) { 969 quoted_print(fp, s->s); 970 if (ts != NULL) 971 putc(sep, fp); 972 } 973 } 974 975 /* 976 * Print a string with quotes around spaces. 977 */ 978 static void 979 quoted_print(FILE *fp, char *str) 980 { 981 int c, qc; 982 char *p = str; 983 984 qc = !*p ? '"' 985 : strchr(p, '\'') ? '"' 986 : strchr(p, '"') ? '\'' 987 : strchr(p, ' ') || strchr(p, '\t') ? '"' 988 : 0; 989 if (qc) 990 putc(qc, fp); 991 while ((c = *p++)) { 992 if (c == '\\' || c == qc) 993 putc('\\', fp); 994 putc(c, fp); 995 } 996 if (qc) 997 putc(qc, fp); 998 } 999 1000 static void 1001 usage(void) 1002 { 1003 1004 (void)fprintf(stderr, 1005 "usage: jail [-dhilqv] [-J jid_file] [-u username] [-U username]\n" 1006 " -[cmr] param=value ... [command=command ...]\n" 1007 " jail [-dqv] [-f file] -[cmr] [jail]\n" 1008 " jail [-qv] [-f file] -[rR] ['*' | jail ...]\n" 1009 " jail [-dhilqv] [-J jid_file] [-u username] [-U username]\n" 1010 " [-n jailname] [-s securelevel]\n" 1011 " path hostname ip[,...] command ...\n" 1012 " jail [-f file] -e separator\n"); 1013 exit(1); 1014 } 1015