int uv__close(int fd) { assert(fd > STDERR_FILENO); /* Catch stdio close bugs. */ #if defined(__MVS__) SAVE_ERRNO(epoll_file_close(fd)); #endif return uv__close_nocheckstdio(fd); }
int uv__close(int fd) { assert(fd > STDERR_FILENO); /* Catch stdio close bugs. */ return uv__close_nocheckstdio(fd); }
static ssize_t uv__fs_copyfile(uv_fs_t* req) { #if defined(__APPLE__) && !TARGET_OS_IPHONE /* On macOS, use the native copyfile(3). */ copyfile_flags_t flags; flags = COPYFILE_ALL; if (req->flags & UV_FS_COPYFILE_EXCL) flags |= COPYFILE_EXCL; #ifdef COPYFILE_CLONE if (req->flags & UV_FS_COPYFILE_FICLONE) flags |= COPYFILE_CLONE; #endif if (req->flags & UV_FS_COPYFILE_FICLONE_FORCE) { #ifdef COPYFILE_CLONE_FORCE flags |= COPYFILE_CLONE_FORCE; #else return UV_ENOSYS; #endif } return copyfile(req->path, req->new_path, NULL, flags); #else uv_fs_t fs_req; uv_file srcfd; uv_file dstfd; struct stat statsbuf; int dst_flags; int result; int err; size_t bytes_to_send; int64_t in_offset; dstfd = -1; err = 0; /* Open the source file. */ srcfd = uv_fs_open(NULL, &fs_req, req->path, O_RDONLY, 0, NULL); uv_fs_req_cleanup(&fs_req); if (srcfd < 0) return srcfd; /* Get the source file's mode. */ if (fstat(srcfd, &statsbuf)) { err = UV__ERR(errno); goto out; } dst_flags = O_WRONLY | O_CREAT | O_TRUNC; if (req->flags & UV_FS_COPYFILE_EXCL) dst_flags |= O_EXCL; /* Open the destination file. */ dstfd = uv_fs_open(NULL, &fs_req, req->new_path, dst_flags, statsbuf.st_mode, NULL); uv_fs_req_cleanup(&fs_req); if (dstfd < 0) { err = dstfd; goto out; } if (fchmod(dstfd, statsbuf.st_mode) == -1) { err = UV__ERR(errno); goto out; } #ifdef FICLONE if (req->flags & UV_FS_COPYFILE_FICLONE || req->flags & UV_FS_COPYFILE_FICLONE_FORCE) { if (ioctl(dstfd, FICLONE, srcfd) == -1) { /* If an error occurred that the sendfile fallback also won't handle, or this is a force clone then exit. Otherwise, fall through to try using sendfile(). */ if (errno != ENOTTY && errno != EOPNOTSUPP && errno != EXDEV) { err = UV__ERR(errno); goto out; } else if (req->flags & UV_FS_COPYFILE_FICLONE_FORCE) { err = UV_ENOTSUP; goto out; } } else { goto out; } } #else if (req->flags & UV_FS_COPYFILE_FICLONE_FORCE) { err = UV_ENOSYS; goto out; } #endif bytes_to_send = statsbuf.st_size; in_offset = 0; while (bytes_to_send != 0) { err = uv_fs_sendfile(NULL, &fs_req, dstfd, srcfd, in_offset, bytes_to_send, NULL); uv_fs_req_cleanup(&fs_req); if (err < 0) break; bytes_to_send -= fs_req.result; in_offset += fs_req.result; } out: if (err < 0) result = err; else result = 0; /* Close the source file. */ err = uv__close_nocheckstdio(srcfd); /* Don't overwrite any existing errors. */ if (err != 0 && result == 0) result = err; /* Close the destination file if it is open. */ if (dstfd >= 0) { err = uv__close_nocheckstdio(dstfd); /* Don't overwrite any existing errors. */ if (err != 0 && result == 0) result = err; /* Remove the destination file if something went wrong. */ if (result != 0) { uv_fs_unlink(NULL, &fs_req, req->new_path, NULL); /* Ignore the unlink return value, as an error already happened. */ uv_fs_req_cleanup(&fs_req); } } if (result == 0) return 0; errno = UV__ERR(result); return -1; #endif }
static ssize_t uv__fs_copyfile(uv_fs_t* req) { #if defined(__APPLE__) && !TARGET_OS_IPHONE /* On macOS, use the native copyfile(3). */ copyfile_flags_t flags; flags = COPYFILE_ALL; if (req->flags & UV_FS_COPYFILE_EXCL) flags |= COPYFILE_EXCL; return copyfile(req->path, req->new_path, NULL, flags); #else uv_fs_t fs_req; uv_file srcfd; uv_file dstfd; struct stat statsbuf; int dst_flags; int result; int err; size_t bytes_to_send; int64_t in_offset; dstfd = -1; err = 0; /* Open the source file. */ srcfd = uv_fs_open(NULL, &fs_req, req->path, O_RDONLY, 0, NULL); uv_fs_req_cleanup(&fs_req); if (srcfd < 0) return srcfd; /* Get the source file's mode. */ if (fstat(srcfd, &statsbuf)) { err = -errno; goto out; } dst_flags = O_WRONLY | O_CREAT | O_TRUNC; if (req->flags & UV_FS_COPYFILE_EXCL) dst_flags |= O_EXCL; /* Open the destination file. */ dstfd = uv_fs_open(NULL, &fs_req, req->new_path, dst_flags, statsbuf.st_mode, NULL); uv_fs_req_cleanup(&fs_req); if (dstfd < 0) { err = dstfd; goto out; } if (fchmod(dstfd, statsbuf.st_mode) == -1) { err = -errno; goto out; } bytes_to_send = statsbuf.st_size; in_offset = 0; while (bytes_to_send != 0) { err = uv_fs_sendfile(NULL, &fs_req, dstfd, srcfd, in_offset, bytes_to_send, NULL); uv_fs_req_cleanup(&fs_req); if (err < 0) break; bytes_to_send -= fs_req.result; in_offset += fs_req.result; } out: if (err < 0) result = err; else result = 0; /* Close the source file. */ err = uv__close_nocheckstdio(srcfd); /* Don't overwrite any existing errors. */ if (err != 0 && result == 0) result = err; /* Close the destination file if it is open. */ if (dstfd >= 0) { err = uv__close_nocheckstdio(dstfd); /* Don't overwrite any existing errors. */ if (err != 0 && result == 0) result = err; /* Remove the destination file if something went wrong. */ if (result != 0) { uv_fs_unlink(NULL, &fs_req, req->new_path, NULL); /* Ignore the unlink return value, as an error already happened. */ uv_fs_req_cleanup(&fs_req); } } return result; #endif }
int uv_spawn(uv_loop_t* loop, uv_process_t* process, const uv_process_options_t* options) { #if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH) /* fork is marked __WATCHOS_PROHIBITED __TVOS_PROHIBITED. */ return UV_ENOSYS; #else int signal_pipe[2] = { -1, -1 }; int pipes_storage[8][2]; int (*pipes)[2]; int stdio_count; ssize_t r; pid_t pid; int err; int exec_errorno; int i; int status; if (options->cpumask != NULL) { #if defined(__linux__) || defined(__FreeBSD__) if (options->cpumask_size < (size_t)uv_cpumask_size()) { return UV_EINVAL; } #else return UV_ENOTSUP; #endif } assert(options->file != NULL); assert(!(options->flags & ~(UV_PROCESS_DETACHED | UV_PROCESS_SETGID | UV_PROCESS_SETUID | UV_PROCESS_WINDOWS_HIDE | UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS))); uv__handle_init(loop, (uv_handle_t*)process, UV_PROCESS); QUEUE_INIT(&process->queue); stdio_count = options->stdio_count; if (stdio_count < 3) stdio_count = 3; err = UV_ENOMEM; pipes = pipes_storage; if (stdio_count > (int) ARRAY_SIZE(pipes_storage)) pipes = uv__malloc(stdio_count * sizeof(*pipes)); if (pipes == NULL) goto error; for (i = 0; i < stdio_count; i++) { pipes[i][0] = -1; pipes[i][1] = -1; } for (i = 0; i < options->stdio_count; i++) { err = uv__process_init_stdio(options->stdio + i, pipes[i]); if (err) goto error; } /* This pipe is used by the parent to wait until * the child has called `execve()`. We need this * to avoid the following race condition: * * if ((pid = fork()) > 0) { * kill(pid, SIGTERM); * } * else if (pid == 0) { * execve("/bin/cat", argp, envp); * } * * The parent sends a signal immediately after forking. * Since the child may not have called `execve()` yet, * there is no telling what process receives the signal, * our fork or /bin/cat. * * To avoid ambiguity, we create a pipe with both ends * marked close-on-exec. Then, after the call to `fork()`, * the parent polls the read end until it EOFs or errors with EPIPE. */ err = uv__make_pipe(signal_pipe, 0); if (err) goto error; uv_signal_start(&loop->child_watcher, uv__chld, SIGCHLD); /* Acquire write lock to prevent opening new fds in worker threads */ uv_rwlock_wrlock(&loop->cloexec_lock); pid = fork(); if (pid == -1) { err = UV__ERR(errno); uv_rwlock_wrunlock(&loop->cloexec_lock); uv__close(signal_pipe[0]); uv__close(signal_pipe[1]); goto error; } if (pid == 0) { uv__process_child_init(options, stdio_count, pipes, signal_pipe[1]); abort(); } /* Release lock in parent process */ uv_rwlock_wrunlock(&loop->cloexec_lock); uv__close(signal_pipe[1]); process->status = 0; exec_errorno = 0; do r = read(signal_pipe[0], &exec_errorno, sizeof(exec_errorno)); while (r == -1 && errno == EINTR); if (r == 0) ; /* okay, EOF */ else if (r == sizeof(exec_errorno)) { do err = waitpid(pid, &status, 0); /* okay, read errorno */ while (err == -1 && errno == EINTR); assert(err == pid); } else if (r == -1 && errno == EPIPE) { do err = waitpid(pid, &status, 0); /* okay, got EPIPE */ while (err == -1 && errno == EINTR); assert(err == pid); } else abort(); uv__close_nocheckstdio(signal_pipe[0]); for (i = 0; i < options->stdio_count; i++) { err = uv__process_open_stream(options->stdio + i, pipes[i]); if (err == 0) continue; while (i--) uv__process_close_stream(options->stdio + i); goto error; } /* Only activate this handle if exec() happened successfully */ if (exec_errorno == 0) { QUEUE_INSERT_TAIL(&loop->process_handles, &process->queue); uv__handle_start(process); } process->pid = pid; process->exit_cb = options->exit_cb; if (pipes != pipes_storage) uv__free(pipes); return exec_errorno; error: if (pipes != NULL) { for (i = 0; i < stdio_count; i++) { if (i < options->stdio_count) if (options->stdio[i].flags & (UV_INHERIT_FD | UV_INHERIT_STREAM)) continue; if (pipes[i][0] != -1) uv__close_nocheckstdio(pipes[i][0]); if (pipes[i][1] != -1) uv__close_nocheckstdio(pipes[i][1]); } if (pipes != pipes_storage) uv__free(pipes); } return err; #endif }