lukechilds
/
termux-packages
mirror of https://github.com/lukechilds/termux-packages.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

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

emacs-27
Butta 6 years ago
committed by Fredrik Fornwall
parent
6145c7afb5
commit
2aff54c113
9 changed files with 467 additions and 707 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 6
      packages/libandroid-spawn/build.sh
  2. 156
      packages/libandroid-spawn/posix_spawn.c
  3. 381
      packages/libandroid-spawn/posix_spawn.cpp
  4. 115
      packages/libandroid-spawn/posix_spawn.h
  5. 9
      packages/ninja/build.sh
  6. 12
      packages/ninja/configure.py.patch
  7. 387
      packages/ninja/src-spawn.cc.patch
  8. 96
      packages/ninja/src-spawn.h.patch
  9. 12
      packages/ninja/src-subprocess-posix.cc.patch

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
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);
}

115
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;
typedef struct {
// int unused;
} posix_spawn_file_actions_t;
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 *);
__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

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));

Write Preview
Loading…
Cancel
Save