Termux
/
termux-packages
mirror of https://github.com/termux/termux-packages
1
0
Fork 0
Code Issues Releases Wiki Activity

libandroid-spawn: switch to modified upstream implementation and use it for ninja

This commit is contained in:
Butta 2019-08-30 00:01:44 +05:30 committed by Fredrik Fornwall
parent 814ee28661
commit 0043f4fcf4
9 changed files with 465 additions and 705 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
packages/libandroid-spawn/build.sh
View File

@ -1,12 +1,12 @@
TERMUX_PKG_HOMEPAGE=http://man7.org/linux/man-pages/man3/posix_spawn.3.html
TERMUX_PKG_DESCRIPTION="Shared library for the posix_spawn system function"
TERMUX_PKG_LICENSE="BSD 3-Clause"
TERMUX_PKG_VERSION=0.1
TERMUX_PKG_LICENSE="BSD 2-Clause"
TERMUX_PKG_VERSION=0.2
TERMUX_PKG_SKIP_SRC_EXTRACT=true
TERMUX_PKG_BUILD_IN_SRC=true
termux_step_make() {
$CC $CFLAGS $CPPFLAGS -I$TERMUX_PKG_BUILDER_DIR -c $TERMUX_PKG_BUILDER_DIR/posix_spawn.c
$CC $CFLAGS $CPPFLAGS -I$TERMUX_PKG_BUILDER_DIR -c $TERMUX_PKG_BUILDER_DIR/posix_spawn.cpp
$CC $LDFLAGS -shared posix_spawn.o -o libandroid-spawn.so
$AR rcu libandroid-spawn.a posix_spawn.o
}

156
packages/libandroid-spawn/posix_spawn.c
View File

@ -1,156 +0,0 @@
/*
* dhcpcd - DHCP client daemon
* Copyright (c) 2006-2012 Roy Marples <roy@marples.name>
* All rights reserved
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/* This implementation of posix_spawn is only suitable for the needs of dhcpcd
* but it could easily be extended to other applications. */
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "posix_spawn.h"
#ifndef _NSIG
#ifdef _SIG_MAXSIG
#define _NSIG _SIG_MAXSIG + 1
#else
/* Guess */
#define _NSIG SIGPWR + 1
#endif
#endif
extern char **environ;
static int
posix_spawnattr_handle(const posix_spawnattr_t *attrp)
{
struct sigaction sa;
int i;
if (attrp->posix_attr_flags & POSIX_SPAWN_SETSIGMASK)
sigprocmask(SIG_SETMASK, &attrp->posix_attr_sigmask, NULL);
if (attrp->posix_attr_flags & POSIX_SPAWN_SETSIGDEF) {
memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_DFL;
for (i = 1; i < _NSIG; i++) {
if (sigismember(&attrp->posix_attr_sigdefault, i)) {
if (sigaction(i, &sa, NULL) == -1)
return -1;
}
}
}
return 0;
}
inline static int
is_vfork_safe(short int flags)
{
return !(flags & (POSIX_SPAWN_SETSIGDEF | POSIX_SPAWN_SETSIGMASK));
}
int
posix_spawn(pid_t *pid, const char *path,
const posix_spawn_file_actions_t *file_actions,
const posix_spawnattr_t *attrp,
char *const argv[], char *const envp[])
{
short int flags;
pid_t p;
volatile int error;
error = 0;
flags = attrp ? attrp->posix_attr_flags : 0;
if (file_actions == NULL && is_vfork_safe(flags))
p = vfork();
else
#ifdef THERE_IS_NO_FORK
return ENOSYS;
#else
p = fork();
#endif
switch (p) {
case -1:
return errno;
case 0:
if (attrp) {
error = posix_spawnattr_handle(attrp);
if (error)
_exit(127);
}
execve(path, argv, envp);
error = errno;
_exit(127);
default:
if (error != 0)
waitpid(p, NULL, WNOHANG);
else if (pid != NULL)
*pid = p;
return error;
}
}
int
posix_spawnattr_init(posix_spawnattr_t *attr)
{
memset(attr, 0, sizeof(*attr));
attr->posix_attr_flags = 0;
sigprocmask(0, NULL, &attr->posix_attr_sigmask);
sigemptyset(&attr->posix_attr_sigdefault);
return 0;
}
int
posix_spawnattr_setflags(posix_spawnattr_t *attr, short flags)
{
attr->posix_attr_flags = flags;
return 0;
}
int
posix_spawnattr_setsigmask(posix_spawnattr_t *attr, const sigset_t *sigmask)
{
attr->posix_attr_sigmask = *sigmask;
return 0;
}
int
posix_spawnattr_setsigdefault(posix_spawnattr_t *attr, const sigset_t *sigmask)
{
attr->posix_attr_sigdefault = *sigmask;
return 0;
}

381
packages/libandroid-spawn/posix_spawn.cpp Normal file
View File

