1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /*
28 * Copyright (c) 2011 by Delphix. All rights reserved.
29 */
30
31 #include "lint.h"
32 #include "thr_uberdata.h"
33 #include <sys/libc_kernel.h>
34 #include <sys/procset.h>
35 #include <sys/fork.h>
36 #include <dirent.h>
37 #include <alloca.h>
38 #include <spawn.h>
39 #include <paths.h>
40
41 #define ALL_POSIX_SPAWN_FLAGS \
42 (POSIX_SPAWN_RESETIDS | \
43 POSIX_SPAWN_SETPGROUP | \
44 POSIX_SPAWN_SETSIGDEF | \
45 POSIX_SPAWN_SETSIGMASK | \
46 POSIX_SPAWN_SETSCHEDPARAM | \
47 POSIX_SPAWN_SETSCHEDULER | \
48 POSIX_SPAWN_SETSIGIGN_NP | \
49 POSIX_SPAWN_NOSIGCHLD_NP | \
50 POSIX_SPAWN_WAITPID_NP | \
51 POSIX_SPAWN_NOEXECERR_NP)
52
53 typedef struct {
54 int sa_psflags; /* POSIX_SPAWN_* flags */
55 int sa_priority;
56 int sa_schedpolicy;
57 pid_t sa_pgroup;
58 sigset_t sa_sigdefault;
59 sigset_t sa_sigignore;
60 sigset_t sa_sigmask;
61 } spawn_attr_t;
62
63 typedef struct file_attr {
64 struct file_attr *fa_next; /* circular list of file actions */
65 struct file_attr *fa_prev;
66 enum {FA_OPEN, FA_CLOSE, FA_DUP2, FA_CLOSEFROM} fa_type;
67 int fa_need_dirbuf; /* only consulted in the head action */
68 char *fa_path; /* copied pathname for open() */
69 uint_t fa_pathsize; /* size of fa_path[] array */
70 int fa_oflag; /* oflag for open() */
71 mode_t fa_mode; /* mode for open() */
72 int fa_filedes; /* file descriptor for open()/close() */
73 int fa_newfiledes; /* new file descriptor for dup2() */
74 } file_attr_t;
75
76 #if defined(_LP64)
77 #define __open64 __open
78 #define getdents64 getdents
79 #define dirent64_t dirent_t
80 #else
81 extern int getdents64(int, dirent64_t *, size_t);
82 #endif
83
84 extern const char **_environ;
85
86 /*
87 * Support function:
88 * Close all open file descriptors greater than or equal to lowfd.
89 * This is executed in the child of vfork(), so we must not call
90 * opendir() / readdir() because that would alter the parent's
91 * address space. We use the low-level getdents64() system call.
92 * Return non-zero on error.
93 */
94 static int
spawn_closefrom(int lowfd,void * buf)95 spawn_closefrom(int lowfd, void *buf)
96 {
97 int procfd;
98 int fd;
99 int buflen;
100 dirent64_t *dp;
101 dirent64_t *dpend;
102
103 if (lowfd < 0)
104 lowfd = 0;
105
106 /*
107 * Close lowfd right away as a hedge against failing
108 * to open the /proc file descriptor directory due
109 * all file descriptors being currently used up.
110 */
111 (void) __close(lowfd++);
112
113 if ((procfd = __open64("/proc/self/fd", O_RDONLY, 0)) < 0) {
114 /*
115 * We could not open the /proc file descriptor directory.
116 * Just fail and be done with it.
117 */
118 return (-1);
119 }
120
121 for (;;) {
122 /*
123 * Collect a bunch of open file descriptors and close them.
124 * Repeat until the directory is exhausted.
125 */
126 dp = (dirent64_t *)buf;
127 if ((buflen = getdents64(procfd, dp, DIRBUF)) <= 0) {
128 (void) __close(procfd);
129 break;
130 }
131 dpend = (dirent64_t *)((uintptr_t)buf + buflen);
132 do {
133 /* skip '.', '..' and procfd */
134 if (dp->d_name[0] != '.' &&
135 (fd = atoi(dp->d_name)) != procfd &&
136 fd >= lowfd)
137 (void) __close(fd);
138 dp = (dirent64_t *)((uintptr_t)dp + dp->d_reclen);
139 } while (dp < dpend);
140 }
141
142 return (0);
143 }
144
145 static int
perform_flag_actions(spawn_attr_t * sap)146 perform_flag_actions(spawn_attr_t *sap)
147 {
148 int sig;
149 struct sigaction action;
150
151 if (sap->sa_psflags & POSIX_SPAWN_SETSIGMASK) {
152 (void) __lwp_sigmask(SIG_SETMASK, &sap->sa_sigmask);
153 }
154
155 if (sap->sa_psflags & POSIX_SPAWN_SETSIGIGN_NP) {
156 (void) memset(&action, 0, sizeof (action));
157 action.sa_handler = SIG_IGN;
158 for (sig = 1; sig < NSIG; sig++) {
159 if (sigismember(&sap->sa_sigignore, sig))
160 (void) __sigaction(sig, &action, NULL);
161 }
162 }
163
164 if (sap->sa_psflags & POSIX_SPAWN_SETSIGDEF) {
165 (void) memset(&action, 0, sizeof (action));
166 action.sa_handler = SIG_DFL;
167 for (sig = 1; sig < NSIG; sig++) {
168 if (sigismember(&sap->sa_sigdefault, sig))
169 (void) __sigaction(sig, &action, NULL);
170 }
171 }
172
173 if (sap->sa_psflags & POSIX_SPAWN_RESETIDS) {
174 if (setgid(getgid()) != 0 || setuid(getuid()) != 0)
175 return (errno);
176 }
177
178 if (sap->sa_psflags & POSIX_SPAWN_SETPGROUP) {
179 if (setpgid(0, sap->sa_pgroup) != 0)
180 return (errno);
181 }
182
183 if (sap->sa_psflags & POSIX_SPAWN_SETSCHEDULER) {
184 if (setparam(P_LWPID, P_MYID,
185 sap->sa_schedpolicy, sap->sa_priority) == -1)
186 return (errno);
187 } else if (sap->sa_psflags & POSIX_SPAWN_SETSCHEDPARAM) {
188 if (setprio(P_LWPID, P_MYID, sap->sa_priority, NULL) == -1)
189 return (errno);
190 }
191
192 return (0);
193 }
194
195 static int
perform_file_actions(file_attr_t * fap,void * dirbuf)196 perform_file_actions(file_attr_t *fap, void *dirbuf)
197 {
198 file_attr_t *froot = fap;
199 int fd;
200
201 do {
202 switch (fap->fa_type) {
203 case FA_OPEN:
204 fd = __open(fap->fa_path, fap->fa_oflag, fap->fa_mode);
205 if (fd < 0)
206 return (errno);
207 if (fd != fap->fa_filedes) {
208 if (__fcntl(fd, F_DUP2FD, fap->fa_filedes) < 0)
209 return (errno);
210 (void) __close(fd);
211 }
212 break;
213 case FA_CLOSE:
214 if (__close(fap->fa_filedes) == -1 &&
215 errno != EBADF) /* already closed, no error */
216 return (errno);
217 break;
218 case FA_DUP2:
219 fd = __fcntl(fap->fa_filedes, F_DUP2FD,
220 fap->fa_newfiledes);
221 if (fd < 0)
222 return (errno);
223 break;
224 case FA_CLOSEFROM:
225 if (spawn_closefrom(fap->fa_filedes, dirbuf))
226 return (errno);
227 break;
228 }
229 } while ((fap = fap->fa_next) != froot);
230
231 return (0);
232 }
233
234 static int
forkflags(spawn_attr_t * sap)235 forkflags(spawn_attr_t *sap)
236 {
237 int flags = 0;
238
239 if (sap != NULL) {
240 if (sap->sa_psflags & POSIX_SPAWN_NOSIGCHLD_NP)
241 flags |= FORK_NOSIGCHLD;
242 if (sap->sa_psflags & POSIX_SPAWN_WAITPID_NP)
243 flags |= FORK_WAITPID;
244 }
245
246 return (flags);
247 }
248
249 /*
250 * set_error() / get_error() are used to guarantee that the local variable
251 * 'error' is set correctly in memory on return from vfork() in the parent.
252 */
253
254 static int
set_error(int * errp,int err)255 set_error(int *errp, int err)
256 {
257 return (*errp = err);
258 }
259
260 static int
get_error(int * errp)261 get_error(int *errp)
262 {
263 return (*errp);
264 }
265
266 /*
267 * For MT safety, do not invoke the dynamic linker after calling vfork().
268 * If some other thread was in the dynamic linker when this thread's parent
269 * called vfork() then the dynamic linker's lock would still be held here
270 * (with a defunct owner) and we would deadlock ourself if we invoked it.
271 *
272 * Therefore, all of the functions we call here after returning from
273 * vforkx() in the child are not and must never be exported from libc
274 * as global symbols. To do so would risk invoking the dynamic linker.
275 */
276
277 int
posix_spawn(pid_t * pidp,const char * path,const posix_spawn_file_actions_t * file_actions,const posix_spawnattr_t * attrp,char * const * argv,char * const * envp)278 posix_spawn(
279 pid_t *pidp,
280 const char *path,
281 const posix_spawn_file_actions_t *file_actions,
282 const posix_spawnattr_t *attrp,
283 char *const *argv,
284 char *const *envp)
285 {
286 spawn_attr_t *sap = attrp? attrp->__spawn_attrp : NULL;
287 file_attr_t *fap = file_actions? file_actions->__file_attrp : NULL;
288 void *dirbuf = NULL;
289 int error; /* this will be set by the child */
290 pid_t pid;
291
292 if (attrp != NULL && sap == NULL)
293 return (EINVAL);
294
295 if (fap != NULL && fap->fa_need_dirbuf) {
296 /*
297 * Preallocate the buffer for the call to getdents64() in
298 * spawn_closefrom() since we can't do it in the vfork() child.
299 */
300 if ((dirbuf = lmalloc(DIRBUF)) == NULL)
301 return (ENOMEM);
302 }
303
304 switch (pid = vforkx(forkflags(sap))) {
305 case 0: /* child */
306 break;
307 case -1: /* parent, failure */
308 if (dirbuf)
309 lfree(dirbuf, DIRBUF);
310 return (errno);
311 default: /* parent, success */
312 /*
313 * We don't get here until the child exec()s or exit()s
314 */
315 if (pidp != NULL && get_error(&error) == 0)
316 *pidp = pid;
317 if (dirbuf)
318 lfree(dirbuf, DIRBUF);
319 return (get_error(&error));
320 }
321
322 if (sap != NULL)
323 if (set_error(&error, perform_flag_actions(sap)) != 0)
324 _exit(_EVAPORATE);
325
326 if (fap != NULL)
327 if (set_error(&error, perform_file_actions(fap, dirbuf)) != 0)
328 _exit(_EVAPORATE);
329
330 (void) set_error(&error, 0);
331 (void) execve(path, argv, envp);
332 if (sap != NULL && (sap->sa_psflags & POSIX_SPAWN_NOEXECERR_NP))
333 _exit(127);
334 (void) set_error(&error, errno);
335 _exit(_EVAPORATE);
336 return (0); /* not reached */
337 }
338
339 /*
340 * Much of posix_spawnp() blatently stolen from execvp() (port/gen/execvp.c).
341 */
342
343 extern int libc__xpg4;
344
345 static const char *
execat(const char * s1,const char * s2,char * si)346 execat(const char *s1, const char *s2, char *si)
347 {
348 int cnt = PATH_MAX + 1;
349 char *s;
350 char c;
351
352 for (s = si; (c = *s1) != '\0' && c != ':'; s1++) {
353 if (cnt > 0) {
354 *s++ = c;
355 cnt--;
356 }
357 }
358 if (si != s && cnt > 0) {
359 *s++ = '/';
360 cnt--;
361 }
362 for (; (c = *s2) != '\0' && cnt > 0; s2++) {
363 *s++ = c;
364 cnt--;
365 }
366 *s = '\0';
367 return (*s1? ++s1: NULL);
368 }
369
370 /* ARGSUSED */
371 int
posix_spawnp(pid_t * pidp,const char * file,const posix_spawn_file_actions_t * file_actions,const posix_spawnattr_t * attrp,char * const * argv,char * const * envp)372 posix_spawnp(
373 pid_t *pidp,
374 const char *file,
375 const posix_spawn_file_actions_t *file_actions,
376 const posix_spawnattr_t *attrp,
377 char *const *argv,
378 char *const *envp)
379 {
380 spawn_attr_t *sap = attrp? attrp->__spawn_attrp : NULL;
381 file_attr_t *fap = file_actions? file_actions->__file_attrp : NULL;
382 void *dirbuf = NULL;
383 const char *pathstr = (strchr(file, '/') == NULL)? getenv("PATH") : "";
384 int xpg4 = libc__xpg4;
385 int error = 0; /* this will be set by the child */
386 char path[PATH_MAX+4];
387 const char *cp;
388 pid_t pid;
389 char **newargs;
390 int argc;
391 int i;
392
393 if (attrp != NULL && sap == NULL)
394 return (EINVAL);
395
396 if (*file == '\0')
397 return (EACCES);
398
399 if (fap != NULL && fap->fa_need_dirbuf) {
400 /*
401 * Preallocate the buffer for the call to getdents64() in
402 * spawn_closefrom() since we can't do it in the vfork() child.
403 */
404 if ((dirbuf = lmalloc(DIRBUF)) == NULL)
405 return (ENOMEM);
406 }
407
408 /*
409 * We may need to invoke the shell with a slightly modified
410 * argv[] array. To do this we need to preallocate the array.
411 * We must call alloca() before calling vfork() because doing
412 * it after vfork() (in the child) would corrupt the parent.
413 */
414 for (argc = 0; argv[argc] != NULL; argc++)
415 continue;
416 newargs = alloca((argc + 2) * sizeof (char *));
417
418 switch (pid = vforkx(forkflags(sap))) {
419 case 0: /* child */
420 break;
421 case -1: /* parent, failure */
422 if (dirbuf)
423 lfree(dirbuf, DIRBUF);
424 return (errno);
425 default: /* parent, success */
426 /*
427 * We don't get here until the child exec()s or exit()s
428 */
429 if (pidp != NULL && get_error(&error) == 0)
430 *pidp = pid;
431 if (dirbuf)
432 lfree(dirbuf, DIRBUF);
433 return (get_error(&error));
434 }
435
436 if (sap != NULL)
437 if (set_error(&error, perform_flag_actions(sap)) != 0)
438 _exit(_EVAPORATE);
439
440 if (fap != NULL)
441 if (set_error(&error, perform_file_actions(fap, dirbuf)) != 0)
442 _exit(_EVAPORATE);
443
444 if (pathstr == NULL) {
445 /*
446 * XPG4: pathstr is equivalent to _CS_PATH, except that
447 * :/usr/sbin is appended when root, and pathstr must end
448 * with a colon when not root. Keep these paths in sync
449 * with _CS_PATH in confstr.c. Note that pathstr must end
450 * with a colon when not root so that when file doesn't
451 * contain '/', the last call to execat() will result in an
452 * attempt to execv file from the current directory.
453 */
454 if (geteuid() == 0 || getuid() == 0) {
455 if (!xpg4)
456 pathstr = "/usr/sbin:/usr/ccs/bin:/usr/bin";
457 else
458 pathstr = "/usr/xpg4/bin:/usr/ccs/bin:"
459 "/usr/bin:/opt/SUNWspro/bin:/usr/sbin";
460 } else {
461 if (!xpg4)
462 pathstr = "/usr/ccs/bin:/usr/bin:";
463 else
464 pathstr = "/usr/xpg4/bin:/usr/ccs/bin:"
465 "/usr/bin:/opt/SUNWspro/bin:";
466 }
467 }
468
469 cp = pathstr;
470 do {
471 cp = execat(cp, file, path);
472 /*
473 * 4025035 and 4038378
474 * if a filename begins with a "-" prepend "./" so that
475 * the shell can't interpret it as an option
476 */
477 if (*path == '-') {
478 char *s;
479
480 for (s = path; *s != '\0'; s++)
481 continue;
482 for (; s >= path; s--)
483 *(s + 2) = *s;
484 path[0] = '.';
485 path[1] = '/';
486 }
487 (void) set_error(&error, 0);
488 (void) execve(path, argv, envp);
489 if (set_error(&error, errno) == ENOEXEC) {
490 newargs[0] = "sh";
491 newargs[1] = path;
492 for (i = 1; i <= argc; i++)
493 newargs[i + 1] = argv[i];
494 (void) set_error(&error, 0);
495 (void) execve(_PATH_BSHELL, newargs, envp);
496 if (sap != NULL &&
497 (sap->sa_psflags & POSIX_SPAWN_NOEXECERR_NP))
498 _exit(127);
499 (void) set_error(&error, errno);
500 _exit(_EVAPORATE);
501 }
502 } while (cp);
503
504 if (sap != NULL &&
505 (sap->sa_psflags & POSIX_SPAWN_NOEXECERR_NP)) {
506 (void) set_error(&error, 0);
507 _exit(127);
508 }
509 _exit(_EVAPORATE);
510 return (0); /* not reached */
511 }
512
513 int
posix_spawn_file_actions_init(posix_spawn_file_actions_t * file_actions)514 posix_spawn_file_actions_init(
515 posix_spawn_file_actions_t *file_actions)
516 {
517 file_actions->__file_attrp = NULL;
518 return (0);
519 }
520
521 int
posix_spawn_file_actions_destroy(posix_spawn_file_actions_t * file_actions)522 posix_spawn_file_actions_destroy(
523 posix_spawn_file_actions_t *file_actions)
524 {
525 file_attr_t *froot = file_actions->__file_attrp;
526 file_attr_t *fap;
527 file_attr_t *next;
528
529 if ((fap = froot) != NULL) {
530 do {
531 next = fap->fa_next;
532 if (fap->fa_type == FA_OPEN)
533 lfree(fap->fa_path, fap->fa_pathsize);
534 lfree(fap, sizeof (*fap));
535 } while ((fap = next) != froot);
536 }
537 file_actions->__file_attrp = NULL;
538 return (0);
539 }
540
541 static void
add_file_attr(posix_spawn_file_actions_t * file_actions,file_attr_t * fap)542 add_file_attr(posix_spawn_file_actions_t *file_actions, file_attr_t *fap)
543 {
544 file_attr_t *froot = file_actions->__file_attrp;
545
546 if (froot == NULL) {
547 fap->fa_next = fap->fa_prev = fap;
548 file_actions->__file_attrp = froot = fap;
549 } else {
550 fap->fa_next = froot;
551 fap->fa_prev = froot->fa_prev;
552 froot->fa_prev->fa_next = fap;
553 froot->fa_prev = fap;
554 }
555
556 /*
557 * Once set, __file_attrp no longer changes, so this assignment
558 * always goes into the first element in the list, as required.
559 */
560 if (fap->fa_type == FA_CLOSEFROM)
561 froot->fa_need_dirbuf = 1;
562 }
563
564 int
posix_spawn_file_actions_addopen(posix_spawn_file_actions_t * file_actions,int filedes,const char * path,int oflag,mode_t mode)565 posix_spawn_file_actions_addopen(
566 posix_spawn_file_actions_t *file_actions,
567 int filedes,
568 const char *path,
569 int oflag,
570 mode_t mode)
571 {
572 file_attr_t *fap;
573
574 if (filedes < 0)
575 return (EBADF);
576 if ((fap = lmalloc(sizeof (*fap))) == NULL)
577 return (ENOMEM);
578
579 fap->fa_pathsize = strlen(path) + 1;
580 if ((fap->fa_path = lmalloc(fap->fa_pathsize)) == NULL) {
581 lfree(fap, sizeof (*fap));
582 return (ENOMEM);
583 }
584 (void) strcpy(fap->fa_path, path);
585
586 fap->fa_type = FA_OPEN;
587 fap->fa_oflag = oflag;
588 fap->fa_mode = mode;
589 fap->fa_filedes = filedes;
590 add_file_attr(file_actions, fap);
591
592 return (0);
593 }
594
595 int
posix_spawn_file_actions_addclose(posix_spawn_file_actions_t * file_actions,int filedes)596 posix_spawn_file_actions_addclose(
597 posix_spawn_file_actions_t *file_actions,
598 int filedes)
599 {
600 file_attr_t *fap;
601
602 if (filedes < 0)
603 return (EBADF);
604 if ((fap = lmalloc(sizeof (*fap))) == NULL)
605 return (ENOMEM);
606
607 fap->fa_type = FA_CLOSE;
608 fap->fa_filedes = filedes;
609 add_file_attr(file_actions, fap);
610
611 return (0);
612 }
613
614 int
posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t * file_actions,int filedes,int newfiledes)615 posix_spawn_file_actions_adddup2(
616 posix_spawn_file_actions_t *file_actions,
617 int filedes,
618 int newfiledes)
619 {
620 file_attr_t *fap;
621
622 if (filedes < 0 || newfiledes < 0)
623 return (EBADF);
624 if ((fap = lmalloc(sizeof (*fap))) == NULL)
625 return (ENOMEM);
626
627 fap->fa_type = FA_DUP2;
628 fap->fa_filedes = filedes;
629 fap->fa_newfiledes = newfiledes;
630 add_file_attr(file_actions, fap);
631
632 return (0);
633 }
634
635 int
posix_spawn_file_actions_addclosefrom_np(posix_spawn_file_actions_t * file_actions,int lowfiledes)636 posix_spawn_file_actions_addclosefrom_np(
637 posix_spawn_file_actions_t *file_actions,
638 int lowfiledes)
639 {
640 file_attr_t *fap;
641
642 if (lowfiledes < 0)
643 return (EBADF);
644 if ((fap = lmalloc(sizeof (*fap))) == NULL)
645 return (ENOMEM);
646 fap->fa_type = FA_CLOSEFROM;
647 fap->fa_filedes = lowfiledes;
648 add_file_attr(file_actions, fap);
649
650 return (0);
651 }
652
653 int
posix_spawnattr_init(posix_spawnattr_t * attr)654 posix_spawnattr_init(
655 posix_spawnattr_t *attr)
656 {
657 if ((attr->__spawn_attrp = lmalloc(sizeof (posix_spawnattr_t))) == NULL)
658 return (ENOMEM);
659 /*
660 * Add default stuff here?
661 */
662 return (0);
663 }
664
665 int
posix_spawnattr_destroy(posix_spawnattr_t * attr)666 posix_spawnattr_destroy(
667 posix_spawnattr_t *attr)
668 {
669 spawn_attr_t *sap = attr->__spawn_attrp;
670
671 if (sap == NULL)
672 return (EINVAL);
673
674 /*
675 * deallocate stuff here?
676 */
677 lfree(sap, sizeof (*sap));
678 attr->__spawn_attrp = NULL;
679 return (0);
680 }
681
682 int
posix_spawnattr_setflags(posix_spawnattr_t * attr,short flags)683 posix_spawnattr_setflags(
684 posix_spawnattr_t *attr,
685 short flags)
686 {
687 spawn_attr_t *sap = attr->__spawn_attrp;
688
689 if (sap == NULL ||
690 (flags & ~ALL_POSIX_SPAWN_FLAGS))
691 return (EINVAL);
692
693 sap->sa_psflags = flags;
694 return (0);
695 }
696
697 int
posix_spawnattr_getflags(const posix_spawnattr_t * attr,short * flags)698 posix_spawnattr_getflags(
699 const posix_spawnattr_t *attr,
700 short *flags)
701 {
702 spawn_attr_t *sap = attr->__spawn_attrp;
703
704 if (sap == NULL)
705 return (EINVAL);
706
707 *flags = sap->sa_psflags;
708 return (0);
709 }
710
711 int
posix_spawnattr_setpgroup(posix_spawnattr_t * attr,pid_t pgroup)712 posix_spawnattr_setpgroup(
713 posix_spawnattr_t *attr,
714 pid_t pgroup)
715 {
716 spawn_attr_t *sap = attr->__spawn_attrp;
717
718 if (sap == NULL)
719 return (EINVAL);
720
721 sap->sa_pgroup = pgroup;
722 return (0);
723 }
724
725 int
posix_spawnattr_getpgroup(const posix_spawnattr_t * attr,pid_t * pgroup)726 posix_spawnattr_getpgroup(
727 const posix_spawnattr_t *attr,
728 pid_t *pgroup)
729 {
730 spawn_attr_t *sap = attr->__spawn_attrp;
731
732 if (sap == NULL)
733 return (EINVAL);
734
735 *pgroup = sap->sa_pgroup;
736 return (0);
737 }
738
739 int
posix_spawnattr_setschedparam(posix_spawnattr_t * attr,const struct sched_param * schedparam)740 posix_spawnattr_setschedparam(
741 posix_spawnattr_t *attr,
742 const struct sched_param *schedparam)
743 {
744 spawn_attr_t *sap = attr->__spawn_attrp;
745
746 if (sap == NULL)
747 return (EINVAL);
748
749 /*
750 * Check validity?
751 */
752 sap->sa_priority = schedparam->sched_priority;
753 return (0);
754 }
755
756 int
posix_spawnattr_getschedparam(const posix_spawnattr_t * attr,struct sched_param * schedparam)757 posix_spawnattr_getschedparam(
758 const posix_spawnattr_t *attr,
759 struct sched_param *schedparam)
760 {
761 spawn_attr_t *sap = attr->__spawn_attrp;
762
763 if (sap == NULL)
764 return (EINVAL);
765
766 schedparam->sched_priority = sap->sa_priority;
767 return (0);
768 }
769
770 int
posix_spawnattr_setschedpolicy(posix_spawnattr_t * attr,int schedpolicy)771 posix_spawnattr_setschedpolicy(
772 posix_spawnattr_t *attr,
773 int schedpolicy)
774 {
775 spawn_attr_t *sap = attr->__spawn_attrp;
776
777 if (sap == NULL || schedpolicy == SCHED_SYS)
778 return (EINVAL);
779
780 /*
781 * Cache the policy information for later use
782 * by the vfork() child of posix_spawn().
783 */
784 if (get_info_by_policy(schedpolicy) == NULL)
785 return (errno);
786
787 sap->sa_schedpolicy = schedpolicy;
788 return (0);
789 }
790
791 int
posix_spawnattr_getschedpolicy(const posix_spawnattr_t * attr,int * schedpolicy)792 posix_spawnattr_getschedpolicy(
793 const posix_spawnattr_t *attr,
794 int *schedpolicy)
795 {
796 spawn_attr_t *sap = attr->__spawn_attrp;
797
798 if (sap == NULL)
799 return (EINVAL);
800
801 *schedpolicy = sap->sa_schedpolicy;
802 return (0);
803 }
804
805 int
posix_spawnattr_setsigdefault(posix_spawnattr_t * attr,const sigset_t * sigdefault)806 posix_spawnattr_setsigdefault(
807 posix_spawnattr_t *attr,
808 const sigset_t *sigdefault)
809 {
810 spawn_attr_t *sap = attr->__spawn_attrp;
811
812 if (sap == NULL)
813 return (EINVAL);
814
815 sap->sa_sigdefault = *sigdefault;
816 return (0);
817 }
818
819 int
posix_spawnattr_getsigdefault(const posix_spawnattr_t * attr,sigset_t * sigdefault)820 posix_spawnattr_getsigdefault(
821 const posix_spawnattr_t *attr,
822 sigset_t *sigdefault)
823 {
824 spawn_attr_t *sap = attr->__spawn_attrp;
825
826 if (sap == NULL)
827 return (EINVAL);
828
829 *sigdefault = sap->sa_sigdefault;
830 return (0);
831 }
832
833 int
posix_spawnattr_setsigignore_np(posix_spawnattr_t * attr,const sigset_t * sigignore)834 posix_spawnattr_setsigignore_np(
835 posix_spawnattr_t *attr,
836 const sigset_t *sigignore)
837 {
838 spawn_attr_t *sap = attr->__spawn_attrp;
839
840 if (sap == NULL)
841 return (EINVAL);
842
843 sap->sa_sigignore = *sigignore;
844 return (0);
845 }
846
847 int
posix_spawnattr_getsigignore_np(const posix_spawnattr_t * attr,sigset_t * sigignore)848 posix_spawnattr_getsigignore_np(
849 const posix_spawnattr_t *attr,
850 sigset_t *sigignore)
851 {
852 spawn_attr_t *sap = attr->__spawn_attrp;
853
854 if (sap == NULL)
855 return (EINVAL);
856
857 *sigignore = sap->sa_sigignore;
858 return (0);
859 }
860
861 int
posix_spawnattr_setsigmask(posix_spawnattr_t * attr,const sigset_t * sigmask)862 posix_spawnattr_setsigmask(
863 posix_spawnattr_t *attr,
864 const sigset_t *sigmask)
865 {
866 spawn_attr_t *sap = attr->__spawn_attrp;
867
868 if (sap == NULL)
869 return (EINVAL);
870
871 sap->sa_sigmask = *sigmask;
872 return (0);
873 }
874
875 int
posix_spawnattr_getsigmask(const posix_spawnattr_t * attr,sigset_t * sigmask)876 posix_spawnattr_getsigmask(
877 const posix_spawnattr_t *attr,
878 sigset_t *sigmask)
879 {
880 spawn_attr_t *sap = attr->__spawn_attrp;
881
882 if (sap == NULL)
883 return (EINVAL);
884
885 *sigmask = sap->sa_sigmask;
886 return (0);
887 }
888
889 /*
890 * Spawn a process to run "sh -c <cmd>". Return the child's pid (in
891 * *pidp), and a file descriptor (in *fdp) for reading or writing to the
892 * child process, depending on the 'write' argument.
893 * Return 0 on success; otherwise return an error code.
894 */
895 int
posix_spawn_pipe_np(pid_t * pidp,int * fdp,const char * cmd,boolean_t write,posix_spawn_file_actions_t * fact,posix_spawnattr_t * attr)896 posix_spawn_pipe_np(pid_t *pidp, int *fdp,
897 const char *cmd, boolean_t write,
898 posix_spawn_file_actions_t *fact, posix_spawnattr_t *attr)
899 {
900 int p[2];
901 int myside, yourside, stdio;
902 const char *shpath = _PATH_BSHELL;
903 const char *argvec[4] = { "sh", "-c", cmd, NULL };
904 int error;
905
906 if (pipe(p) < 0)
907 return (errno);
908
909 if (access(shpath, X_OK)) /* XPG4 Requirement: */
910 shpath = ""; /* force child to fail immediately */
911
912 if (write) {
913 /*
914 * Data is read from p[0] and written to p[1].
915 * 'stdio' is the fd in the child process that should be
916 * connected to the pipe.
917 */
918 myside = p[1];
919 yourside = p[0];
920 stdio = STDIN_FILENO;
921 } else {
922 myside = p[0];
923 yourside = p[1];
924 stdio = STDOUT_FILENO;
925 }
926
927 error = posix_spawn_file_actions_addclose(fact, myside);
928 if (yourside != stdio) {
929 if (error == 0) {
930 error = posix_spawn_file_actions_adddup2(fact,
931 yourside, stdio);
932 }
933 if (error == 0) {
934 error = posix_spawn_file_actions_addclose(fact,
935 yourside);
936 }
937 }
938
939 if (error)
940 return (error);
941 error = posix_spawn(pidp, shpath, fact, attr,
942 (char *const *)argvec, (char *const *)_environ);
943 (void) close(yourside);
944 if (error) {
945 (void) close(myside);
946 return (error);
947 }
948
949 *fdp = myside;
950 return (0);
951 }
952