/* * Copyright (C) 2026 Linux Studio Plugins Project * (C) 2026 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 24 июл. 2019 г. * * lsp-runtime-lib is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * lsp-runtime-lib is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with lsp-runtime-lib. If not, see . */ #include #include #include #include #include #include #include #include #include #if defined(PLATFORM_WINDOWS) #include #include #include #include #include #include #else #include #include #include #ifndef _GNU_SOURCE extern char **environ; // Define environment variables #endif /* _GNU_SOURCE */ #endif /* PLATFORM_WINDOWS */ #if defined(PLATFORM_POSIX) && defined(_GNU_SOURCE) #define PLATFORM_HAS_EXECVPE #endif namespace lsp { namespace ipc { #if defined(PLATFORM_WINDOWS) || (!defined(PLATFORM_HAS_EXECVPE)) static status_t find_executable(LSPString & program, const LSPString & command) { if (command.index_of(FILE_SEPARATOR_C) >= 0) return STATUS_NOT_FOUND; // Lookup PATH LSPString path; status_t res = system::get_env_var("PATH", &path); if (res != STATUS_OK) return res; ssize_t start = 0, count = path.length(), found = 0; do { // Lookup for separator found = path.index_of(start, ';'); const ssize_t next = (found >= 0) ? found : count; if (start < next) { if (!program.set(&path, start, found)) return STATUS_NO_MEM; if (!program.ends_with(FILE_SEPARATOR_C)) { if (!program.append(FILE_SEPARATOR_C)) return STATUS_NO_MEM; } if (!program.append(&command)) return STATUS_NO_MEM; #ifdef PLATFORM_WINDOWS if (PathFileExistsW(program.get_utf16())) return STATUS_OK; // Try .EXE and .COM extensions if ((!program.ends_with_ascii_nocase(".exe")) && (!program.ends_with_ascii_nocase(".com"))) { // Try ".EXE" if (!program.append_ascii(".exe")) return STATUS_NO_MEM; if (PathFileExistsW(program.get_utf16())) return STATUS_OK; // Try ".COM" program.set_length(program.length() - 4); if (!program.append_ascii(".com")) return STATUS_NO_MEM; if (PathFileExistsW(program.get_utf16())) return STATUS_OK; } #else struct stat st; if (stat(program.get_native(), &st) == 0) { if (S_ISREG(st.st_mode) && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) return STATUS_OK; } #endif /* PLATFORM_WINDOWS */ } start = found + 1; } while (found >= 0); return STATUS_NOT_FOUND; } #endif /* PLATFORM_HAS_EXECPE */ Process::Process() { nStatus = PSTATUS_CREATED; nExitCode = 0; #ifdef PLATFORM_WINDOWS nPID = 0; hProcess = NULL; hStdIn = NULL; hStdOut = NULL; hStdErr = NULL; #else nPID = 0; hStdIn = -1; hStdOut = -1; hStdErr = -1; #endif pStdIn = NULL; pStdOut = NULL; pStdErr = NULL; if (copy_env() != STATUS_OK) nStatus = PSTATUS_ERROR; } Process::~Process() { destroy_args(&vArgs); destroy_env(&vEnv); close_handles(); if (pStdIn != NULL) { pStdIn->close(); delete pStdIn; pStdIn = NULL; } if (pStdOut != NULL) { pStdOut->close(); delete pStdOut; pStdOut = NULL; } if (pStdErr != NULL) { pStdErr->close(); delete pStdErr; pStdErr = NULL; } #ifdef PLATFORM_WINDOWS if (hProcess != NULL) { ::CloseHandle(hProcess); hProcess = NULL; } #endif /* PLATFORM_WINDOWS */ } void Process::destroy_args(lltl::parray *args) { for (size_t i=0, n=args->size(); iuget(i); args->flush(); } void Process::destroy_env(lltl::parray *env) { for (size_t i=0, n=env->size(); iuget(i); env->flush(); } status_t Process::set_command(const LSPString *cmd) { if (nStatus != PSTATUS_CREATED) return STATUS_BAD_STATE; if (cmd == NULL) { sCommand.clear(); return STATUS_OK; } return (sCommand.set(cmd)) ? STATUS_OK : STATUS_NO_MEM; } status_t Process::set_command(const char *cmd) { if (nStatus != PSTATUS_CREATED) return STATUS_BAD_STATE; if (cmd == NULL) { sCommand.clear(); return STATUS_OK; } return (sCommand.set_utf8(cmd)) ? STATUS_OK : STATUS_NO_MEM; } size_t Process::args() const { return vArgs.size(); } status_t Process::add_arg(const LSPString *value) { if (value == NULL) return STATUS_BAD_ARGUMENTS; if (nStatus != PSTATUS_CREATED) return STATUS_BAD_STATE; LSPString *arg = new LSPString(); if (arg == NULL) return STATUS_NO_MEM; if (!arg->set(value)) { delete arg; return STATUS_NO_MEM; } if (!vArgs.add(arg)) { delete arg; return STATUS_NO_MEM; } return STATUS_OK; } status_t Process::add_arg(const char *value) { if (value == NULL) return STATUS_BAD_ARGUMENTS; if (nStatus != PSTATUS_CREATED) return STATUS_BAD_STATE; LSPString *arg = new LSPString(); if (arg == NULL) return STATUS_NO_MEM; if (!arg->set_utf8(value)) { delete arg; return STATUS_NO_MEM; } if (!vArgs.add(arg)) { delete arg; return STATUS_NO_MEM; } return STATUS_OK; } status_t Process::set_arg(size_t index, const LSPString *value) { if (value == NULL) return STATUS_BAD_ARGUMENTS; if (nStatus != PSTATUS_CREATED) return STATUS_BAD_STATE; LSPString *ptr = vArgs.get(index); if (ptr == NULL) return STATUS_BAD_ARGUMENTS; return (ptr->set(value)) ? STATUS_OK : STATUS_NO_MEM; } status_t Process::set_arg(size_t index, const char *value) { if (value == NULL) return STATUS_BAD_ARGUMENTS; if (nStatus != PSTATUS_CREATED) return STATUS_BAD_STATE; LSPString *ptr = vArgs.get(index); if (ptr == NULL) return STATUS_BAD_ARGUMENTS; return (ptr->set_utf8(value)) ? STATUS_OK : STATUS_NO_MEM; } status_t Process::get_arg(size_t index, LSPString *value) { LSPString *ptr = vArgs.get(index); if (ptr == NULL) return STATUS_BAD_ARGUMENTS; if (value == NULL) return STATUS_OK; return (value->set(ptr)) ? STATUS_OK : STATUS_NO_MEM; } status_t Process::get_arg(size_t index, char **value) { LSPString *ptr = vArgs.get(index); if (ptr == NULL) return STATUS_BAD_ARGUMENTS; if (value == NULL) return STATUS_OK; char *dup = ptr->clone_utf8(); if (dup == NULL) return STATUS_NO_MEM; *value = dup; return STATUS_OK; } status_t Process::remove_arg(size_t index, LSPString *value) { if (nStatus != PSTATUS_CREATED) return STATUS_BAD_STATE; LSPString *ptr = vArgs.get(index); if (ptr == NULL) return STATUS_BAD_ARGUMENTS; if (value != NULL) value->swap(ptr); vArgs.remove(index); delete ptr; return STATUS_OK; } status_t Process::remove_arg(size_t index, char **value) { if (nStatus != PSTATUS_CREATED) return STATUS_BAD_STATE; LSPString *ptr = vArgs.get(index); if (ptr == NULL) return STATUS_BAD_ARGUMENTS; if (value != NULL) { char *dup = ptr->clone_utf8(); if (dup == NULL) return STATUS_NO_MEM; *value = dup; } vArgs.remove(index); delete ptr; return STATUS_OK; } status_t Process::insert_arg(size_t index, const LSPString *value) { if (nStatus != PSTATUS_CREATED) return STATUS_BAD_STATE; if (value == NULL) return STATUS_BAD_ARGUMENTS; LSPString *arg = new LSPString(); if (arg == NULL) return STATUS_NO_MEM; if ((!arg->set(value)) || (!vArgs.insert(index, arg))) { delete arg; return STATUS_NO_MEM; } return STATUS_OK; } status_t Process::insert_arg(size_t index, const char *value) { if (nStatus != PSTATUS_CREATED) return STATUS_BAD_STATE; if (value == NULL) return STATUS_BAD_ARGUMENTS; LSPString *arg = new LSPString(); if (arg == NULL) return STATUS_NO_MEM; if ((!arg->set_utf8(value)) || (!vArgs.insert(index, arg))) { delete arg; return STATUS_NO_MEM; } return STATUS_OK; } status_t Process::clear_args() { if (nStatus != PSTATUS_CREATED) return STATUS_BAD_STATE; destroy_args(&vArgs); return STATUS_OK; } size_t Process::envs() const { return vEnv.size(); } status_t Process::set_env(const LSPString *key, const LSPString *value) { if (nStatus != PSTATUS_CREATED) return STATUS_BAD_STATE; if ((key == NULL) || (value == NULL)) return STATUS_BAD_ARGUMENTS; if (key->index_of('=') >= 0) return STATUS_BAD_FORMAT; envvar_t *var; for (size_t i=0, n=vEnv.size(); iname.equals(key)) return (var->value.set(value)) ? STATUS_OK : STATUS_NO_MEM; } if ((var = new envvar_t) == NULL) return STATUS_NO_MEM; if ((!var->name.set(key)) || (!var->value.set(value)) || (!vEnv.add(var))) { delete var; return STATUS_NO_MEM; } return STATUS_OK; } status_t Process::set_env(const char *key, const char *value) { if (nStatus != PSTATUS_CREATED) return STATUS_BAD_STATE; if ((key == NULL) || (value == NULL)) return STATUS_BAD_ARGUMENTS; if (strchr(key, '=') != NULL) return STATUS_BAD_FORMAT; LSPString k, v; if ((!k.set_utf8(key)) || (!v.set_utf8(value))) return STATUS_NO_MEM; return set_env(&k, &v); } status_t Process::remove_env(const LSPString *key, LSPString *value) { if (nStatus != PSTATUS_CREATED) return STATUS_BAD_STATE; if (key == NULL) return STATUS_BAD_ARGUMENTS; for (size_t i=0, n=vEnv.size(); iname.equals(key)) { if (value != NULL) value->swap(&var->value); delete var; vEnv.qremove(i); return STATUS_OK; } } return STATUS_NOT_FOUND; } status_t Process::remove_env(const char *key, char **value) { if (nStatus != PSTATUS_CREATED) return STATUS_BAD_STATE; if (key == NULL) return STATUS_BAD_ARGUMENTS; LSPString k; if (!k.set_utf8(key)) return STATUS_NO_MEM; for (size_t i=0, n=vEnv.size(); iname.equals(&k)) { if (value != NULL) { char *dup = var->value.clone_utf8(); if (dup == NULL) return STATUS_NO_MEM; *value = dup; } delete var; vEnv.qremove(i); return STATUS_OK; } } return STATUS_NOT_FOUND; } status_t Process::remove_env(const char *key, LSPString *value) { if (nStatus != PSTATUS_CREATED) return STATUS_BAD_STATE; if (key == NULL) return STATUS_BAD_ARGUMENTS; LSPString k; if (!k.set_utf8(key)) return STATUS_NO_MEM; for (size_t i=0, n=vEnv.size(); iname.equals(&k)) continue; if (value != NULL) value->swap(&var->value); delete var; vEnv.qremove(i); return STATUS_OK; } return STATUS_NOT_FOUND; } status_t Process::get_env(const LSPString *key, LSPString *value) { if (key == NULL) return STATUS_BAD_ARGUMENTS; if (nStatus != PSTATUS_CREATED) return STATUS_BAD_STATE; for (size_t i=0, n=vEnv.size(); iname.equals(key)) continue; if (value != NULL) { if (!value->set(&var->value)) return STATUS_NO_MEM; } return STATUS_OK; } return STATUS_NOT_FOUND; } status_t Process::get_env(const char *key, LSPString *value) { if (key == NULL) return STATUS_BAD_ARGUMENTS; LSPString k; if (!k.set_utf8(key)) return STATUS_NO_MEM; for (size_t i=0, n=vEnv.size(); iname.equals(&k)) continue; if (value != NULL) { if (!value->set(&var->value)) return STATUS_NO_MEM; } return STATUS_OK; } return STATUS_NOT_FOUND; } status_t Process::get_env(const char *key, char **value) { if (key == NULL) return STATUS_BAD_ARGUMENTS; LSPString k; if (!k.set_utf8(key)) return STATUS_NO_MEM; for (size_t i=0, n=vEnv.size(); iname.equals(&k)) continue; if (value != NULL) { char *dup = var->value.clone_utf8(); if (dup == NULL) return STATUS_NO_MEM; *value = dup; } return STATUS_OK; } return STATUS_NOT_FOUND; } status_t Process::read_env(size_t idx, LSPString *key, LSPString *value) { if ((key == NULL) && (value == NULL)) return STATUS_BAD_ARGUMENTS; envvar_t *var = vEnv.get(idx); if (var == NULL) return STATUS_BAD_ARGUMENTS; LSPString tk, tv; if (key != NULL) { if (!tk.set(&var->name)) return STATUS_NO_MEM; if (value != NULL) { if (!tv.set(&var->value)) return STATUS_NO_MEM; value->swap(&tv); } key->swap(&tk); return STATUS_OK; } if (!tv.set(&var->value)) return STATUS_NO_MEM; value->swap(&tv); return STATUS_OK; } status_t Process::read_env(size_t idx, char **key, char **value) { if ((key == NULL) && (value == NULL)) return STATUS_BAD_ARGUMENTS; envvar_t *var = vEnv.get(idx); if (var == NULL) return STATUS_BAD_ARGUMENTS; char *tk, *tv; if (key != NULL) { if ((tk = var->name.clone_utf8()) == NULL) return STATUS_NO_MEM; if (value != NULL) { if ((tv = var->value.clone_utf8()) == NULL) { ::free(tk); return STATUS_NO_MEM; } *value = tv; } *key = tk; return STATUS_OK; } if ((tv = var->value.clone_utf8()) == NULL) return STATUS_NO_MEM; *value = tv; return STATUS_OK; } status_t Process::clear_env() { if (nStatus != PSTATUS_CREATED) return STATUS_BAD_STATE; destroy_env(&vEnv); return STATUS_OK; } size_t Process::status() { wait(0); // Try to update status return nStatus; } bool Process::exited() { return status() == PSTATUS_EXITED; } bool Process::running() { if (nStatus == PSTATUS_RUNNING_ERROR) return true; return status() == PSTATUS_RUNNING; } bool Process::valid() { return status() != PSTATUS_ERROR; } ssize_t Process::process_id() const { switch (nStatus) { case PSTATUS_RUNNING: case PSTATUS_EXITED: return nPID; default: break; } return -1; } status_t Process::exit_code(int *code) { if (code == NULL) return STATUS_BAD_ARGUMENTS; if (nStatus != PSTATUS_EXITED) return STATUS_BAD_STATE; *code = nExitCode; return STATUS_OK; } #ifdef PLATFORM_WINDOWS status_t Process::append_arg_escaped(LSPString *dst, const LSPString *value) { if (value->is_empty()) return (dst->append_ascii("\"\"")) ? STATUS_OK : STATUS_NO_MEM; for (size_t i=0, n=value->length(); ichar_at(i); switch (ch) { case ' ': if (!dst->append_ascii("\" \"", 3)) return STATUS_NO_MEM; break; case '"': if (!dst->append_ascii("\\\"", 2)) return STATUS_NO_MEM; break; default: if (!dst->append(ch)) return STATUS_NO_MEM; break; } } return STATUS_OK; } status_t Process::build_argv(LSPString *dst) { status_t res = append_arg_escaped(dst, &sCommand); if (res != STATUS_OK) return res; for (size_t i=0, n=vArgs.size(); iappend(' ')) return STATUS_NO_MEM; res = append_arg_escaped(dst, arg); if (res != STATUS_OK) return res; } return STATUS_OK; } status_t Process::build_envp(LSPString *dst) { for (size_t i=0, n=vEnv.size(); iappend(&env->name)) return STATUS_NO_MEM; if (!dst->append('=')) return STATUS_NO_MEM; if (!dst->append(&env->value)) return STATUS_NO_MEM; if (!dst->append('\0')) return STATUS_NO_MEM; } // Note that an ANSI environment block is terminated by two zero bytes: // one for the last string, one more to terminate the block. A Unicode // environment block is terminated by four zero bytes: two for the last // string, two more to terminate the block. return (dst->append('\0')) ? STATUS_OK : STATUS_NO_MEM; } status_t Process::launch() { if (nStatus != PSTATUS_CREATED) return STATUS_BAD_STATE; if (sCommand.is_empty()) return STATUS_BAD_STATE; // Obtain the command string status_t res; LSPString xcmd; res = find_executable(xcmd, sCommand); if ((res != STATUS_OK) && (res != STATUS_NOT_FOUND)) return res; LSPString & program = (res == STATUS_OK) ? xcmd : sCommand; // Form argv and envp LSPString argv, envp; if ((res = build_argv(&argv)) != STATUS_OK) return res; if ((res = build_envp(&envp)) != STATUS_OK) return res; // Launch child process STARTUPINFOW si; PROCESS_INFORMATION pi; ZeroMemory( &si, sizeof(STARTUPINFOW) ); ZeroMemory( &pi, sizeof(PROCESS_INFORMATION) ); si.cb = sizeof(si); // Override STDIN, STDOUT, STDERR if (hStdIn != NULL) { si.dwFlags |= STARTF_USESTDHANDLES; si.hStdInput = hStdIn; } if (hStdOut != NULL) { si.dwFlags |= STARTF_USESTDHANDLES; si.hStdOutput = hStdOut; } if (hStdErr != NULL) { si.dwFlags |= STARTF_USESTDHANDLES; si.hStdError = hStdErr; } // Prepare buffers WCHAR *wargv = argv.clone_utf16(); if (wargv == NULL) return STATUS_NO_MEM; WCHAR *wenvp = envp.clone_utf16(); if (wenvp == NULL) { ::free(wargv); return STATUS_NO_MEM; } // Start the child process. if( !::CreateProcessW( program.get_utf16(), // Module name (use command line) wargv, // Command line NULL, // Process handle not inheritable NULL, // Thread handle not inheritable FALSE, // Set handle inheritance to FALSE CREATE_NEW_CONSOLE | CREATE_UNICODE_ENVIRONMENT, // Use unicode environment wenvp, // Set-up environment block NULL, // Use parent's starting directory &si, // Pointer to STARTUPINFO structure &pi // Pointer to PROCESS_INFORMATION structure )) { int error = ::GetLastError(); ::fprintf(stderr, "Failed to create child process (%d)\n", error); ::fflush(stderr); ::free(wenvp); ::free(wargv); nStatus = PSTATUS_RUNNING_ERROR; switch (error) { case ERROR_FILE_NOT_FOUND: case ERROR_PATH_NOT_FOUND: nExitCode = STATUS_NOT_FOUND; break; default: nExitCode = STATUS_UNKNOWN_ERR; break; } return res; } // Free resources and close redirected file handles ::free(wenvp); ::free(wargv); close_handles(); // Update state hProcess = pi.hProcess; nPID = pi.dwProcessId; nStatus = PSTATUS_RUNNING; return res; } status_t Process::wait(wssize_t millis) { // If we're simulating some process that failed to start as running, // then we need to update the status and just return. // Otherwise we need to reject any wait() request since process is in // bad state. if (nStatus == PSTATUS_RUNNING_ERROR) { nStatus = PSTATUS_EXITED; return STATUS_OK; } else if (nStatus != PSTATUS_RUNNING) return STATUS_BAD_STATE; // Wait for completion of the process DWORD res = ::WaitForSingleObject(hProcess, (millis < 0) ? INFINITE : millis); switch (res) { case WAIT_OBJECT_0: { // Obtain exit status of process DWORD code = 0; ::GetExitCodeProcess(hProcess, &code); ::CloseHandle(hProcess); hProcess = NULL; // Update state nStatus = PSTATUS_EXITED; nExitCode = code; return STATUS_OK; } case WAIT_TIMEOUT: return STATUS_OK; default: break; } return STATUS_UNKNOWN_ERR; } void Process::close_handles() { if (hStdIn != NULL) { ::CloseHandle(hStdIn); hStdIn = NULL; } if (hStdOut != NULL) { ::CloseHandle(hStdOut); hStdOut = NULL; } if (hStdErr != NULL) { ::CloseHandle(hStdErr); hStdErr = NULL; } } io::IOutStream *Process::get_stdin() { if ((nStatus != PSTATUS_CREATED) || (pStdIn != NULL)) return pStdIn; HANDLE hRead = NULL, hWrite = NULL; if (!::CreatePipe(&hRead, &hWrite, NULL, 0)) return NULL; // Create stream and wrap io::OutFileStream *strm = new io::OutFileStream(); if ((strm == NULL) || (strm->wrap_native(hWrite, true) != STATUS_OK)) { delete strm; ::CloseHandle(hRead); ::CloseHandle(hWrite); return NULL; } // All is OK pStdIn = strm; hStdIn = hRead; return pStdIn; } io::IInStream *Process::get_stdout() { if ((nStatus != PSTATUS_CREATED) || (pStdOut != NULL)) return pStdOut; HANDLE hRead = NULL, hWrite = NULL; if (!::CreatePipe(&hRead, &hWrite, NULL, 0)) return NULL; // Create stream and wrap io::InFileStream *strm = new io::InFileStream(); if ((strm == NULL) || (strm->wrap_native(hRead, true) != STATUS_OK)) { delete strm; ::CloseHandle(hRead); ::CloseHandle(hWrite); return NULL; } // All is OK pStdOut = strm; hStdOut = hWrite; return pStdOut; } io::IInStream *Process::get_stderr() { if ((nStatus != PSTATUS_CREATED) || (pStdErr != NULL)) return pStdErr; HANDLE hRead = NULL, hWrite = NULL; if (!::CreatePipe(&hRead, &hWrite, NULL, 0)) return NULL; // Create stream and wrap io::InFileStream *strm = new io::InFileStream(); if ((strm == NULL) || (strm->wrap_native(hRead, true) != STATUS_OK)) { delete strm; ::CloseHandle(hRead); ::CloseHandle(hWrite); return NULL; } // All is OK pStdErr = strm; hStdErr = hWrite; return pStdErr; } #else static void drop_data(lltl::parray *v) { for (size_t i=0, n=v->size(); iuget(i); if (ptr != NULL) ::free(ptr); } v->flush(); } void Process::close_handles() { if (hStdIn >= 0) { ::close(hStdIn); hStdIn = -1; } if (hStdOut >= 0) { ::close(hStdOut); hStdOut = -1; } if (hStdErr >= 0) { ::close(hStdErr); hStdErr = -1; } } status_t Process::build_argv(lltl::parray *dst) { char *s; // Add command as argv[0] if ((s = sCommand.clone_native()) == NULL) return STATUS_NO_MEM; if (!dst->add(s)) return STATUS_NO_MEM; // Add all other arguments for (size_t i=0, n=vArgs.size(); iclone_native()) == NULL) return STATUS_NO_MEM; if (!dst->add(s)) { ::free(s); return STATUS_NO_MEM; } } // Add terminator return (dst->add(static_cast(NULL))) ? STATUS_OK : STATUS_NO_MEM; } status_t Process::build_envp(lltl::parray *dst) { char *s; LSPString tmp; for (size_t i=0, n=vEnv.size(); iname)) return STATUS_NO_MEM; if (!tmp.append('=')) return STATUS_NO_MEM; if (!tmp.append(&var->value)) return STATUS_NO_MEM; if ((s = tmp.clone_native()) == NULL) return STATUS_NO_MEM; if (!dst->add(s)) { ::free(s); return STATUS_NO_MEM; } } return (dst->add(static_cast(NULL))) ? STATUS_OK : STATUS_NO_MEM; } status_t Process::spawn_process(const char *cmd, char * const *argv, char * const *envp) { lsp_trace("Creating child process using posix_spawn..."); // Initialize spawn routines posix_spawnattr_t attr; if (::posix_spawnattr_init(&attr)) return STATUS_UNKNOWN_ERR; #if defined(__USE_GNU) || defined(POSIX_SPAWN_USEVFORK) // Prever vfork() over fork() if (::posix_spawnattr_setflags(&attr, POSIX_SPAWN_USEVFORK)) { ::posix_spawnattr_destroy(&attr); return STATUS_UNKNOWN_ERR; } #endif /* __USE_GNU */ posix_spawn_file_actions_t actions; if (::posix_spawn_file_actions_init(&actions)) { ::posix_spawnattr_destroy(&attr); return STATUS_UNKNOWN_ERR; } // Override STDIN, STDOUT, STDERR if (hStdIn >= 0) { if (::posix_spawn_file_actions_adddup2(&actions, hStdIn, STDIN_FILENO)) { ::posix_spawnattr_destroy(&attr); return STATUS_UNKNOWN_ERR; } if (::posix_spawn_file_actions_addclose(&actions, hStdIn)) { ::posix_spawnattr_destroy(&attr); return STATUS_UNKNOWN_ERR; } } if (hStdOut >= 0) { if (::posix_spawn_file_actions_adddup2(&actions, hStdOut, STDOUT_FILENO)) { ::posix_spawnattr_destroy(&attr); return STATUS_UNKNOWN_ERR; } if (::posix_spawn_file_actions_addclose(&actions, hStdOut)) { ::posix_spawnattr_destroy(&attr); return STATUS_UNKNOWN_ERR; } } if (hStdErr >= 0) { if (::posix_spawn_file_actions_adddup2(&actions, hStdErr, STDERR_FILENO)) { ::posix_spawnattr_destroy(&attr); return STATUS_UNKNOWN_ERR; } if (::posix_spawn_file_actions_addclose(&actions, hStdErr)) { ::posix_spawnattr_destroy(&attr); return STATUS_UNKNOWN_ERR; } } // Perform posix_spawn() pid_t pid; status_t res = STATUS_OK; while (true) { int x = ::posix_spawnp(&pid, cmd, &actions, &attr, argv, envp); switch (x) { case 0: break; case EAGAIN: continue; case ENOMEM: res = STATUS_NO_MEM; break; default: res = STATUS_UNKNOWN_ERR; break; } break; } // Success execution? if (res == STATUS_OK) { nPID = pid; nStatus = PSTATUS_RUNNING; } ::posix_spawn_file_actions_destroy(&actions); ::posix_spawnattr_destroy(&attr); return res; } void Process::execvpe_process(const char *cmd, char * const *argv, char * const *envp, bool soft_exit) { // Override STDIN, STDOUT, STDERR if (hStdIn >= 0) { ::dup2(hStdIn, STDIN_FILENO); ::close(hStdIn); hStdIn = -1; } if (hStdOut >= 0) { ::dup2(hStdOut, STDOUT_FILENO); ::close(hStdOut); hStdOut = -1; } if (hStdErr >= 0) { ::dup2(hStdErr, STDERR_FILENO); ::close(hStdErr); hStdErr = -1; } // Launch the process #ifndef PLATFORM_HAS_EXECVPE ::execve(cmd, argv, envp); #else if (strchr(cmd, FILE_SEPARATOR_C) != NULL) ::execve(cmd, argv, envp); else ::execvpe(cmd, argv, envp); #endif /* PLATFORM_HAS_EXECVPE */ lsp_trace("exec failed for pid=%d\n", int(getpid())); // Return error only if ::execvpe failed if (soft_exit) ::_exit(STATUS_UNKNOWN_ERR); else ::exit(STATUS_UNKNOWN_ERR); } status_t Process::vfork_process(const char *cmd, char * const *argv, char * const *envp) { lsp_trace("Creating child process using vfork()..."); errno = 0; #ifdef PLATFORM_MACOSX #if defined(COMPILER_CLANG) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" #elif defined(COMPILER_GCC) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" #endif #endif /* PLATFORM_MACOSX */ // vfork() is deprecated in MacOS, we'll hide deprectation warning for that as // vfork() is a fallback case for posix_spawn. pid_t pid = ::vfork(); #ifdef PLATFORM_MACOSX #if defined(COMPILER_CLANG) #pragma clang diagnostic pop #elif defined(COMPILER_GCC) #pragma GCC diagnostic pop #endif #endif /* PLATFORM_MACOSX */ // Failed to fork()? if (pid < 0) { int code = errno; switch (code) { case ENOMEM: return STATUS_NO_MEM; case EAGAIN: return STATUS_NO_MEM; default: return STATUS_UNKNOWN_ERR; } } // The child process stuff if (pid == 0) execvpe_process(cmd, argv, envp, true); // The parent process stuff nPID = pid; nStatus = PSTATUS_RUNNING; return STATUS_OK; } status_t Process::fork_process(const char *cmd, char * const *argv, char * const *envp) { lsp_trace("Creating child process using fork()..."); errno = 0; pid_t pid = ::fork(); // Failed to fork()? if (pid < 0) { int code = errno; switch (code) { case ENOMEM: return STATUS_NO_MEM; case EAGAIN: return STATUS_NO_MEM; default: return STATUS_UNKNOWN_ERR; } } // The child process stuff if (pid == 0) execvpe_process(cmd, argv, envp, false); // The parent process stuff nPID = pid; nStatus = PSTATUS_RUNNING; return STATUS_OK; } status_t Process::launch() { if (nStatus != PSTATUS_CREATED) return STATUS_BAD_STATE; if (sCommand.is_empty()) return STATUS_BAD_STATE; status_t res; lltl::parray argv; lltl::parray envp; lsp_finally { drop_data(&argv); drop_data(&envp); }; // Make execution command #ifndef PLATFORM_HAS_EXECVPE LSPString xcmd; res = find_executable(xcmd, sCommand); if ((res != STATUS_OK) && (res != STATUS_NOT_FOUND)) return res; char *cmd = (res == STATUS_OK) ? xcmd.clone_native() : sCommand.clone_native(); #else char *cmd = sCommand.clone_native(); #endif /* PLATFORM_HAS_EXECVPE */ if (cmd == NULL) return STATUS_NO_MEM; lsp_finally { free(cmd); }; // Form argv if ((res = build_argv(&argv)) != STATUS_OK) return res; // Form envp res = build_envp(&envp); if (res == STATUS_OK) { res = STATUS_UNKNOWN_ERR; // Different behaviour, depending on POSIX_SPAWN_USEVFORK presence #if defined(__USE_GNU) || defined(POSIX_SPAWN_USEVFORK) res = spawn_process(cmd, argv.array(), envp.array()); if (res != STATUS_OK) res = vfork_process(cmd, argv.array(), envp.array()); #else res = vfork_process(cmd, argv.array(), envp.array()); if (res != STATUS_OK) res = spawn_process(cmd, argv.array(), envp.array()); #endif /* __USE_GNU */ if (res != STATUS_OK) res = fork_process(cmd, argv.array(), envp.array()); } // Close redirected file handles if (res == STATUS_OK) close_handles(); return res; } status_t Process::wait(wssize_t millis) { if (nStatus != PSTATUS_RUNNING) return STATUS_BAD_STATE; int status; if (millis < 0) { do { // Wait for child process pid_t pid = ::waitpid(nPID, &status, WUNTRACED | WCONTINUED); if (pid < 0) { status = errno; if (status == EINTR) continue; return STATUS_UNKNOWN_ERR; } } while ((!WIFEXITED(status)) && (!WIFSIGNALED(status))); nStatus = PSTATUS_EXITED; nExitCode = WEXITSTATUS(status); } else if (millis == 0) { // Wait for child process pid_t pid = ::waitpid(nPID, &status, WUNTRACED | WCONTINUED | WNOHANG); if (pid < 0) { status = errno; return (status == EINTR) ? STATUS_OK : STATUS_UNKNOWN_ERR; } // Child has exited? if ((pid == nPID) && ((WIFEXITED(status)) || (WIFSIGNALED(status)))) { nStatus = PSTATUS_EXITED; nExitCode = WEXITSTATUS(status); } } else { struct timespec ts; wssize_t deadline, left; ::clock_gettime(CLOCK_REALTIME, &ts); deadline = millis + (ts.tv_sec * 1000 + ts.tv_nsec / 1000000); while (true) { // Wait for child process pid_t pid = ::waitpid(nPID, &status, WUNTRACED | WCONTINUED | WNOHANG); if (pid < 0) { status = errno; if (status == EINTR) continue; return STATUS_UNKNOWN_ERR; } // Child process has exited? if ((pid == nPID) && ((WIFEXITED(status)) || (WIFSIGNALED(status)))) break; // Get time ::clock_gettime(CLOCK_REALTIME, &ts); left = deadline - (ts.tv_sec * 1000 + ts.tv_nsec / 1000000); if (left <= 0) return STATUS_OK; // Just leave, no changes // Perform short sleep ts.tv_sec = 0; ts.tv_nsec = ((left > 50) ? 50 : left) * 1000000; ::nanosleep(&ts, NULL); } nStatus = PSTATUS_EXITED; nExitCode = WEXITSTATUS(status); } return STATUS_OK; } io::IOutStream *Process::get_stdin() { if ((nStatus != PSTATUS_CREATED) || (pStdIn != NULL)) return pStdIn; int fd[2]; // rw if (::pipe(fd) != 0) return NULL; // Create stream and wrap io::OutFileStream *strm = new io::OutFileStream(); if ((strm == NULL) || (strm->wrap_native(fd[1], true) != STATUS_OK)) { delete strm; ::close(fd[0]); ::close(fd[1]); return NULL; } // All is OK pStdIn = strm; hStdIn = fd[0]; return pStdIn; } io::IInStream *Process::get_stdout() { if ((nStatus != PSTATUS_CREATED) || (pStdOut != NULL)) return pStdOut; int fd[2]; // rw if (::pipe(fd) != 0) return NULL; // Create stream and wrap io::InFileStream *strm = new io::InFileStream(); if ((strm == NULL) || (strm->wrap_native(fd[0], true) != STATUS_OK)) { delete strm; ::close(fd[0]); ::close(fd[1]); return NULL; } // All is OK pStdOut = strm; hStdOut = fd[1]; return pStdOut; } io::IInStream *Process::get_stderr() { if ((nStatus != PSTATUS_CREATED) || (pStdErr != NULL)) return pStdErr; int fd[2]; // rw if (::pipe(fd) != 0) return NULL; // Create stream and wrap io::InFileStream *strm = new io::InFileStream(); if ((strm == NULL) || (strm->wrap_native(fd[0], true) != STATUS_OK)) { delete strm; ::close(fd[0]); ::close(fd[1]); return NULL; } // All is OK pStdErr = strm; hStdErr = fd[1]; return pStdErr; } #endif /* PLATFORM_WINDOWS */ status_t Process::copy_env() { lltl::parray env; LSPString k, v; #ifdef PLATFORM_WINDOWS for (WCHAR *item = GetEnvironmentStringsW(); (*item) != 0; ) { size_t len = wcslen(item); // Fetch environment variable if (!k.set_utf16(item, len)) { destroy_env(&env); return STATUS_NO_MEM; } item += (len + 1); // length + terminating character #else for (char **item=environ; *item != NULL; ++item) { // Fetch environment variable if (!k.set_native(*item)) { destroy_env(&env); return STATUS_NO_MEM; } #endif /* PLATFORM_WINDOWS */ // Parse record ssize_t idx = k.index_of('='); if (idx >= 0) { if (!v.set(&k, idx+1)) { destroy_env(&env); return STATUS_NO_MEM; } if (!k.truncate(idx)) { destroy_env(&env); return STATUS_NO_MEM; } } // Allocate && add env var envvar_t *var = new envvar_t(); if ((var == NULL) || (!env.add(var))) { destroy_env(&env); return STATUS_NO_MEM; } // Store value to env var->name.swap(&k); var->value.swap(&v); } // for // Commit result vEnv.swap(&env); destroy_env(&env); return STATUS_OK; } } /* namespace ipc */ } /* namespace lsp */