int main(void) { int sp[2]; if (-1 == socketpair(AF_UNIX, SOCK_STREAM, 0, sp)) { fprintf(stderr, "socketpair(): %s\n", strerror(errno)); exit(EXIT_FAILURE); } switch (fork()) { case -1: fprintf(stderr, "fork(): %s\n", strerror(errno)); exit(EXIT_FAILURE); case 0: close(sp[0]); do_child(sp[1]); break; default: close(sp[1]); do_parent(sp[0]); break; } exit(EXIT_SUCCESS); }
int main(int argc, char **argv) { int forkres, i; /* Get subtest number */ if(argc != 2) { printf("Usage: %s subtest_no\n", argv[0]); exit(-2); } else if(sscanf(argv[1], "%d", &subtest) != 1) { printf("Usage: %s subtest_no\n", argv[0]); exit(-2); } /* Fork off a bunch of children */ for(i = 0; i < NUMCHILDREN; i++) { forkres = fork(); if(forkres == 0) do_child(i); else if(forkres < 0) { perror("Unable to fork"); exit(-1); } } /* do_child always calls exit(), so when we end up here, we're the parent. */ do_parent(); exit(-2); /* We're not supposed to get here. Both do_* routines should exit.*/ }
int main(int argc, char *argv[]) { int rank, size; MPI_Comm parent; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); /* Check to see if we *were* spawned -- because this is a test, we can only assume the existence of this one executable. Hence, we both mpirun it and spawn it. */ parent = MPI_COMM_NULL; MPI_Comm_get_parent(&parent); if (parent != MPI_COMM_NULL) { whoami = argv[1]; do_target(argv, parent); } else { do_parent(argv, rank, size); } /* All done */ MPI_Finalize(); return 0; }
int main(int argc, char **argv) { int forkres; /* Get subtest number */ if(argc != 2) { printf("Usage: %s subtest_no\n", argv[0]); exit(-2); } else if(sscanf(argv[1], "%d", &subtest) != 1) { printf("Usage: %s subtest_no\n", argv[0]); exit(-2); } /* Set up anonymous pipe */ if(pipe(fd_ap) < 0) { perror("Could not create anonymous pipe"); exit(-1); } forkres = fork(); if(forkres == 0) do_child(); else if(forkres > 0) do_parent(forkres); else { /* Fork failed */ perror("Unable to fork"); exit(-1); } exit(-2); /* We're not supposed to get here. Both do_* routines should exit*/ }
int main(int argc, char **argv) { int forkres; int master, slave; /* Get subtest number */ if(argc != 2) { printf("Usage: %s subtest_no\n", argv[0]); exit(-1); } else if(sscanf(argv[1], "%d", &subtest) != 1) { printf("Usage: %s subtest_no\n", argv[0]); exit(-1); } open_terminal(&master, &slave); forkres = fork(); if(forkres == 0) do_child(master); else if(forkres > 0) do_parent(forkres, slave); else { /* Fork failed */ perror("Unable to fork"); exit(-1); } exit(-2); /* We're not supposed to get here. Both do_* routines should exit*/ }
/* and the main function. */ int main(int argc, char* argv[]) { int data_pipe[2]; /* an array to store the file descriptors of the pipe. */ int pid; /* pid of child process, or 0, as returned via fork. */ int rc; /* stores return values of various routines. */ /* first, create a pipe. */ rc = pipe(data_pipe); if (rc == -1) { perror("pipe"); exit(1); } /* now fork off a child process, and set their handling routines. */ pid = fork(); switch (pid) { case -1: /* fork failed. */ perror("fork"); exit(1); case 0: /* inside child process. */ do_child(data_pipe); /* NOT REACHED */ default: /* inside parent process. */ do_parent(data_pipe); /* NOT REACHED */ } return 0; /* NOT REACHED */ }
int main(void) { pid_t r; subtest = 1; #ifdef __GNUC__ printf("Test 52 (GCC) "); #else printf("Test 52 (ACK) "); #endif fflush(stdout); if (pipe(pipefdc) == -1) err(1); if (pipe(pipefdp) == -1) err(2); r = fork(); if(r < 0) { err(3); } else if(r == 0) { /* Child */ do_child(); } else { /* Parent */ do_parent(); } return(0); /* Never reached */ }
int main(int argc, char** argv) { // We need to keep the original parameters in order to pass them to the // model-checked process: int argc_copy = argc; char** argv_copy = argvdup(argc, argv); xbt_log_init(&argc_copy, argv_copy); sg_config_init(&argc_copy, argv_copy); if (argc < 2) xbt_die("Missing arguments.\n"); bool server_mode = true; char* env = std::getenv("SIMGRID_MC_MODE"); if (env) { if (std::strcmp(env, "server") == 0) server_mode = true; else if (std::strcmp(env, "standalone") == 0) server_mode = false; else xbt_die("Unrecognised value for SIMGRID_MC_MODE (server/standalone)"); } if (!server_mode) { setenv(MC_ENV_VARIABLE, "1", 1); execvp(argv[1], argv+1); std::perror("simgrid-mc"); return 127; } // Create a AF_LOCAL socketpair: int res; int sockets[2]; res = socketpair(AF_LOCAL, SOCK_DGRAM | SOCK_CLOEXEC, 0, sockets); if (res == -1) { perror("simgrid-mc"); return MC_SERVER_ERROR; } XBT_DEBUG("Created socketpair"); pid_t pid = fork(); if (pid < 0) { perror("simgrid-mc"); return MC_SERVER_ERROR; } else if (pid == 0) { close(sockets[1]); return do_child(sockets[0], argv); } else { close(sockets[0]); return do_parent(sockets[1], pid); } return 0; }
/** * Fork/exec the specified processes */ static int fork_local_proc(orte_app_context_t* context, orte_odls_child_t *child, char **environ_copy, orte_odls_job_t *jobdat) { orte_iof_base_io_conf_t opts; int rc, p[2]; pid_t pid; /* we do not forward io, so mark it as complete */ child->iof_complete = true; /* A pipe is used to communicate between the parent and child to indicate whether the exec ultimately succeeded or failed. The child sets the pipe to be close-on-exec; the child only ever writes anything to the pipe if there is an error (e.g., executable not found, exec() fails, etc.). The parent does a blocking read on the pipe; if the pipe closed with no data, then the exec() succeeded. If the parent reads something from the pipe, then the child was letting us know why it failed. */ if (pipe(p) < 0) { ORTE_ERROR_LOG(ORTE_ERR_SYS_LIMITS_PIPES); if (NULL != child) { child->state = ORTE_PROC_STATE_FAILED_TO_START; child->exit_code = ORTE_ERR_SYS_LIMITS_PIPES; } return ORTE_ERR_SYS_LIMITS_PIPES; } /* Fork off the child */ pid = fork(); if (NULL != child) { child->pid = pid; } if (pid < 0) { ORTE_ERROR_LOG(ORTE_ERR_SYS_LIMITS_CHILDREN); if (NULL != child) { child->state = ORTE_PROC_STATE_FAILED_TO_START; child->exit_code = ORTE_ERR_SYS_LIMITS_CHILDREN; } return ORTE_ERR_SYS_LIMITS_CHILDREN; } if (pid == 0) { close(p[0]); do_child(context, child, environ_copy, jobdat, p[1], opts); /* Does not return */ } close(p[1]); return do_parent(context, child, environ_copy, jobdat, p[0], opts); }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { ACE_LOG_MSG->open (argv[0]); if (argc != 2) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("usage: %n input-file\n"), 1)); ACE_OS::exit (1); } ACE_FIFO_Recv fifo_reader (FIFO_NAME, O_RDONLY | O_CREAT, PERMS, 0); if (fifo_reader.get_handle () == ACE_INVALID_HANDLE) return -1; pid_t child_pid = ACE_OS::fork (); switch (child_pid) { case -1: ACE_ERROR ((LM_ERROR, ACE_TEXT ("%n: %p\n%a"), ACE_TEXT ("fork"), 1)); case 0: if (do_child (fifo_reader) == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("%n: %p\n%a"), ACE_TEXT ("do_child"), 1)); default: if (do_parent (FIFO_NAME, argv[1]) == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("%n: %p\n%a"), ACE_TEXT ("do_parent"), 1)); // wait for child to ACE_OS::exit. if (ACE_OS::waitpid (child_pid, (ACE_exitcode *) 0, 0) == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("%n: %p\n%a"), ACE_TEXT ("waitpid"), 1)); } return 0; }
/** * Fork/exec the specified processes */ static int odls_alps_fork_local_proc(void *cdptr) { orte_odls_spawn_caddy_t *cd = (orte_odls_spawn_caddy_t*)cdptr; int p[2]; pid_t pid; /* A pipe is used to communicate between the parent and child to indicate whether the exec ultimately succeeded or failed. The child sets the pipe to be close-on-exec; the child only ever writes anything to the pipe if there is an error (e.g., executable not found, exec() fails, etc.). The parent does a blocking read on the pipe; if the pipe closed with no data, then the exec() succeeded. If the parent reads something from the pipe, then the child was letting us know why it failed. */ if (pipe(p) < 0) { ORTE_ERROR_LOG(ORTE_ERR_SYS_LIMITS_PIPES); if (NULL != cd->child) { cd->child->state = ORTE_PROC_STATE_FAILED_TO_START; cd->child->exit_code = ORTE_ERR_SYS_LIMITS_PIPES; } return ORTE_ERR_SYS_LIMITS_PIPES; } /* Fork off the child */ pid = fork(); if (NULL != cd->child) { cd->child->pid = pid; } if (pid < 0) { ORTE_ERROR_LOG(ORTE_ERR_SYS_LIMITS_CHILDREN); if (NULL != cd->child) { cd->child->state = ORTE_PROC_STATE_FAILED_TO_START; cd->child->exit_code = ORTE_ERR_SYS_LIMITS_CHILDREN; } return ORTE_ERR_SYS_LIMITS_CHILDREN; } if (pid == 0) { close(p[0]); #if HAVE_SETPGID setpgid(0, 0); #endif do_child(cd, p[1]); /* Does not return */ } close(p[1]); return do_parent(cd, p[0]); }
static atf_error_t fork_with_streams(atf_process_child_t *c, void (*start)(void *), const atf_process_stream_t *outsb, const atf_process_stream_t *errsb, void *v) { atf_error_t err; stream_prepare_t outsp; stream_prepare_t errsp; pid_t pid; err = stream_prepare_init(&outsp, outsb); if (atf_is_error(err)) goto out; err = stream_prepare_init(&errsp, errsb); if (atf_is_error(err)) goto err_outpipe; pid = fork(); if (pid == -1) { err = atf_libc_error(errno, "Failed to fork"); goto err_errpipe; } if (pid == 0) { do_child(start, v, &outsp, &errsp); UNREACHABLE; abort(); err = atf_no_error(); } else { err = do_parent(c, pid, &outsp, &errsp); if (atf_is_error(err)) goto err_errpipe; } goto out; err_errpipe: stream_prepare_fini(&errsp); err_outpipe: stream_prepare_fini(&outsp); out: return err; }
int main(int argc, char** argv) { setup_shared_port(); pid_t child_pid = fork(); if (child_pid == -1) { FAIL("forking"); } if (child_pid == 0) { mach_port_t shared_port_child = recover_shared_port_child(); do_child(shared_port_child); } else { mach_port_t shared_port_parent = recover_shared_port_parent(); mach_port_t child_task_port = do_parent(shared_port_parent); sploit(child_pid, child_task_port); } return 0; }
int main(int argc, char** argv) { int done = 0; kern_return_t err; mach_port_t exception_port = MACH_PORT_NULL; err = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &exception_port); if (err != KERN_SUCCESS) { printf("[-] failed to allocate port\n"); return 1; } err = mach_port_insert_right(mach_task_self(), exception_port, exception_port, MACH_MSG_TYPE_MAKE_SEND); if (err != KERN_SUCCESS) { printf("[-] failed to insert send right\n"); return 1; } while (!done) { setup_shared_port(); pid_t child_pid = fork(); if (child_pid == -1) { FAIL("forking"); } if (child_pid == 0) { mach_port_t shared_port_child = recover_shared_port_child(); do_child(shared_port_child); sploit_child(); } else { mach_port_t shared_port_parent = recover_shared_port_parent(); mach_port_t child_task_port = do_parent(shared_port_parent); done = sploit_parent(child_task_port, exception_port); int sl; wait(&sl); } } mach_port_destroy(mach_task_self(), exception_port); return 0; }
int main(int argc, char **argv) { if (argc != 1) err_quit("usage: qlen"); Socketpair(AF_UNIX, SOCK_STREAM, 0, pipefd); bzero(&serv, sizeof(serv)); serv.sin_family = AF_INET; serv.sin_port = htons(PORT); Inet_pton(AF_INET, ADDR, &serv.sin_addr); if ( (pid = Fork()) == 0) do_child(); else do_parent(); exit(0); }
int main(void) { // index array int x = 0; // semaphore stuff emptysem = semget(IPC_PRIVATE,1,SEMPERM|IPC_CREAT|IPC_EXCL); empty.val = 0; rc1 = semctl (emptysem_id, 0, SETVAL, empty); fullsem = semget(IPC_PRIVATE,1,SEMPERM|IPC_CREAT|IPC_EXCL); full.val = initialization value; rc2 = semctl (fullsem_id, 0, SETVAL, full); mutexsem = semget(IPC_PRIVATE,1,SEMPERM|IPC_CREAT|IPC_EXCL); mutex.val = 1; rc3 = semctl (mutexsem_id, 0, SETVAL, mutex); //request segment segid = shmget(IPC_PRIVATE,SIZE,IPC_CREAT | IPC_EXCL | SHMPERM); //check system call return if(segid<0) { perror(strerror(errno)); exit(1); } //fill array for(x = 0 ; x < MAX ; x+=1) {data[x] = x;} //spawn child process retcheck = fork(); //Begin consumer/producer by retcheck if(retcheck == 0) {do_child();} else { retcheck == fork(); if (retcheck == 0) {do child2()}; else do_parent(); }
int main(int argc, char *argv[]) { int ptys[2]; int retval; int pid; if(openpty(&ptys[0], &ptys[1], name, NULL, NULL) < 0) { perror("openpty"); return 1; } printf("Using %s\n", name); pid = fork(); if (pid == -1) { fprintf(stderr, "Error forking\n"); exit(-1); } if (pid == 0) /* child proc */ do_child(ptys); else do_parent(ptys); /* not reached */ return 0; }
int main(void) { pid_t pid; if (pipe(pipe_parent) < 0) err_sys("pipe error"); if (pipe(pipe_child) < 0) err_sys("pipe error"); if ((pid = fork()) < 0) err_sys("fork error"); else if (pid > 0) { /* parent */ close(pipe_parent[0]); /* close read end of pipe */ close(pipe_child[1]); /* close write end of pipe */ do_parent(); } else { /* child */ close(pipe_parent[1]); /* close write end of pipe */ close(pipe_child[0]); /* close read end of pipe */ do_child(); } exit(EXIT_SUCCESS); }
int main(void) { pid_t r; subtest = 1; start(52); if (pipe(pipefdc) == -1) err(1); if (pipe(pipefdp) == -1) err(2); r = fork(); if(r < 0) { err(3); } else if(r == 0) { /* Child */ do_child(); } else { /* Parent */ do_parent(); } return(0); /* Never reached */ }
void test(parent_exit_t parent_exit_time, debugger_exit_t debugger_exit_time) { pid_t parent, child, debugger; int ret; int fds[2]; /* pipe for parent to send child pid to grandparent */ ret = pipe(fds); if (-1 == ret) { err(1, "failed to create pipe"); } parent = fork(); if (parent == 0) { /* parent sub-branch */ ret = close(fds[0]); if (ret == -1) { err(1, "close read end of pipe"); } child = fork(); if (child == 0) { /* child */ ret = close(fds[1]); if (ret == -1) { err(1, "close write end of pipe"); } do_child(); } else if (child == -1) { err(1, "parent failed to fork child"); } else { /* parent */ if (-1 == write(fds[1], &child, sizeof(child))) { err(1, "writing child pid to grandparent"); } if (parent_exit_time == eParentIsDebugger) { debugger = -1; if (-1 == write(fds[1], &debugger, sizeof(debugger))) { err(1, "writing debugger pid to grandparent"); } ret = close(fds[1]); if (ret == -1) { err(1, "close write end of pipe"); } do_debugger(child, debugger_exit_time); } else { debugger = fork(); if (debugger == 0) { /* debugger */ ret = close(fds[1]); if (ret == -1) { err(1, "close write end of pipe"); } do_debugger(child, debugger_exit_time); } else if (debugger == -1) { err(1, "parent failed to fork debugger"); } else { /* still parent */ if (-1 == write(fds[1], &debugger, sizeof(debugger))) { err(1, "writing debugger pid to grandparent"); } ret = close(fds[1]); if (ret == -1) { err(1, "close write end of pipe"); } do_parent(child, debugger, parent_exit_time, debugger_exit_time); } } } } else if (parent == -1) { err(1, "grandparent failed to fork parent"); } else { ret = close(fds[1]); if (ret == -1) { err(1, "close write end of pipe"); } if (-1 == read(fds[0], &child, sizeof(child))) { err(1, "could not read child pid"); } if (-1 == read(fds[0], &debugger, sizeof(debugger))) { err(1, "could not read debugger pid"); } ret = close(fds[0]); if (ret == -1) { err(1, "close read end of pipe"); } do_grandparent(parent, child, debugger, debugger_exit_time); } }
/** * Fork/exec the specified processes */ static int odls_default_fork_local_proc(orte_app_context_t* context, orte_proc_t *child, char **environ_copy, orte_job_t *jobdat) { orte_iof_base_io_conf_t opts; int rc, p[2]; pid_t pid; if (NULL != child) { /* should pull this information from MPIRUN instead of going with default */ opts.usepty = OPAL_ENABLE_PTY_SUPPORT; /* do we want to setup stdin? */ if (NULL != child && (jobdat->stdin_target == ORTE_VPID_WILDCARD || child->name.vpid == jobdat->stdin_target)) { opts.connect_stdin = true; } else { opts.connect_stdin = false; } if (ORTE_SUCCESS != (rc = orte_iof_base_setup_prefork(&opts))) { ORTE_ERROR_LOG(rc); if (NULL != child) { child->state = ORTE_PROC_STATE_FAILED_TO_START; child->exit_code = rc; } return rc; } } /* A pipe is used to communicate between the parent and child to indicate whether the exec ultimately succeeded or failed. The child sets the pipe to be close-on-exec; the child only ever writes anything to the pipe if there is an error (e.g., executable not found, exec() fails, etc.). The parent does a blocking read on the pipe; if the pipe closed with no data, then the exec() succeeded. If the parent reads something from the pipe, then the child was letting us know why it failed. */ if (pipe(p) < 0) { ORTE_ERROR_LOG(ORTE_ERR_SYS_LIMITS_PIPES); if (NULL != child) { child->state = ORTE_PROC_STATE_FAILED_TO_START; child->exit_code = ORTE_ERR_SYS_LIMITS_PIPES; } return ORTE_ERR_SYS_LIMITS_PIPES; } /* Fork off the child */ pid = fork(); if (NULL != child) { child->pid = pid; } if (pid < 0) { ORTE_ERROR_LOG(ORTE_ERR_SYS_LIMITS_CHILDREN); if (NULL != child) { child->state = ORTE_PROC_STATE_FAILED_TO_START; child->exit_code = ORTE_ERR_SYS_LIMITS_CHILDREN; } return ORTE_ERR_SYS_LIMITS_CHILDREN; } if (pid == 0) { close(p[0]); #if HAVE_SETPGID setpgid(0, 0); #endif do_child(context, child, environ_copy, jobdat, p[1], opts); /* Does not return */ } close(p[1]); return do_parent(context, child, environ_copy, jobdat, p[0], opts); }