1 /*- 2 * Copyright (c) 2013-15, Stacey D. Son 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/ctype.h> 32 #include <sys/sbuf.h> 33 #include <sys/systm.h> 34 #include <sys/sysproto.h> 35 #include <sys/exec.h> 36 #include <sys/imgact.h> 37 #include <sys/imgact_binmisc.h> 38 #include <sys/kernel.h> 39 #include <sys/libkern.h> 40 #include <sys/lock.h> 41 #include <sys/malloc.h> 42 #include <sys/mutex.h> 43 #include <sys/sysctl.h> 44 #include <sys/sx.h> 45 46 #include <machine/atomic.h> 47 48 /** 49 * Miscellaneous binary interpreter image activator. 50 * 51 * If the given target executable's header matches 'xbe_magic' field in the 52 * 'interpreter_list' then it will use the user-level interpreter specified in 53 * the 'xbe_interpreter' field to execute the binary. The 'xbe_magic' field may 54 * be adjusted to a given offset using the value in the 'xbe_moffset' field 55 * and bits of the header may be masked using the 'xbe_mask' field. The 56 * 'interpreter_list' entries are managed using sysctl(3) as described in the 57 * <sys/imgact_binmisc.h> file. 58 */ 59 60 /* 61 * Node of the interpreter list. 62 */ 63 typedef struct imgact_binmisc_entry { 64 char *ibe_name; 65 uint8_t *ibe_magic; 66 uint32_t ibe_moffset; 67 uint32_t ibe_msize; 68 uint8_t *ibe_mask; 69 uint8_t *ibe_interpreter; 70 uint32_t ibe_interp_argcnt; 71 uint32_t ibe_interp_length; 72 uint32_t ibe_flags; 73 SLIST_ENTRY(imgact_binmisc_entry) link; 74 } imgact_binmisc_entry_t; 75 76 /* 77 * sysctl() commands. 78 */ 79 #define IBC_ADD 1 /* Add given entry. */ 80 #define IBC_REMOVE 2 /* Remove entry for a given name. */ 81 #define IBC_DISABLE 3 /* Disable entry for a given name. */ 82 #define IBC_ENABLE 4 /* Enable entry for a given name. */ 83 #define IBC_LOOKUP 5 /* Lookup and return entry for given name. */ 84 #define IBC_LIST 6 /* Get a snapshot of the interpretor list. */ 85 86 /* 87 * Interpreter string macros. 88 * 89 * They all start with '#' followed by a single letter: 90 */ 91 #define ISM_POUND '#' /* "##" is the escape sequence for single #. */ 92 #define ISM_OLD_ARGV0 'a' /* "#a" is replaced with the old argv0. */ 93 94 MALLOC_DEFINE(M_BINMISC, KMOD_NAME, "misc binary image activator"); 95 96 /* The interpreter list. */ 97 static SLIST_HEAD(, imgact_binmisc_entry) interpreter_list = 98 SLIST_HEAD_INITIALIZER(interpreter_list); 99 100 static int interp_list_entry_count = 0; 101 102 static struct sx interp_list_sx; 103 104 /* 105 * Populate the entry with the information about the interpreter. 106 */ 107 static void 108 imgact_binmisc_populate_interp(char *str, imgact_binmisc_entry_t *ibe) 109 { 110 uint32_t len = 0, argc = 1; 111 char t[IBE_INTERP_LEN_MAX]; 112 char *sp, *tp; 113 114 memset(t, 0, sizeof(t)); 115 116 /* 117 * Normalize interpreter string. Replace white space between args with 118 * single space. 119 */ 120 sp = str; tp = t; 121 while (*sp != '\0') { 122 if (*sp == ' ' || *sp == '\t') { 123 if (++len > IBE_INTERP_LEN_MAX) 124 break; 125 *tp++ = ' '; 126 argc++; 127 while (*sp == ' ' || *sp == '\t') 128 sp++; 129 continue; 130 } else { 131 *tp++ = *sp++; 132 len++; 133 } 134 } 135 *tp = '\0'; 136 len++; 137 138 ibe->ibe_interpreter = malloc(len, M_BINMISC, M_WAITOK|M_ZERO); 139 140 /* Populate all the ibe fields for the interpreter. */ 141 memcpy(ibe->ibe_interpreter, t, len); 142 ibe->ibe_interp_argcnt = argc; 143 ibe->ibe_interp_length = len; 144 } 145 146 /* 147 * Allocate memory and populate a new entry for the interpreter table. 148 */ 149 static imgact_binmisc_entry_t * 150 imgact_binmisc_new_entry(ximgact_binmisc_entry_t *xbe) 151 { 152 imgact_binmisc_entry_t *ibe = NULL; 153 size_t namesz = min(strlen(xbe->xbe_name) + 1, IBE_NAME_MAX); 154 155 ibe = malloc(sizeof(*ibe), M_BINMISC, M_WAITOK|M_ZERO); 156 157 ibe->ibe_name = malloc(namesz, M_BINMISC, M_WAITOK|M_ZERO); 158 strlcpy(ibe->ibe_name, xbe->xbe_name, namesz); 159 160 imgact_binmisc_populate_interp(xbe->xbe_interpreter, ibe); 161 162 ibe->ibe_magic = malloc(xbe->xbe_msize, M_BINMISC, M_WAITOK|M_ZERO); 163 memcpy(ibe->ibe_magic, xbe->xbe_magic, xbe->xbe_msize); 164 165 ibe->ibe_mask = malloc(xbe->xbe_msize, M_BINMISC, M_WAITOK|M_ZERO); 166 memcpy(ibe->ibe_mask, xbe->xbe_mask, xbe->xbe_msize); 167 168 ibe->ibe_moffset = xbe->xbe_moffset; 169 ibe->ibe_msize = xbe->xbe_msize; 170 ibe->ibe_flags = xbe->xbe_flags; 171 172 return (ibe); 173 } 174 175 /* 176 * Free the allocated memory for a given list item. 177 */ 178 static void 179 imgact_binmisc_destroy_entry(imgact_binmisc_entry_t *ibe) 180 { 181 if (!ibe) 182 return; 183 if (ibe->ibe_magic) 184 free(ibe->ibe_magic, M_BINMISC); 185 if (ibe->ibe_mask) 186 free(ibe->ibe_mask, M_BINMISC); 187 if (ibe->ibe_interpreter) 188 free(ibe->ibe_interpreter, M_BINMISC); 189 if (ibe->ibe_name) 190 free(ibe->ibe_name, M_BINMISC); 191 if (ibe) 192 free(ibe, M_BINMISC); 193 } 194 195 /* 196 * Find the interpreter in the list by the given name. Return NULL if not 197 * found. 198 */ 199 static imgact_binmisc_entry_t * 200 imgact_binmisc_find_entry(char *name) 201 { 202 imgact_binmisc_entry_t *ibe; 203 204 sx_assert(&interp_list_sx, SA_LOCKED); 205 206 SLIST_FOREACH(ibe, &interpreter_list, link) { 207 if (strncmp(name, ibe->ibe_name, IBE_NAME_MAX) == 0) 208 return (ibe); 209 } 210 211 return (NULL); 212 } 213 214 /* 215 * Add the given interpreter if it doesn't already exist. Return EEXIST 216 * if the name already exist in the interpreter list. 217 */ 218 static int 219 imgact_binmisc_add_entry(ximgact_binmisc_entry_t *xbe) 220 { 221 imgact_binmisc_entry_t *ibe; 222 char *p; 223 224 if (xbe->xbe_msize > IBE_MAGIC_MAX) 225 return (EINVAL); 226 227 for(p = xbe->xbe_name; *p != 0; p++) 228 if (!isascii((int)*p)) 229 return (EINVAL); 230 231 for(p = xbe->xbe_interpreter; *p != 0; p++) 232 if (!isascii((int)*p)) 233 return (EINVAL); 234 235 /* Make sure we don't have any invalid #'s. */ 236 p = xbe->xbe_interpreter; 237 while (1) { 238 p = strchr(p, '#'); 239 if (!p) 240 break; 241 242 p++; 243 switch(*p) { 244 case ISM_POUND: 245 /* "##" */ 246 p++; 247 break; 248 249 case ISM_OLD_ARGV0: 250 /* "#a" */ 251 p++; 252 break; 253 254 case 0: 255 default: 256 /* Anything besides the above is invalid. */ 257 return (EINVAL); 258 } 259 } 260 261 sx_xlock(&interp_list_sx); 262 if (imgact_binmisc_find_entry(xbe->xbe_name) != NULL) { 263 sx_xunlock(&interp_list_sx); 264 return (EEXIST); 265 } 266 267 /* Preallocate a new entry. */ 268 ibe = imgact_binmisc_new_entry(xbe); 269 if (!ibe) 270 return (ENOMEM); 271 272 SLIST_INSERT_HEAD(&interpreter_list, ibe, link); 273 interp_list_entry_count++; 274 sx_xunlock(&interp_list_sx); 275 276 return (0); 277 } 278 279 /* 280 * Remove the interpreter in the list with the given name. Return ENOENT 281 * if not found. 282 */ 283 static int 284 imgact_binmisc_remove_entry(char *name) 285 { 286 imgact_binmisc_entry_t *ibe; 287 288 sx_xlock(&interp_list_sx); 289 if ((ibe = imgact_binmisc_find_entry(name)) == NULL) { 290 sx_xunlock(&interp_list_sx); 291 return (ENOENT); 292 } 293 SLIST_REMOVE(&interpreter_list, ibe, imgact_binmisc_entry, link); 294 interp_list_entry_count--; 295 sx_xunlock(&interp_list_sx); 296 297 imgact_binmisc_destroy_entry(ibe); 298 299 return (0); 300 } 301 302 /* 303 * Disable the interpreter in the list with the given name. Return ENOENT 304 * if not found. 305 */ 306 static int 307 imgact_binmisc_disable_entry(char *name) 308 { 309 imgact_binmisc_entry_t *ibe; 310 311 sx_xlock(&interp_list_sx); 312 if ((ibe = imgact_binmisc_find_entry(name)) == NULL) { 313 sx_xunlock(&interp_list_sx); 314 return (ENOENT); 315 } 316 317 ibe->ibe_flags &= ~IBF_ENABLED; 318 sx_xunlock(&interp_list_sx); 319 320 return (0); 321 } 322 323 /* 324 * Enable the interpreter in the list with the given name. Return ENOENT 325 * if not found. 326 */ 327 static int 328 imgact_binmisc_enable_entry(char *name) 329 { 330 imgact_binmisc_entry_t *ibe; 331 332 sx_xlock(&interp_list_sx); 333 if ((ibe = imgact_binmisc_find_entry(name)) == NULL) { 334 sx_xunlock(&interp_list_sx); 335 return (ENOENT); 336 } 337 338 ibe->ibe_flags |= IBF_ENABLED; 339 sx_xunlock(&interp_list_sx); 340 341 return (0); 342 } 343 344 static int 345 imgact_binmisc_populate_xbe(ximgact_binmisc_entry_t *xbe, 346 imgact_binmisc_entry_t *ibe) 347 { 348 uint32_t i; 349 350 sx_assert(&interp_list_sx, SA_LOCKED); 351 352 memset(xbe, 0, sizeof(*xbe)); 353 strlcpy(xbe->xbe_name, ibe->ibe_name, IBE_NAME_MAX); 354 355 /* Copy interpreter string. Replace NULL breaks with space. */ 356 memcpy(xbe->xbe_interpreter, ibe->ibe_interpreter, 357 ibe->ibe_interp_length); 358 for(i = 0; i < (ibe->ibe_interp_length - 1); i++) 359 if (xbe->xbe_interpreter[i] == '\0') 360 xbe->xbe_interpreter[i] = ' '; 361 362 memcpy(xbe->xbe_magic, ibe->ibe_magic, ibe->ibe_msize); 363 memcpy(xbe->xbe_mask, ibe->ibe_mask, ibe->ibe_msize); 364 xbe->xbe_version = IBE_VERSION; 365 xbe->xbe_flags = ibe->ibe_flags; 366 xbe->xbe_moffset = ibe->ibe_moffset; 367 xbe->xbe_msize = ibe->ibe_msize; 368 369 return (0); 370 } 371 372 /* 373 * Retrieve the interpreter with the give name and populate the 374 * ximgact_binmisc_entry structure. Return ENOENT if not found. 375 */ 376 static int 377 imgact_binmisc_lookup_entry(char *name, ximgact_binmisc_entry_t *xbe) 378 { 379 imgact_binmisc_entry_t *ibe; 380 int error = 0; 381 382 sx_slock(&interp_list_sx); 383 if ((ibe = imgact_binmisc_find_entry(name)) == NULL) { 384 sx_sunlock(&interp_list_sx); 385 return (ENOENT); 386 } 387 388 error = imgact_binmisc_populate_xbe(xbe, ibe); 389 sx_sunlock(&interp_list_sx); 390 391 return (error); 392 } 393 394 /* 395 * Get a snapshot of all the interpreter entries in the list. 396 */ 397 static int 398 imgact_binmisc_get_all_entries(struct sysctl_req *req) 399 { 400 ximgact_binmisc_entry_t *xbe, *xbep; 401 imgact_binmisc_entry_t *ibe; 402 int error = 0, count; 403 404 sx_slock(&interp_list_sx); 405 count = interp_list_entry_count; 406 xbe = malloc(sizeof(*xbe) * count, M_BINMISC, M_WAITOK|M_ZERO); 407 408 xbep = xbe; 409 SLIST_FOREACH(ibe, &interpreter_list, link) { 410 error = imgact_binmisc_populate_xbe(xbep++, ibe); 411 if (error) 412 break; 413 } 414 sx_sunlock(&interp_list_sx); 415 416 if (!error) 417 error = SYSCTL_OUT(req, xbe, sizeof(*xbe) * count); 418 419 free(xbe, M_BINMISC); 420 return (error); 421 } 422 423 /* 424 * sysctl() handler for munipulating interpretor table. 425 * Not MP safe (locked by sysctl). 426 */ 427 static int 428 sysctl_kern_binmisc(SYSCTL_HANDLER_ARGS) 429 { 430 ximgact_binmisc_entry_t xbe; 431 int error = 0; 432 433 switch(arg2) { 434 case IBC_ADD: 435 /* Add an entry. Limited to IBE_MAX_ENTRIES. */ 436 error = SYSCTL_IN(req, &xbe, sizeof(xbe)); 437 if (error) 438 return (error); 439 if (IBE_VERSION != xbe.xbe_version) 440 return (EINVAL); 441 if (interp_list_entry_count == IBE_MAX_ENTRIES) 442 return (ENOSPC); 443 error = imgact_binmisc_add_entry(&xbe); 444 break; 445 446 case IBC_REMOVE: 447 /* Remove an entry. */ 448 error = SYSCTL_IN(req, &xbe, sizeof(xbe)); 449 if (error) 450 return (error); 451 if (IBE_VERSION != xbe.xbe_version) 452 return (EINVAL); 453 error = imgact_binmisc_remove_entry(xbe.xbe_name); 454 break; 455 456 case IBC_DISABLE: 457 /* Disable an entry. */ 458 error = SYSCTL_IN(req, &xbe, sizeof(xbe)); 459 if (error) 460 return (error); 461 if (IBE_VERSION != xbe.xbe_version) 462 return (EINVAL); 463 error = imgact_binmisc_disable_entry(xbe.xbe_name); 464 break; 465 466 case IBC_ENABLE: 467 /* Enable an entry. */ 468 error = SYSCTL_IN(req, &xbe, sizeof(xbe)); 469 if (error) 470 return (error); 471 if (IBE_VERSION != xbe.xbe_version) 472 return (EINVAL); 473 error = imgact_binmisc_enable_entry(xbe.xbe_name); 474 break; 475 476 case IBC_LOOKUP: 477 /* Lookup an entry. */ 478 error = SYSCTL_IN(req, &xbe, sizeof(xbe)); 479 if (error) 480 return (error); 481 if (IBE_VERSION != xbe.xbe_version) 482 return (EINVAL); 483 error = imgact_binmisc_lookup_entry(xbe.xbe_name, &xbe); 484 if (!error) 485 error = SYSCTL_OUT(req, &xbe, sizeof(xbe)); 486 break; 487 488 case IBC_LIST: 489 /* Return a snapshot of the interpretor list. */ 490 491 if (!req->oldptr) { 492 /* No pointer then just return the list size. */ 493 error = SYSCTL_OUT(req, 0, interp_list_entry_count * 494 sizeof(ximgact_binmisc_entry_t)); 495 return (error); 496 } else 497 if (!req->oldlen) 498 return (EINVAL); 499 500 error = imgact_binmisc_get_all_entries(req); 501 break; 502 503 default: 504 return (EINVAL); 505 } 506 507 return (error); 508 } 509 510 SYSCTL_NODE(_kern, OID_AUTO, binmisc, CTLFLAG_RW, 0, 511 "Image activator for miscellaneous binaries"); 512 513 SYSCTL_PROC(_kern_binmisc, OID_AUTO, add, 514 CTLFLAG_MPSAFE|CTLTYPE_STRUCT|CTLFLAG_WR, NULL, IBC_ADD, 515 sysctl_kern_binmisc, "S,ximgact_binmisc_entry", 516 "Add an activator entry"); 517 518 SYSCTL_PROC(_kern_binmisc, OID_AUTO, remove, 519 CTLFLAG_MPSAFE|CTLTYPE_STRUCT|CTLFLAG_WR, NULL, IBC_REMOVE, 520 sysctl_kern_binmisc, "S,ximgact_binmisc_entry", 521 "Remove an activator entry"); 522 523 SYSCTL_PROC(_kern_binmisc, OID_AUTO, disable, 524 CTLFLAG_MPSAFE|CTLTYPE_STRUCT|CTLFLAG_WR, NULL, IBC_DISABLE, 525 sysctl_kern_binmisc, "S,ximgact_binmisc_entry", 526 "Disable an activator entry"); 527 528 SYSCTL_PROC(_kern_binmisc, OID_AUTO, enable, 529 CTLFLAG_MPSAFE|CTLTYPE_STRUCT|CTLFLAG_WR, NULL, IBC_ENABLE, 530 sysctl_kern_binmisc, "S,ximgact_binmisc_entry", 531 "Enable an activator entry"); 532 533 SYSCTL_PROC(_kern_binmisc, OID_AUTO, lookup, 534 CTLFLAG_MPSAFE|CTLTYPE_STRUCT|CTLFLAG_RW|CTLFLAG_ANYBODY, NULL, IBC_LOOKUP, 535 sysctl_kern_binmisc, "S,ximgact_binmisc_entry", 536 "Lookup an activator entry"); 537 538 SYSCTL_PROC(_kern_binmisc, OID_AUTO, list, 539 CTLFLAG_MPSAFE|CTLTYPE_STRUCT|CTLFLAG_RD|CTLFLAG_ANYBODY, NULL, IBC_LIST, 540 sysctl_kern_binmisc, "S,ximgact_binmisc_entry", 541 "Get snapshot of all the activator entries"); 542 543 static imgact_binmisc_entry_t * 544 imgact_binmisc_find_interpreter(const char *image_header) 545 { 546 imgact_binmisc_entry_t *ibe; 547 const char *p; 548 int i; 549 size_t sz; 550 551 sx_assert(&interp_list_sx, SA_LOCKED); 552 553 SLIST_FOREACH(ibe, &interpreter_list, link) { 554 if (!(IBF_ENABLED & ibe->ibe_flags)) 555 continue; 556 557 p = image_header + ibe->ibe_moffset; 558 sz = ibe->ibe_msize; 559 if (IBF_USE_MASK & ibe->ibe_flags) { 560 /* Compare using mask. */ 561 for (i = 0; i < sz; i++) 562 if ((*p++ ^ ibe->ibe_magic[i]) & 563 ibe->ibe_mask[i]) 564 break; 565 } else { 566 for (i = 0; i < sz; i++) 567 if (*p++ ^ ibe->ibe_magic[i]) 568 break; 569 } 570 if (i == ibe->ibe_msize) 571 return (ibe); 572 } 573 return (NULL); 574 } 575 576 static int 577 imgact_binmisc_exec(struct image_params *imgp) 578 { 579 const char *image_header = imgp->image_header; 580 const char *fname = NULL; 581 int error = 0; 582 size_t offset, l; 583 imgact_binmisc_entry_t *ibe; 584 struct sbuf *sname; 585 char *s, *d; 586 587 /* Do we have an interpreter for the given image header? */ 588 sx_slock(&interp_list_sx); 589 if ((ibe = imgact_binmisc_find_interpreter(image_header)) == NULL) { 590 sx_sunlock(&interp_list_sx); 591 return (-1); 592 } 593 594 /* No interpreter nesting allowed. */ 595 if (imgp->interpreted & IMGACT_BINMISC) { 596 sx_sunlock(&interp_list_sx); 597 return (ENOEXEC); 598 } 599 600 imgp->interpreted |= IMGACT_BINMISC; 601 602 if (imgp->args->fname != NULL) { 603 fname = imgp->args->fname; 604 sname = NULL; 605 } else { 606 /* Use the fdescfs(5) path for fexecve(2). */ 607 sname = sbuf_new_auto(); 608 sbuf_printf(sname, "/dev/fd/%d", imgp->args->fd); 609 sbuf_finish(sname); 610 fname = sbuf_data(sname); 611 } 612 613 614 /* 615 * We need to "push" the interpreter in the arg[] list. To do this, 616 * we first shift all the other values in the `begin_argv' area to 617 * provide the exact amount of room for the values added. Set up 618 * `offset' as the number of bytes to be added to the `begin_argv' 619 * area. 620 */ 621 offset = ibe->ibe_interp_length; 622 623 /* Adjust the offset for #'s. */ 624 s = ibe->ibe_interpreter; 625 while (1) { 626 s = strchr(s, '#'); 627 if (!s) 628 break; 629 630 s++; 631 switch(*s) { 632 case ISM_POUND: 633 /* "##" -> "#": reduce offset by one. */ 634 offset--; 635 break; 636 637 case ISM_OLD_ARGV0: 638 /* "#a" -> (old argv0): increase offset to fit fname */ 639 offset += strlen(fname) - 2; 640 break; 641 642 default: 643 /* Hmm... This shouldn't happen. */ 644 sx_sunlock(&interp_list_sx); 645 printf("%s: Unknown macro #%c sequence in " 646 "interpreter string\n", KMOD_NAME, *(s + 1)); 647 error = EINVAL; 648 goto done; 649 } 650 s++; 651 } 652 653 /* Check to make sure we won't overrun the stringspace. */ 654 if (offset > imgp->args->stringspace) { 655 sx_sunlock(&interp_list_sx); 656 error = E2BIG; 657 goto done; 658 } 659 660 /* Make room for the interpreter */ 661 bcopy(imgp->args->begin_argv, imgp->args->begin_argv + offset, 662 imgp->args->endp - imgp->args->begin_argv); 663 664 /* Adjust everything by the offset. */ 665 imgp->args->begin_envv += offset; 666 imgp->args->endp += offset; 667 imgp->args->stringspace -= offset; 668 669 /* Add the new argument(s) in the count. */ 670 imgp->args->argc += ibe->ibe_interp_argcnt; 671 672 /* 673 * The original arg[] list has been shifted appropriately. Copy in 674 * the interpreter path. 675 */ 676 s = ibe->ibe_interpreter; 677 d = imgp->args->begin_argv; 678 while(*s != '\0') { 679 switch (*s) { 680 case '#': 681 /* Handle "#" in interpreter string. */ 682 s++; 683 switch(*s) { 684 case ISM_POUND: 685 /* "##": Replace with a single '#' */ 686 *d++ = '#'; 687 break; 688 689 case ISM_OLD_ARGV0: 690 /* "#a": Replace with old arg0 (fname). */ 691 if ((l = strlen(fname)) != 0) { 692 memcpy(d, fname, l); 693 d += l; 694 } 695 break; 696 697 default: 698 /* Shouldn't happen but skip it if it does. */ 699 break; 700 } 701 break; 702 703 case ' ': 704 /* Replace space with NUL to seperate arguments. */ 705 *d++ = '\0'; 706 break; 707 708 default: 709 *d++ = *s; 710 break; 711 } 712 s++; 713 } 714 *d = '\0'; 715 sx_sunlock(&interp_list_sx); 716 717 if (!error) 718 imgp->interpreter_name = imgp->args->begin_argv; 719 720 721 done: 722 if (sname) 723 sbuf_delete(sname); 724 return (error); 725 } 726 727 static void 728 imgact_binmisc_init(void *arg) 729 { 730 731 sx_init(&interp_list_sx, KMOD_NAME); 732 } 733 734 static void 735 imgact_binmisc_fini(void *arg) 736 { 737 imgact_binmisc_entry_t *ibe, *ibe_tmp; 738 739 /* Free all the interpreters. */ 740 sx_xlock(&interp_list_sx); 741 SLIST_FOREACH_SAFE(ibe, &interpreter_list, link, ibe_tmp) { 742 SLIST_REMOVE(&interpreter_list, ibe, imgact_binmisc_entry, 743 link); 744 imgact_binmisc_destroy_entry(ibe); 745 } 746 sx_xunlock(&interp_list_sx); 747 748 sx_destroy(&interp_list_sx); 749 } 750 751 SYSINIT(imgact_binmisc, SI_SUB_EXEC, SI_ORDER_MIDDLE, imgact_binmisc_init, 0); 752 SYSUNINIT(imgact_binmisc, SI_SUB_EXEC, SI_ORDER_MIDDLE, imgact_binmisc_fini, 0); 753 754 /* 755 * Tell kern_execve.c about it, with a little help from the linker. 756 */ 757 static struct execsw imgact_binmisc_execsw = { imgact_binmisc_exec, KMOD_NAME }; 758 EXEC_SET(imgact_binmisc, imgact_binmisc_execsw); 759