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