@ -0,0 +1,381 @@
/*
* Copyright (C) 2017 The Android Open Source Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <android/fdsan.h>
#include "posix_spawn.h"
// Bionic "private/ScopedSignalBlocker.h" + one macro needed
#define BIONIC_DISALLOW_COPY_AND_ASSIGN(TypeName) \
TypeName(const TypeName&) = delete; \
void operator=(const TypeName&) = delete
class ScopedSignalBlocker {
public:
// Block all signals.
explicit ScopedSignalBlocker() {
sigset_t set;
sigfillset(&set);
sigprocmask(SIG_BLOCK, &set, &old_set_);
}
// Block just the specified signal.
explicit ScopedSignalBlocker(int signal) {
sigset_t set = {};
sigaddset(&set, signal);
sigprocmask(SIG_BLOCK, &set, &old_set_);
}
~ScopedSignalBlocker() {
reset();
}
void reset() {
sigprocmask(SIG_SETMASK, &old_set_, nullptr);
}
sigset_t old_set_;
BIONIC_DISALLOW_COPY_AND_ASSIGN(ScopedSignalBlocker);
};
// Bionic "private/SigSetConverter.h"
union SigSetConverter {
int bsd;
sigset_t sigset;
sigset64_t sigset64;
};
enum Action {
kOpen,
kClose,
kDup2
};
struct __posix_spawn_file_action {
__posix_spawn_file_action* next;
Action what;
int fd;
int new_fd;
char* path;
int flags;
mode_t mode;
void Do() {
if (what == kOpen) {
fd = open(path, flags, mode);
if (fd == -1) _exit(127);
// If it didn't land where we wanted it, move it.
if (fd != new_fd) {
if (dup2(fd, new_fd) == -1) _exit(127);
close(fd);
}
} else if (what == kClose) {
// Failure to close is ignored.
close(fd);
} else {
if (dup2(fd, new_fd) == -1) _exit(127);
}
}
};
struct __posix_spawn_file_actions {
__posix_spawn_file_action* head;
__posix_spawn_file_action* last;
void Do() {
for (__posix_spawn_file_action* action = head; action != nullptr; action = action->next) {
action->Do();
}
}
};
struct __posix_spawnattr {
short flags;
pid_t pgroup;
sched_param schedparam;
int schedpolicy;
SigSetConverter sigmask;
SigSetConverter sigdefault;
};
static void ApplyAttrs(short flags, const posix_spawnattr_t* attr) {
// POSIX: "If POSIX_SPAWN_SETSIGDEF is set ... signals in sigdefault ...
// shall be set to their default actions in the child process."
// POSIX: "Signals set to be caught by the calling process shall be
// set to the default action in the child process."
bool use_sigdefault = ((flags & POSIX_SPAWN_SETSIGDEF) != 0);
const struct sigaction default_sa = { .sa_handler = SIG_DFL };
for (int s = 1; s < _NSIG; ++s) {
bool reset = false;
if (use_sigdefault && sigismember(&(*attr)->sigdefault.sigset, s)) {
reset = true;
} else {
struct sigaction current;
if (sigaction(s, nullptr, &current) == -1) _exit(127);
reset = (current.sa_handler != SIG_IGN && current.sa_handler != SIG_DFL);
}
if (reset && sigaction(s, &default_sa, nullptr) == -1) _exit(127);
}
if ((flags & POSIX_SPAWN_SETPGROUP) != 0 && setpgid(0, (*attr)->pgroup) == -1) _exit(127);
if ((flags & POSIX_SPAWN_SETSID) != 0 && setsid() == -1) _exit(127);
// POSIX_SPAWN_SETSCHEDULER overrides POSIX_SPAWN_SETSCHEDPARAM, but it is not an error
// to set both.
if ((flags & POSIX_SPAWN_SETSCHEDULER) != 0) {
if (sched_setscheduler(0, (*attr)->schedpolicy, &(*attr)->schedparam) == -1) _exit(127);
} else if ((flags & POSIX_SPAWN_SETSCHEDPARAM) != 0) {
if (sched_setparam(0, &(*attr)->schedparam) == -1) _exit(127);
}
if ((flags & POSIX_SPAWN_RESETIDS) != 0) {
if (seteuid(getuid()) == -1 || setegid(getgid()) == -1) _exit(127);
}
if ((flags & POSIX_SPAWN_SETSIGMASK) != 0) {
if (sigprocmask(SIG_SETMASK, &(*attr)->sigmask.sigset, nullptr)) _exit(127);
}
}
static int posix_spawn(pid_t* pid_ptr,
const char* path,
const posix_spawn_file_actions_t* actions,
const posix_spawnattr_t* attr,
char* const argv[],
char* const env[],
int exec_fn(const char* path, char* const argv[], char* const env[])) {
// See http://man7.org/linux/man-pages/man3/posix_spawn.3.html
// and http://pubs.opengroup.org/onlinepubs/9699919799/functions/posix_spawn.html
ScopedSignalBlocker ssb;
short flags = attr ? (*attr)->flags : 0;
bool use_vfork = ((flags & POSIX_SPAWN_USEVFORK) != 0) || (actions == nullptr && flags == 0);
pid_t pid = use_vfork ? vfork() : fork();
if (pid == -1) return errno;
if (pid == 0) {
// Child.
ApplyAttrs(flags, attr);
if (actions) (*actions)->Do();
if ((flags & POSIX_SPAWN_SETSIGMASK) == 0) ssb.reset();
exec_fn(path, argv, env ? env : environ);
_exit(127);
}
// Parent.
if (pid_ptr) *pid_ptr = pid;
return 0;
}
int posix_spawn(pid_t* pid, const char* path, const posix_spawn_file_actions_t* actions,
const posix_spawnattr_t* attr, char* const argv[], char* const env[]) {
return posix_spawn(pid, path, actions, attr, argv, env, execve);
}
int posix_spawnp(pid_t* pid, const char* file, const posix_spawn_file_actions_t* actions,
const posix_spawnattr_t* attr, char* const argv[], char* const env[]) {
return posix_spawn(pid, file, actions, attr, argv, env, execvpe);
}
int posix_spawnattr_init(posix_spawnattr_t* attr) {
*attr = reinterpret_cast<__posix_spawnattr*>(calloc(1, sizeof(__posix_spawnattr)));
return (*attr == nullptr) ? errno : 0;
}
int posix_spawnattr_destroy(posix_spawnattr_t* attr) {
free(*attr);
*attr = nullptr;
return 0;
}
int posix_spawnattr_setflags(posix_spawnattr_t* attr, short flags) {
if ((flags & ~(POSIX_SPAWN_RESETIDS | POSIX_SPAWN_SETPGROUP | POSIX_SPAWN_SETSIGDEF |
POSIX_SPAWN_SETSIGMASK | POSIX_SPAWN_SETSCHEDPARAM | POSIX_SPAWN_SETSCHEDULER |
POSIX_SPAWN_USEVFORK | POSIX_SPAWN_SETSID)) != 0) {
return EINVAL;
}
(*attr)->flags = flags;
return 0;
}
int posix_spawnattr_getflags(const posix_spawnattr_t* attr, short* flags) {
*flags = (*attr)->flags;
return 0;
}
int posix_spawnattr_setpgroup(posix_spawnattr_t* attr, pid_t pgroup) {
(*attr)->pgroup = pgroup;
return 0;
}
int posix_spawnattr_getpgroup(const posix_spawnattr_t* attr, pid_t* pgroup) {
*pgroup = (*attr)->pgroup;
return 0;
}
int posix_spawnattr_setsigmask(posix_spawnattr_t* attr, const sigset_t* mask) {
(*attr)->sigmask.sigset = *mask;
return 0;
}
int posix_spawnattr_setsigmask64(posix_spawnattr_t* attr, const sigset64_t* mask) {
(*attr)->sigmask.sigset64 = *mask;
return 0;
}
int posix_spawnattr_getsigmask(const posix_spawnattr_t* attr, sigset_t* mask) {
*mask = (*attr)->sigmask.sigset;
return 0;
}
int posix_spawnattr_getsigmask64(const posix_spawnattr_t* attr, sigset64_t* mask) {
*mask = (*attr)->sigmask.sigset64;
return 0;
}
int posix_spawnattr_setsigdefault(posix_spawnattr_t* attr, const sigset_t* mask) {
(*attr)->sigdefault.sigset = *mask;
return 0;
}
int posix_spawnattr_setsigdefault64(posix_spawnattr_t* attr, const sigset64_t* mask) {
(*attr)->sigdefault.sigset64 = *mask;
return 0;
}
int posix_spawnattr_getsigdefault(const posix_spawnattr_t* attr, sigset_t* mask) {
*mask = (*attr)->sigdefault.sigset;
return 0;
}
int posix_spawnattr_getsigdefault64(const posix_spawnattr_t* attr, sigset64_t* mask) {
*mask = (*attr)->sigdefault.sigset64;
return 0;
}
int posix_spawnattr_setschedparam(posix_spawnattr_t* attr, const struct sched_param* param) {
(*attr)->schedparam = *param;
return 0;
}
int posix_spawnattr_getschedparam(const posix_spawnattr_t* attr, struct sched_param* param) {
*param = (*attr)->schedparam;
return 0;
}
int posix_spawnattr_setschedpolicy(posix_spawnattr_t* attr, int policy) {
(*attr)->schedpolicy = policy;
return 0;
}
int posix_spawnattr_getschedpolicy(const posix_spawnattr_t* attr, int* policy) {
*policy = (*attr)->schedpolicy;
return 0;
}
int posix_spawn_file_actions_init(posix_spawn_file_actions_t* actions) {
*actions = reinterpret_cast<__posix_spawn_file_actions*>(calloc(1, sizeof(**actions)));
return (*actions == nullptr) ? errno : 0;
}
int posix_spawn_file_actions_destroy(posix_spawn_file_actions_t* actions) {
__posix_spawn_file_action* a = (*actions)->head;
while (a) {
__posix_spawn_file_action* last = a;
a = a->next;
free(last->path);
free(last);
}
free(*actions);
*actions = nullptr;
return 0;
}
static int posix_spawn_add_file_action(posix_spawn_file_actions_t* actions,
Action what,
int fd,
int new_fd,
const char* path,
int flags,
mode_t mode) {
__posix_spawn_file_action* action =
reinterpret_cast<__posix_spawn_file_action*>(malloc(sizeof(*action)));
if (action == nullptr) return errno;
action->next = nullptr;
if (path != nullptr) {
action->path = strdup(path);
if (action->path == nullptr) {
free(action);
return errno;
}
} else {
action->path = nullptr;
}
action->what = what;
action->fd = fd;
action->new_fd = new_fd;
action->flags = flags;
action->mode = mode;
if ((*actions)->head == nullptr) {
(*actions)->head = (*actions)->last = action;
} else {
(*actions)->last->next = action;
(*actions)->last = action;
}
return 0;
}
int posix_spawn_file_actions_addopen(posix_spawn_file_actions_t* actions,
int fd, const char* path, int flags, mode_t mode) {
if (fd < 0) return EBADF;
return posix_spawn_add_file_action(actions, kOpen, -1, fd, path, flags, mode);
}
int posix_spawn_file_actions_addclose(posix_spawn_file_actions_t* actions, int fd) {
if (fd < 0) return EBADF;
return posix_spawn_add_file_action(actions, kClose, fd, -1, nullptr, 0, 0);
}
int posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t* actions, int fd, int new_fd) {
if (fd < 0 || new_fd < 0) return EBADF;
return posix_spawn_add_file_action(actions, kDup2, fd, new_fd, nullptr, 0, 0);
}

111
packages/libandroid-spawn/posix_spawn.h
View File

@ -1,53 +1,90 @@
/*
* dhcpcd - DHCP client daemon
* Copyright (c) 2006-2012 Roy Marples <roy@marples.name>
* All rights reserved
* Copyright (C) 2017 The Android Open Source Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#ifndef POSIX_SPAWN_H
#define POSIX_SPAWN_H
#ifndef _SPAWN_H_
#define _SPAWN_H_
#include <sys/cdefs.h>
#include <sys/types.h>
#include <sched.h>
#include <signal.h>
typedef struct {
short posix_attr_flags;
#define POSIX_SPAWN_SETSIGDEF 0x10
#define POSIX_SPAWN_SETSIGMASK 0x20
sigset_t posix_attr_sigmask;
sigset_t posix_attr_sigdefault;
} posix_spawnattr_t;
__BEGIN_DECLS
typedef struct {
// int unused;
} posix_spawn_file_actions_t;
#define POSIX_SPAWN_RESETIDS 1
#define POSIX_SPAWN_SETPGROUP 2
#define POSIX_SPAWN_SETSIGDEF 4
#define POSIX_SPAWN_SETSIGMASK 8
#define POSIX_SPAWN_SETSCHEDPARAM 16
#define POSIX_SPAWN_SETSCHEDULER 32
#if defined(__USE_GNU)
#define POSIX_SPAWN_USEVFORK 64
#define POSIX_SPAWN_SETSID 128
#endif
int posix_spawn(pid_t *, const char *,
const posix_spawn_file_actions_t *, const posix_spawnattr_t *,
char *const [], char *const []);
int posix_spawnattr_init(posix_spawnattr_t *);
int posix_spawnattr_setflags(posix_spawnattr_t *, short);
int posix_spawnattr_setsigmask(posix_spawnattr_t *, const sigset_t *);
int posix_spawnattr_setsigdefault(posix_spawnattr_t *, const sigset_t *);
typedef struct __posix_spawnattr* posix_spawnattr_t;
typedef struct __posix_spawn_file_actions* posix_spawn_file_actions_t;
int posix_spawn(pid_t* __pid, const char* __path, const posix_spawn_file_actions_t* __actions, const posix_spawnattr_t* __attr, char* const __argv[], char* const __env[]) __INTRODUCED_IN(28);
int posix_spawnp(pid_t* __pid, const char* __file, const posix_spawn_file_actions_t* __actions, const posix_spawnattr_t* __attr, char* const __argv[], char* const __env[]) __INTRODUCED_IN(28);
int posix_spawnattr_init(posix_spawnattr_t* __attr) __INTRODUCED_IN(28);
int posix_spawnattr_destroy(posix_spawnattr_t* __attr) __INTRODUCED_IN(28);
int posix_spawnattr_setflags(posix_spawnattr_t* __attr, short __flags) __INTRODUCED_IN(28);
int posix_spawnattr_getflags(const posix_spawnattr_t* __attr, short* __flags) __INTRODUCED_IN(28);
int posix_spawnattr_setpgroup(posix_spawnattr_t* __attr, pid_t __pgroup) __INTRODUCED_IN(28);
int posix_spawnattr_getpgroup(const posix_spawnattr_t* __attr, pid_t* __pgroup) __INTRODUCED_IN(28);
int posix_spawnattr_setsigmask(posix_spawnattr_t* __attr, const sigset_t* __mask) __INTRODUCED_IN(28);
int posix_spawnattr_setsigmask64(posix_spawnattr_t* __attr, const sigset64_t* __mask) __INTRODUCED_IN(28);
int posix_spawnattr_getsigmask(const posix_spawnattr_t* __attr, sigset_t* __mask) __INTRODUCED_IN(28);
int posix_spawnattr_getsigmask64(const posix_spawnattr_t* __attr, sigset64_t* __mask) __INTRODUCED_IN(28);
int posix_spawnattr_setsigdefault(posix_spawnattr_t* __attr, const sigset_t* __mask) __INTRODUCED_IN(28);
int posix_spawnattr_setsigdefault64(posix_spawnattr_t* __attr, const sigset64_t* __mask) __INTRODUCED_IN(28);
int posix_spawnattr_getsigdefault(const posix_spawnattr_t* __attr, sigset_t* __mask) __INTRODUCED_IN(28);
int posix_spawnattr_getsigdefault64(const posix_spawnattr_t* __attr, sigset64_t* __mask) __INTRODUCED_IN(28);
int posix_spawnattr_setschedparam(posix_spawnattr_t* __attr, const struct sched_param* __param) __INTRODUCED_IN(28);
int posix_spawnattr_getschedparam(const posix_spawnattr_t* __attr, struct sched_param* __param) __INTRODUCED_IN(28);
int posix_spawnattr_setschedpolicy(posix_spawnattr_t* __attr, int __policy) __INTRODUCED_IN(28);
int posix_spawnattr_getschedpolicy(const posix_spawnattr_t* __attr, int* __policy) __INTRODUCED_IN(28);
int posix_spawn_file_actions_init(posix_spawn_file_actions_t* __actions) __INTRODUCED_IN(28);
int posix_spawn_file_actions_destroy(posix_spawn_file_actions_t* __actions) __INTRODUCED_IN(28);
int posix_spawn_file_actions_addopen(posix_spawn_file_actions_t* __actions, int __fd, const char* __path, int __flags, mode_t __mode) __INTRODUCED_IN(28);
int posix_spawn_file_actions_addclose(posix_spawn_file_actions_t* __actions, int __fd) __INTRODUCED_IN(28);
int posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t* __actions, int __fd, int __new_fd) __INTRODUCED_IN(28);
__END_DECLS
#endif

9
packages/ninja/build.sh
View File

@ -2,10 +2,15 @@ TERMUX_PKG_HOMEPAGE=https://ninja-build.org
TERMUX_PKG_DESCRIPTION="A small build system with a focus on speed"
TERMUX_PKG_LICENSE="Apache-2.0"
TERMUX_PKG_VERSION=1.9.0
TERMUX_PKG_REVISION=2
TERMUX_PKG_REVISION=3
TERMUX_PKG_SRCURL=https://github.com/ninja-build/ninja/archive/v${TERMUX_PKG_VERSION}.tar.gz
TERMUX_PKG_SHA256=5d7ec75828f8d3fd1a0c2f31b5b0cea780cdfe1031359228c428c1a48bfcd5b9
TERMUX_PKG_DEPENDS="libc++"
TERMUX_PKG_DEPENDS="libc++, libandroid-spawn"
termux_step_pre_configure() {
CXXFLAGS+=" $CPPFLAGS"
LDFLAGS+=" -landroid-spawn"
}
termux_step_configure() {
$TERMUX_PKG_SRCDIR/configure.py

12
packages/ninja/configure.py.patch
View File

@ -1,12 +0,0 @@
diff --git a/configure.py b/configure.py
index a443748..697a110 100755
--- a/configure.py
+++ b/configure.py
@@ -507,6 +507,7 @@ if platform.is_windows():
objs += cxx('minidump-win32')
objs += cc('getopt')
else:
+ objs += cxx('spawn')
objs += cxx('subprocess-posix')
if platform.is_aix():
objs += cc('getopt')

387
packages/ninja/src-spawn.cc.patch
View File

@ -1,387 +0,0 @@
diff --git a/src/spawn.cc b/src/spawn.cc
new file mode 100644
index 0000000..1eed715
--- /dev/null
+++ b/src/spawn.cc
@@ -0,0 +1,381 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <errno.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <android/fdsan.h>
+
+#include "spawn.h"
+
+// Bionic "private/ScopedSignalBlocker.h" + one macro needed
+#define BIONIC_DISALLOW_COPY_AND_ASSIGN(TypeName) \
+ TypeName(const TypeName&) = delete; \
+ void operator=(const TypeName&) = delete
+
+class ScopedSignalBlocker {
+ public:
+ // Block all signals.
+ explicit ScopedSignalBlocker() {
+ sigset_t set;
+ sigfillset(&set);
+ sigprocmask(SIG_BLOCK, &set, &old_set_);
+ }
+
+ // Block just the specified signal.
+ explicit ScopedSignalBlocker(int signal) {
+ sigset_t set = {};
+ sigaddset(&set, signal);
+ sigprocmask(SIG_BLOCK, &set, &old_set_);
+ }
+
+ ~ScopedSignalBlocker() {
+ reset();
+ }
+
+ void reset() {
+ sigprocmask(SIG_SETMASK, &old_set_, nullptr);
+ }
+
+ sigset_t old_set_;
+
+ BIONIC_DISALLOW_COPY_AND_ASSIGN(ScopedSignalBlocker);
+};
+
+// Bionic "private/SigSetConverter.h"
+union SigSetConverter {
+ int bsd;
+ sigset_t sigset;
+ sigset64_t sigset64;
+};
+
+enum Action {
+ kOpen,
+ kClose,
+ kDup2
+};
+
+struct __posix_spawn_file_action {
+ __posix_spawn_file_action* next;
+
+ Action what;
+ int fd;
+ int new_fd;
+ char* path;
+ int flags;
+ mode_t mode;
+
+ void Do() {
+ if (what == kOpen) {
+ fd = open(path, flags, mode);
+ if (fd == -1) _exit(127);
+ // If it didn't land where we wanted it, move it.
+ if (fd != new_fd) {
+ if (dup2(fd, new_fd) == -1) _exit(127);
+ close(fd);
+ }
+ } else if (what == kClose) {
+ // Failure to close is ignored.
+ close(fd);
+ } else {
+ if (dup2(fd, new_fd) == -1) _exit(127);
+ }
+ }
+};
+
+struct __posix_spawn_file_actions {
+ __posix_spawn_file_action* head;
+ __posix_spawn_file_action* last;
+
+ void Do() {
+ for (__posix_spawn_file_action* action = head; action != nullptr; action = action->next) {
+ action->Do();
+ }
+ }
+};
+
+struct __posix_spawnattr {
+ short flags;
+ pid_t pgroup;
+ sched_param schedparam;
+ int schedpolicy;
+ SigSetConverter sigmask;
+ SigSetConverter sigdefault;
+};
+
+static void ApplyAttrs(short flags, const posix_spawnattr_t* attr) {
+ // POSIX: "If POSIX_SPAWN_SETSIGDEF is set ... signals in sigdefault ...
+ // shall be set to their default actions in the child process."
+ // POSIX: "Signals set to be caught by the calling process shall be
+ // set to the default action in the child process."
+ bool use_sigdefault = ((flags & POSIX_SPAWN_SETSIGDEF) != 0);
+ const struct sigaction default_sa = { .sa_handler = SIG_DFL };
+ for (int s = 1; s < _NSIG; ++s) {
+ bool reset = false;
+ if (use_sigdefault && sigismember(&(*attr)->sigdefault.sigset, s)) {
+ reset = true;
+ } else {
+ struct sigaction current;
+ if (sigaction(s, nullptr, &current) == -1) _exit(127);
+ reset = (current.sa_handler != SIG_IGN && current.sa_handler != SIG_DFL);
+ }
+ if (reset && sigaction(s, &default_sa, nullptr) == -1) _exit(127);
+ }
+
+ if ((flags & POSIX_SPAWN_SETPGROUP) != 0 && setpgid(0, (*attr)->pgroup) == -1) _exit(127);
+ if ((flags & POSIX_SPAWN_SETSID) != 0 && setsid() == -1) _exit(127);
+
+ // POSIX_SPAWN_SETSCHEDULER overrides POSIX_SPAWN_SETSCHEDPARAM, but it is not an error
+ // to set both.
+ if ((flags & POSIX_SPAWN_SETSCHEDULER) != 0) {
+ if (sched_setscheduler(0, (*attr)->schedpolicy, &(*attr)->schedparam) == -1) _exit(127);
+ } else if ((flags & POSIX_SPAWN_SETSCHEDPARAM) != 0) {
+ if (sched_setparam(0, &(*attr)->schedparam) == -1) _exit(127);
+ }
+
+ if ((flags & POSIX_SPAWN_RESETIDS) != 0) {
+ if (seteuid(getuid()) == -1 || setegid(getgid()) == -1) _exit(127);
+ }
+
+ if ((flags & POSIX_SPAWN_SETSIGMASK) != 0) {
+ if (sigprocmask(SIG_SETMASK, &(*attr)->sigmask.sigset, nullptr)) _exit(127);
+ }
+}
+
+static int posix_spawn(pid_t* pid_ptr,
+ const char* path,
+ const posix_spawn_file_actions_t* actions,
+ const posix_spawnattr_t* attr,
+ char* const argv[],
+ char* const env[],
+ int exec_fn(const char* path, char* const argv[], char* const env[])) {
+ // See http://man7.org/linux/man-pages/man3/posix_spawn.3.html
+ // and http://pubs.opengroup.org/onlinepubs/9699919799/functions/posix_spawn.html
+
+ ScopedSignalBlocker ssb;
+
+ short flags = attr ? (*attr)->flags : 0;
+ bool use_vfork = ((flags & POSIX_SPAWN_USEVFORK) != 0) || (actions == nullptr && flags == 0);
+
+ pid_t pid = use_vfork ? vfork() : fork();
+ if (pid == -1) return errno;
+
+ if (pid == 0) {
+ // Child.
+ ApplyAttrs(flags, attr);
+ if (actions) (*actions)->Do();
+ if ((flags & POSIX_SPAWN_SETSIGMASK) == 0) ssb.reset();
+ exec_fn(path, argv, env ? env : environ);
+ _exit(127);
+ }
+
+ // Parent.
+ if (pid_ptr) *pid_ptr = pid;
+ return 0;
+}
+
+int posix_spawn(pid_t* pid, const char* path, const posix_spawn_file_actions_t* actions,
+ const posix_spawnattr_t* attr, char* const argv[], char* const env[]) {
+ return posix_spawn(pid, path, actions, attr, argv, env, execve);
+}
+
+int posix_spawnp(pid_t* pid, const char* file, const posix_spawn_file_actions_t* actions,
+ const posix_spawnattr_t* attr, char* const argv[], char* const env[]) {
+ return posix_spawn(pid, file, actions, attr, argv, env, execvpe);
+}
+
+int posix_spawnattr_init(posix_spawnattr_t* attr) {
+ *attr = reinterpret_cast<__posix_spawnattr*>(calloc(1, sizeof(__posix_spawnattr)));
+ return (*attr == nullptr) ? errno : 0;
+}
+
+int posix_spawnattr_destroy(posix_spawnattr_t* attr) {
+ free(*attr);
+ *attr = nullptr;
+ return 0;
+}
+
+int posix_spawnattr_setflags(posix_spawnattr_t* attr, short flags) {
+ if ((flags & ~(POSIX_SPAWN_RESETIDS | POSIX_SPAWN_SETPGROUP | POSIX_SPAWN_SETSIGDEF |
+ POSIX_SPAWN_SETSIGMASK | POSIX_SPAWN_SETSCHEDPARAM | POSIX_SPAWN_SETSCHEDULER |
+ POSIX_SPAWN_USEVFORK | POSIX_SPAWN_SETSID)) != 0) {
+ return EINVAL;
+ }
+ (*attr)->flags = flags;
+ return 0;
+}
+
+int posix_spawnattr_getflags(const posix_spawnattr_t* attr, short* flags) {
+ *flags = (*attr)->flags;
+ return 0;
+}
+
+int posix_spawnattr_setpgroup(posix_spawnattr_t* attr, pid_t pgroup) {
+ (*attr)->pgroup = pgroup;
+ return 0;
+}
+
+int posix_spawnattr_getpgroup(const posix_spawnattr_t* attr, pid_t* pgroup) {
+ *pgroup = (*attr)->pgroup;
+ return 0;
+}
+
+int posix_spawnattr_setsigmask(posix_spawnattr_t* attr, const sigset_t* mask) {
+ (*attr)->sigmask.sigset = *mask;
+ return 0;
+}
+
+int posix_spawnattr_setsigmask64(posix_spawnattr_t* attr, const sigset64_t* mask) {
+ (*attr)->sigmask.sigset64 = *mask;
+ return 0;
+}
+
+int posix_spawnattr_getsigmask(const posix_spawnattr_t* attr, sigset_t* mask) {
+ *mask = (*attr)->sigmask.sigset;
+ return 0;
+}
+
+int posix_spawnattr_getsigmask64(const posix_spawnattr_t* attr, sigset64_t* mask) {
+ *mask = (*attr)->sigmask.sigset64;
+ return 0;
+}
+
+int posix_spawnattr_setsigdefault(posix_spawnattr_t* attr, const sigset_t* mask) {
+ (*attr)->sigdefault.sigset = *mask;
+ return 0;
+}
+
+int posix_spawnattr_setsigdefault64(posix_spawnattr_t* attr, const sigset64_t* mask) {
+ (*attr)->sigdefault.sigset64 = *mask;
+ return 0;
+}
+
+int posix_spawnattr_getsigdefault(const posix_spawnattr_t* attr, sigset_t* mask) {
+ *mask = (*attr)->sigdefault.sigset;
+ return 0;
+}
+
+int posix_spawnattr_getsigdefault64(const posix_spawnattr_t* attr, sigset64_t* mask) {
+ *mask = (*attr)->sigdefault.sigset64;
+ return 0;
+}
+
+int posix_spawnattr_setschedparam(posix_spawnattr_t* attr, const struct sched_param* param) {
+ (*attr)->schedparam = *param;
+ return 0;
+}
+
+int posix_spawnattr_getschedparam(const posix_spawnattr_t* attr, struct sched_param* param) {
+ *param = (*attr)->schedparam;
+ return 0;
+}
+
+int posix_spawnattr_setschedpolicy(posix_spawnattr_t* attr, int policy) {
+ (*attr)->schedpolicy = policy;
+ return 0;
+}
+
+int posix_spawnattr_getschedpolicy(const posix_spawnattr_t* attr, int* policy) {
+ *policy = (*attr)->schedpolicy;
+ return 0;
+}
+
+int posix_spawn_file_actions_init(posix_spawn_file_actions_t* actions) {
+ *actions = reinterpret_cast<__posix_spawn_file_actions*>(calloc(1, sizeof(**actions)));
+ return (*actions == nullptr) ? errno : 0;
+}
+
+int posix_spawn_file_actions_destroy(posix_spawn_file_actions_t* actions) {
+ __posix_spawn_file_action* a = (*actions)->head;
+ while (a) {
+ __posix_spawn_file_action* last = a;
+ a = a->next;
+ free(last->path);
+ free(last);
+ }
+ free(*actions);
+ *actions = nullptr;
+ return 0;
+}
+
+static int posix_spawn_add_file_action(posix_spawn_file_actions_t* actions,
+ Action what,
+ int fd,
+ int new_fd,
+ const char* path,
+ int flags,
+ mode_t mode) {
+ __posix_spawn_file_action* action =
+ reinterpret_cast<__posix_spawn_file_action*>(malloc(sizeof(*action)));
+ if (action == nullptr) return errno;
+
+ action->next = nullptr;
+ if (path != nullptr) {
+ action->path = strdup(path);
+ if (action->path == nullptr) {
+ free(action);
+ return errno;
+ }
+ } else {
+ action->path = nullptr;
+ }
+ action->what = what;
+ action->fd = fd;
+ action->new_fd = new_fd;
+ action->flags = flags;
+ action->mode = mode;
+
+ if ((*actions)->head == nullptr) {
+ (*actions)->head = (*actions)->last = action;
+ } else {
+ (*actions)->last->next = action;
+ (*actions)->last = action;
+ }
+
+ return 0;
+}
+
+int posix_spawn_file_actions_addopen(posix_spawn_file_actions_t* actions,
+ int fd, const char* path, int flags, mode_t mode) {
+ if (fd < 0) return EBADF;
+ return posix_spawn_add_file_action(actions, kOpen, -1, fd, path, flags, mode);
+}
+
+int posix_spawn_file_actions_addclose(posix_spawn_file_actions_t* actions, int fd) {
+ if (fd < 0) return EBADF;
+ return posix_spawn_add_file_action(actions, kClose, fd, -1, nullptr, 0, 0);
+}
+
+int posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t* actions, int fd, int new_fd) {
+ if (fd < 0 || new_fd < 0) return EBADF;
+ return posix_spawn_add_file_action(actions, kDup2, fd, new_fd, nullptr, 0, 0);
+}

96
packages/ninja/src-spawn.h.patch
View File

@ -1,96 +0,0 @@
diff --git a/src/spawn.h b/src/spawn.h
new file mode 100644
index 0000000..2e239bf
--- /dev/null
+++ b/src/spawn.h
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef _SPAWN_H_
+#define _SPAWN_H_
+
+#include <sys/cdefs.h>
+#include <sys/types.h>
+#include <sched.h>
+#include <signal.h>
+
+__BEGIN_DECLS
+
+#define POSIX_SPAWN_RESETIDS 1
+#define POSIX_SPAWN_SETPGROUP 2
+#define POSIX_SPAWN_SETSIGDEF 4
+#define POSIX_SPAWN_SETSIGMASK 8
+#define POSIX_SPAWN_SETSCHEDPARAM 16
+#define POSIX_SPAWN_SETSCHEDULER 32
+#if defined(__USE_GNU)
+#define POSIX_SPAWN_USEVFORK 64
+#define POSIX_SPAWN_SETSID 128
+#endif
+
+typedef struct __posix_spawnattr* posix_spawnattr_t;
+typedef struct __posix_spawn_file_actions* posix_spawn_file_actions_t;
+
+int posix_spawn(pid_t* __pid, const char* __path, const posix_spawn_file_actions_t* __actions, const posix_spawnattr_t* __attr, char* const __argv[], char* const __env[]) __INTRODUCED_IN(28);
+int posix_spawnp(pid_t* __pid, const char* __file, const posix_spawn_file_actions_t* __actions, const posix_spawnattr_t* __attr, char* const __argv[], char* const __env[]) __INTRODUCED_IN(28);
+
+int posix_spawnattr_init(posix_spawnattr_t* __attr) __INTRODUCED_IN(28);
+int posix_spawnattr_destroy(posix_spawnattr_t* __attr) __INTRODUCED_IN(28);
+
+int posix_spawnattr_setflags(posix_spawnattr_t* __attr, short __flags) __INTRODUCED_IN(28);
+int posix_spawnattr_getflags(const posix_spawnattr_t* __attr, short* __flags) __INTRODUCED_IN(28);
+
+int posix_spawnattr_setpgroup(posix_spawnattr_t* __attr, pid_t __pgroup) __INTRODUCED_IN(28);
+int posix_spawnattr_getpgroup(const posix_spawnattr_t* __attr, pid_t* __pgroup) __INTRODUCED_IN(28);
+
+int posix_spawnattr_setsigmask(posix_spawnattr_t* __attr, const sigset_t* __mask) __INTRODUCED_IN(28);
+int posix_spawnattr_setsigmask64(posix_spawnattr_t* __attr, const sigset64_t* __mask) __INTRODUCED_IN(28);
+int posix_spawnattr_getsigmask(const posix_spawnattr_t* __attr, sigset_t* __mask) __INTRODUCED_IN(28);
+int posix_spawnattr_getsigmask64(const posix_spawnattr_t* __attr, sigset64_t* __mask) __INTRODUCED_IN(28);
+
+int posix_spawnattr_setsigdefault(posix_spawnattr_t* __attr, const sigset_t* __mask) __INTRODUCED_IN(28);
+int posix_spawnattr_setsigdefault64(posix_spawnattr_t* __attr, const sigset64_t* __mask) __INTRODUCED_IN(28);
+int posix_spawnattr_getsigdefault(const posix_spawnattr_t* __attr, sigset_t* __mask) __INTRODUCED_IN(28);
+int posix_spawnattr_getsigdefault64(const posix_spawnattr_t* __attr, sigset64_t* __mask) __INTRODUCED_IN(28);
+
+int posix_spawnattr_setschedparam(posix_spawnattr_t* __attr, const struct sched_param* __param) __INTRODUCED_IN(28);
+int posix_spawnattr_getschedparam(const posix_spawnattr_t* __attr, struct sched_param* __param) __INTRODUCED_IN(28);
+
+int posix_spawnattr_setschedpolicy(posix_spawnattr_t* __attr, int __policy) __INTRODUCED_IN(28);
+int posix_spawnattr_getschedpolicy(const posix_spawnattr_t* __attr, int* __policy) __INTRODUCED_IN(28);
+
+int posix_spawn_file_actions_init(posix_spawn_file_actions_t* __actions) __INTRODUCED_IN(28);
+int posix_spawn_file_actions_destroy(posix_spawn_file_actions_t* __actions) __INTRODUCED_IN(28);
+
+int posix_spawn_file_actions_addopen(posix_spawn_file_actions_t* __actions, int __fd, const char* __path, int __flags, mode_t __mode) __INTRODUCED_IN(28);
+int posix_spawn_file_actions_addclose(posix_spawn_file_actions_t* __actions, int __fd) __INTRODUCED_IN(28);
+int posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t* __actions, int __fd, int __new_fd) __INTRODUCED_IN(28);
+
+__END_DECLS
+
+#endif

12
packages/ninja/src-subprocess-posix.cc.patch
View File

@ -2,18 +2,6 @@ diff --git a/src/subprocess-posix.cc b/src/subprocess-posix.cc
index 1de22c3..f988297 100644
--- a/src/subprocess-posix.cc
+++ b/src/subprocess-posix.cc
@@ -22,10 +22,10 @@
#include <stdio.h>
#include <string.h>
#include <sys/wait.h>
-#include <spawn.h>
extern char** environ;
+#include "spawn.h"
#include "util.h"
Subprocess::Subprocess(bool use_console) : fd_(-1), pid_(-1),
@@ -110,8 +110,8 @@ bool Subprocess::Start(SubprocessSet* set, const string& command) {
if (err != 0)
Fatal("posix_spawnattr_setflags: %s", strerror(err));