本文整理汇总了C++中posix_spawnattr_setflags函数的典型用法代码示例。如果您正苦于以下问题:C++ posix_spawnattr_setflags函数的具体用法?C++ posix_spawnattr_setflags怎么用?C++ posix_spawnattr_setflags使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了posix_spawnattr_setflags函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: TEST
TEST(spawn, posix_spawn_POSIX_SPAWN_SETSIGDEF) {
// Ignore SIGALRM and SIGCONT in the parent...
ASSERT_NE(SIG_ERR, signal(SIGALRM, SIG_IGN));
ASSERT_NE(SIG_ERR, signal(SIGCONT, SIG_IGN));
posix_spawnattr_t sa;
ASSERT_EQ(0, posix_spawnattr_init(&sa));
// Ask for SIGALRM to be defaulted in the child...
sigset_t just_SIGALRM;
sigemptyset(&just_SIGALRM);
sigaddset(&just_SIGALRM, SIGALRM);
ASSERT_EQ(0, posix_spawnattr_setsigdefault(&sa, &just_SIGALRM));
ASSERT_EQ(0, posix_spawnattr_setflags(&sa, POSIX_SPAWN_SETSIGDEF));
// Check that's what happens...
ProcStatus ps = {};
GetChildStatus(&sa, &ps);
// TIMER_SIGNAL should be blocked.
uint64_t expected_blocked = 0;
SignalSetAdd(&expected_blocked, __SIGRTMIN + 0);
EXPECT_EQ(expected_blocked, ps.sigblk);
uint64_t expected_ignored = 0;
SignalSetAdd(&expected_ignored, SIGCONT);
EXPECT_EQ(expected_ignored, ps.sigign);
ASSERT_EQ(0, posix_spawnattr_destroy(&sa));
}
示例2: spawn_win32
static void spawn_win32(void) {
char module_name[WATCHMAN_NAME_MAX];
GetModuleFileName(NULL, module_name, sizeof(module_name));
char *argv[MAX_DAEMON_ARGS] = {
module_name,
"--foreground",
NULL
};
posix_spawn_file_actions_t actions;
posix_spawnattr_t attr;
pid_t pid;
int i;
for (i = 0; daemon_argv[i]; i++) {
append_argv(argv, daemon_argv[i]);
}
posix_spawnattr_init(&attr);
posix_spawnattr_setflags(&attr, POSIX_SPAWN_SETPGROUP);
posix_spawn_file_actions_init(&actions);
posix_spawn_file_actions_addopen(&actions,
STDIN_FILENO, "/dev/null", O_RDONLY, 0);
posix_spawn_file_actions_addopen(&actions,
STDOUT_FILENO, log_name, O_WRONLY|O_CREAT|O_APPEND, 0600);
posix_spawn_file_actions_adddup2(&actions,
STDOUT_FILENO, STDERR_FILENO);
posix_spawnp(&pid, argv[0], &actions, &attr, argv, environ);
posix_spawnattr_destroy(&attr);
posix_spawn_file_actions_destroy(&actions);
}
示例3: target_proc
void target_proc(struct execute_context *ctx)
{
int ret;
char **args = ctx->passing_args;
short ps_flags = 0;
pid_t pid;
posix_spawn_file_actions_t actions;
posix_spawnattr_t attrs;
if (args == NULL) {
return;
}
RESET_ERROR;
posix_spawn_file_actions_init(&actions);
posix_spawnattr_init(&attrs);
#ifndef _POSIX_SPAWN_DISABLE_ASLR
# define _POSIX_SPAWN_DISABLE_ASLR 0x0100
#endif
ps_flags |= POSIX_SPAWN_SETEXEC;
ps_flags |= _POSIX_SPAWN_DISABLE_ASLR;
ret = posix_spawnattr_setflags(&attrs, ps_flags);
if (ret != 0) {
fprintf(stderr, "cannot set posix_spawn flags\n");
return;
}
/* attached */
ret = ptrace(PT_TRACE_ME, 0, 0, 0);
posix_spawn(&pid, args[0], &actions, &attrs, args, NULL);
fprintf(stderr, "Failed\n");
exit(1);
}
示例4: rb_spawn_process
pid_t
rb_spawn_process(const char *path, const char **argv)
{
pid_t pid;
const void *arghack = argv;
char **myenviron;
int error;
posix_spawnattr_t spattr;
posix_spawnattr_init(&spattr);
#ifdef POSIX_SPAWN_USEVFORK
posix_spawnattr_setflags(&spattr, POSIX_SPAWN_USEVFORK);
#endif
#ifdef __APPLE__
myenviron = *_NSGetEnviron(); /* apple needs to go fuck themselves for this */
#else
myenviron = environ;
#endif
error = posix_spawn(&pid, path, NULL, &spattr, arghack, myenviron);
posix_spawnattr_destroy(&spattr);
if (error != 0) {
errno = error;
pid = -1;
}
return pid;
}
示例5: l_posix_spawnattr_setflags
static int l_posix_spawnattr_setflags(lua_State *L) {
int r;
posix_spawnattr_t *attr = luaL_checkudata(L, 1, "posix_spawnattr_t");
short int flags = 0;
luaL_checktype(L, 2, LUA_TTABLE);
lua_getfield(L, 2, "resetids");
if (lua_toboolean(L, -1)) flags |= POSIX_SPAWN_RESETIDS;
lua_getfield(L, 2, "setpgroup");
if (lua_toboolean(L, -1)) flags |= POSIX_SPAWN_SETPGROUP;
lua_getfield(L, 2, "setsigdef");
if (lua_toboolean(L, -1)) flags |= POSIX_SPAWN_SETSIGDEF;
lua_getfield(L, 2, "setsigmask");
if (lua_toboolean(L, -1)) flags |= POSIX_SPAWN_SETSIGMASK;
lua_getfield(L, 2, "setschedparam");
if (lua_toboolean(L, -1)) flags |= POSIX_SPAWN_SETSCHEDPARAM;
lua_getfield(L, 2, "setscheduler");
if (lua_toboolean(L, -1)) flags |= POSIX_SPAWN_SETSCHEDULER;
lua_pop(L, 6);
#ifdef POSIX_SPAWN_USEVFORK
lua_getfield(L, 2, "usevfork");
if (lua_toboolean(L, -1)) flags |= POSIX_SPAWN_USEVFORK;
lua_pop(L, 1);
#endif
if (0 != (r = posix_spawnattr_setflags(attr, flags))) {
lua_pushnil(L);
lua_pushstring(L, strerror(r));
lua_pushinteger(L, r);
return 3;
}
lua_pushboolean(L, 1);
return 1;
}
示例6: Open
static int Open (vlc_object_t *obj)
{
vlc_inhibit_t *ih = (vlc_inhibit_t *)obj;
vlc_inhibit_sys_t *p_sys = malloc (sizeof (*p_sys));
if (p_sys == NULL)
return VLC_ENOMEM;
posix_spawnattr_init (&p_sys->attr);
/* Reset signal handlers to default and clear mask in the child process */
{
sigset_t set;
sigemptyset (&set);
posix_spawnattr_setsigmask (&p_sys->attr, &set);
sigaddset (&set, SIGPIPE);
posix_spawnattr_setsigdefault (&p_sys->attr, &set);
posix_spawnattr_setflags (&p_sys->attr, POSIX_SPAWN_SETSIGDEF
| POSIX_SPAWN_SETSIGMASK);
}
ih->p_sys = p_sys;
if (vlc_timer_create (&p_sys->timer, Timer, ih))
{
posix_spawnattr_destroy (&p_sys->attr);
free (p_sys);
return VLC_ENOMEM;
}
ih->inhibit = Inhibit;
return VLC_SUCCESS;
}
示例7: main
int main(int argc, char **argv)
{
extern char **environ;
pid_t pid;
posix_spawnattr_t attr;
int res, status = 1;
char *default_argv[] = {"/bin/sh", NULL};
if (argc >= 2)
++ argv;
else
argv = default_argv;
res = posix_spawnattr_init(&attr);
if (res != 0)
return res;
res = posix_spawnattr_setflags(&attr, _POSIX_SPAWN_DISABLE_ASLR);
if (res != 0)
return res;
res = posix_spawn(&pid, argv[0], NULL, &attr, argv, environ);
if (res != 0)
return res;
if (waitpid(pid, &status, 0) == -1)
return 1;
if (!WIFEXITED(status))
return 1;
return WEXITSTATUS(status);
}
示例8: Launch_posixSpawnSuspended
/*
* Static function implementations
*/
pid_t Launch_posixSpawnSuspended(cpu_type_t cpuType, const char *path, char** argv) {
pid_t retVal = -1;
if (path == NULL || argv == NULL) {
Log_invalidArgument("path: %p, argv: %p", path, argv);
} else {
posix_spawnattr_t attr = 0;
int ret = posix_spawnattr_init(&attr);
if (ret != 0) {
Log_errorPosix(ret, "posix_spawnattr_init");
} else {
sigset_t no_signals = 0;
sigset_t all_signals = 0;
sigemptyset(&no_signals);
sigfillset(&all_signals);
posix_spawnattr_setsigmask(&attr, &no_signals);
posix_spawnattr_setsigdefault(&attr, &all_signals);
if (cpuType != CPU_TYPE_ANY) {
size_t ocount = 0;
// if specified choose the arch from the fat binary to run
ret = posix_spawnattr_setbinpref_np(&attr, 1, &cpuType, &ocount);
if (ret != 0) {
Log_errorPosix(ret, "posix_spawnattr_setbinpref_np");
}
}
if (ret == 0) {
ret = posix_spawnattr_setflags(&attr,
POSIX_SPAWN_START_SUSPENDED
| _POSIX_SPAWN_DISABLE_ASLR
| POSIX_SPAWN_SETSIGDEF
| POSIX_SPAWN_SETSIGMASK);
if (ret != 0) {
Log_errorPosix(ret, "posix_spawnattr_setflags");
} else {
pid_t pid = -1;
ret = posix_spawnp(&pid,
path,
NULL,
&attr,
(char * const*)argv,
(char * const*)NULL);
if (ret != 0) {
Log_errorPosix(ret, "posix_spawnp");
} else {
retVal = pid;
}
}
}
posix_spawnattr_destroy(&attr);
}
}
return retVal;
}
示例9: setup_spawnattr
static void
setup_spawnattr(posix_spawnattr_t* spawnattr)
{
size_t ocount;
size_t count;
cpu_type_t cpu_types[1];
short flags = 0;
#ifdef __LP64__
int ch;
#endif
if ((errno = posix_spawnattr_init(spawnattr)) != 0) {
err(2, "posix_spawnattr_int");
/* NOTREACHTED */
}
count = 1;
/* Run the real python executable using the same architecture as this
* executable, this allows users to control the architecture using
* "arch -ppc python"
*/
#if defined(__ppc64__)
cpu_types[0] = CPU_TYPE_POWERPC64;
#elif defined(__x86_64__)
cpu_types[0] = CPU_TYPE_X86_64;
#elif defined(__ppc__)
cpu_types[0] = CPU_TYPE_POWERPC;
#elif defined(__i386__)
cpu_types[0] = CPU_TYPE_X86;
#else
# error "Unknown CPU"
#endif
if (posix_spawnattr_setbinpref_np(spawnattr, count,
cpu_types, &ocount) == -1) {
err(1, "posix_spawnattr_setbinpref");
/* NOTREACHTED */
}
if (count != ocount) {
fprintf(stderr, "posix_spawnattr_setbinpref failed to copy\n");
exit(1);
/* NOTREACHTED */
}
/*
* Set flag that causes posix_spawn to behave like execv
*/
flags |= POSIX_SPAWN_SETEXEC;
if ((errno = posix_spawnattr_setflags(spawnattr, flags)) != 0) {
err(1, "posix_spawnattr_setflags");
/* NOTREACHTED */
}
}
示例10: do_test_setsid
static void
do_test_setsid (bool test_setsid)
{
pid_t sid, child_sid;
int res;
/* Current session ID. */
sid = getsid(0);
if (sid == (pid_t) -1)
FAIL_EXIT1 ("getsid (0): %m");
posix_spawnattr_t attrp;
/* posix_spawnattr_init should not fail (it basically memset the
attribute). */
posix_spawnattr_init (&attrp);
if (test_setsid)
{
res = posix_spawnattr_setflags (&attrp, POSIX_SPAWN_SETSID);
if (res != 0)
{
errno = res;
FAIL_EXIT1 ("posix_spawnattr_setflags: %m");
}
}
/* Program to run. */
char *args[2] = { (char *) "true", NULL };
pid_t child;
res = posix_spawnp (&child, "true", NULL, &attrp, args, environ);
/* posix_spawnattr_destroy is noop. */
posix_spawnattr_destroy (&attrp);
if (res != 0)
{
errno = res;
FAIL_EXIT1 ("posix_spawnp: %m");
}
/* Child should have a different session ID than parent. */
child_sid = getsid (child);
if (child_sid == (pid_t) -1)
FAIL_EXIT1 ("getsid (%i): %m", child);
if (test_setsid)
{
if (child_sid == sid)
FAIL_EXIT1 ("child session ID matched parent one");
}
else
{
if (child_sid != sid)
FAIL_EXIT1 ("child session ID did not match parent one");
}
}
示例11: lua_newuserdata
struct spawn_params *spawn_param_init(lua_State *L)
{
struct spawn_params *p = lua_newuserdata(L, sizeof *p);
p->L = L;
p->command = 0;
p->argv = p->envp = 0;
posix_spawn_file_actions_init(&p->redirect);
posix_spawnattr_init(&p->attr);
posix_spawnattr_setflags(&p->attr, POSIX_SPAWN_USEVFORK);
return p;
}
示例12: main
int main (void)
{
pid_t pid ;
posix_spawn_file_actions_t actions ;
posix_spawnattr_t attr ;
char *const argv[2] = { "/bin/true", 0 } ;
char *const envp[1] = { 0 } ;
posix_spawnattr_setflags(&attr, 0) ;
posix_spawn_file_actions_init(&actions) ;
return posix_spawn(&pid, argv[0], 0, 0, argv, envp) ;
}
示例13: launchTest
static struct task_and_pid launchTest(const char* testProgPath, bool launchOtherArch, bool launchSuspended)
{
posix_spawnattr_t attr = 0;
if ( posix_spawnattr_init(&attr) != 0 ) {
printf("[FAIL] dyld_process_info posix_spawnattr_init()\n");
exit(0);
}
if ( launchSuspended ) {
if ( posix_spawnattr_setflags(&attr, POSIX_SPAWN_START_SUSPENDED) != 0 ) {
printf("[FAIL] dyld_process_info POSIX_SPAWN_START_SUSPENDED\n");
exit(0);
}
}
if ( launchOtherArch ) {
size_t copied;
if ( posix_spawnattr_setbinpref_np(&attr, 1, otherArch, &copied) != 0 ) {
printf("[FAIL] dyld_process_info posix_spawnattr_setbinpref_np()\n");
exit(0);
}
}
struct task_and_pid child = {0, 0};
const char* argv[] = { testProgPath, NULL };
int psResult = posix_spawn(&child.pid, testProgPath, NULL, &attr, (char**)argv, environ);
if ( psResult != 0 ) {
printf("[FAIL] dyld_process_info posix_spawn(%s) failed, err=%d\n", testProgPath, psResult);
exit(0);
}
if (posix_spawnattr_destroy(&attr) != 0) {
printf("[FAIL] dyld_process_info posix_spawnattr_destroy()\n");
exit(0);
}
if ( task_for_pid(mach_task_self(), child.pid, &child.task) != KERN_SUCCESS ) {
printf("[FAIL] dyld_process_info task_for_pid()\n");
kill(child.pid, SIGKILL);
exit(0);
}
#if __x86_64__
//printf("child pid=%d task=%d (%s, %s)\n", child.pid, child.task, launchOtherArch ? "i386" : "x86_64", launchSuspended ? "suspended" : "active");
#endif
// wait until process is up and has suspended itself
struct task_basic_info info;
do {
unsigned count = TASK_BASIC_INFO_COUNT;
kern_return_t kr = task_info(child.task, TASK_BASIC_INFO, (task_info_t)&info, &count);
sleep(1);
} while ( info.suspend_count == 0 );
return child;
}
示例14: test_proc
void
test_proc(pid_t bad_pid)
{
dispatch_source_t proc_s[PID_CNT], proc;
int res;
pid_t pid, monitor_pid;
event_cnt = 0;
// Creates a process and register multiple observers. Send a signal,
// exit the process, etc., and verify all observers were notified.
posix_spawnattr_t attr;
res = posix_spawnattr_init(&attr);
assert(res == 0);
#if HAVE_DECL_POSIX_SPAWN_START_SUSPENDED
res = posix_spawnattr_setflags(&attr, POSIX_SPAWN_START_SUSPENDED);
assert(res == 0);
#endif
char* args[] = {
"/bin/sleep", "2", NULL
};
res = posix_spawnp(&pid, args[0], NULL, &attr, args, NULL);
if (res < 0) {
perror(args[0]);
exit(127);
}
res = posix_spawnattr_destroy(&attr);
assert(res == 0);
dispatch_group_t group = dispatch_group_create();
assert(pid > 0);
monitor_pid = bad_pid ? bad_pid : pid; // rdar://problem/8090801
int i;
for (i = 0; i < PID_CNT; ++i) {
dispatch_group_enter(group);
proc = proc_s[i] = dispatch_source_create(DISPATCH_SOURCE_TYPE_PROC,
monitor_pid, DISPATCH_PROC_EXIT, dispatch_get_global_queue(0, 0));
test_ptr_notnull("dispatch_source_proc_create", proc);
dispatch_source_set_event_handler(proc, ^{
long flags = dispatch_source_get_data(proc);
test_long("DISPATCH_PROC_EXIT", flags, DISPATCH_PROC_EXIT);
event_cnt++;
dispatch_source_cancel(proc);
});
dispatch_source_set_cancel_handler(proc, ^{
dispatch_group_leave(group);
});
示例15: posix_spawnattr_getflags
void ChildProcess::Options::setFlags(short flags) {
short currentFlags;
auto err = posix_spawnattr_getflags(&inner_->attr, ¤tFlags);
if (err) {
throw std::system_error(
err, std::generic_category(), "posix_spawnattr_getflags");
}
err = posix_spawnattr_setflags(&inner_->attr, currentFlags | flags);
if (err) {
throw std::system_error(
err, std::generic_category(), "posix_spawnattr_setflags");
}
}