/src/FreeRDP/winpr/libwinpr/thread/process.c

Source
/**
 * WinPR: Windows Portable Runtime
 * Process Thread Functions
 *
 * Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
 * Copyright 2014 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <winpr/config.h>

#include <winpr/handle.h>
#include "../handle/nonehandle.h"

#include <winpr/thread.h>
#include <winpr/wlog.h>

/**
 * CreateProcessA
 * CreateProcessW
 * CreateProcessAsUserA
 * CreateProcessAsUserW
 * ExitProcess
 * GetCurrentProcess
 * GetCurrentProcessId
 * GetExitCodeProcess
 * GetProcessHandleCount
 * GetProcessId
 * GetProcessIdOfThread
 * GetProcessMitigationPolicy
 * GetProcessTimes
 * GetProcessVersion
 * OpenProcess
 * OpenProcessToken
 * ProcessIdToSessionId
 * SetProcessAffinityUpdateMode
 * SetProcessMitigationPolicy
 * SetProcessShutdownParameters
 * TerminateProcess
 */

#ifndef _WIN32

#include <winpr/assert.h>
#include <winpr/crt.h>
#include <winpr/path.h>
#include <winpr/environment.h>

#include <grp.h>

#include <fcntl.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>

#ifdef __linux__
#include <sys/syscall.h>
#include <errno.h>
#endif /* __linux__ */

#include "thread.h"

#include "../handle/handle.h"
#include "../security/security.h"

#ifndef NSIG
#ifdef SIGMAX
#define NSIG SIGMAX
#else
#define NSIG 64
#endif
#endif

/**
 * If the file name does not contain a directory path, the system searches for the executable file
 * in the following sequence:
 *
 * 1) The directory from which the application loaded.
 * 2) The current directory for the parent process.
 * 3) The 32-bit Windows system directory. Use the GetSystemDirectory function to get the path of
 * this directory. 4) The 16-bit Windows system directory. There is no function that obtains the
 * path of this directory, but it is searched. The name of this directory is System. 5) The Windows
 * directory. Use the GetWindowsDirectory function to get the path of this directory. 6) The
 * directories that are listed in the PATH environment variable. Note that this function does not
 * search the per-application path specified by the App Paths registry key. To include this
 * per-application path in the search sequence, use the ShellExecute function.
 */
WINPR_ATTR_MALLOC(free, 1)
static char* FindApplicationPath(char* application)
{
  const char pathName[] = "PATH";

  if (!application)
    return nullptr;

  if (application[0] == '/')
  {
    if (!winpr_PathFileExists(application))
      return nullptr;
    return _strdup(application);
  }

  const DWORD nSize = GetEnvironmentVariableA(pathName, nullptr, 0);

  if (!nSize)
    return _strdup(application);

  char* lpSystemPath = malloc(nSize);

  if (!lpSystemPath)
    return nullptr;

  if (GetEnvironmentVariableA(pathName, lpSystemPath, nSize) != nSize - 1)
  {
    free(lpSystemPath);
    return nullptr;
  }

  char* filename = nullptr;
  char* save = nullptr;
  char* path = strtok_s(lpSystemPath, ":", &save);

  while (path)
  {
    filename = GetCombinedPath(path, application);

    if (winpr_PathFileExists(filename))
    {
      break;
    }

    free(filename);
    filename = nullptr;
    path = strtok_s(nullptr, ":", &save);
  }

  free(lpSystemPath);
  return filename;
}

static HANDLE CreateProcessHandle(pid_t pid);
static BOOL ProcessHandleCloseHandle(HANDLE handle);

static BOOL CreateProcessExA(HANDLE hToken, WINPR_ATTR_UNUSED DWORD dwLogonFlags,
                             LPCSTR lpApplicationName, WINPR_ATTR_UNUSED LPSTR lpCommandLine,
                             WINPR_ATTR_UNUSED LPSECURITY_ATTRIBUTES lpProcessAttributes,
                             WINPR_ATTR_UNUSED LPSECURITY_ATTRIBUTES lpThreadAttributes,
                             BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment,
                             LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo,
                             LPPROCESS_INFORMATION lpProcessInformation)
{
  pid_t pid = 0;
  int numArgs = 0;
  LPSTR* pArgs = nullptr;
  char** envp = nullptr;
  char* filename = nullptr;
  HANDLE thread = nullptr;
  HANDLE process = nullptr;
  WINPR_ACCESS_TOKEN* token = nullptr;
  LPTCH lpszEnvironmentBlock = nullptr;
  BOOL ret = FALSE;
  sigset_t oldSigMask;
  sigset_t newSigMask;
  BOOL restoreSigMask = FALSE;
  numArgs = 0;
  lpszEnvironmentBlock = nullptr;
  /* https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessa
   */

  if (lpCommandLine && lpApplicationName)
  {
    char* str = nullptr;
    size_t len = 0;
    winpr_asprintf(&str, &len, "%s %s", lpApplicationName, lpCommandLine);
    if (!str)
      return FALSE;
    pArgs = CommandLineToArgvA(str, &numArgs);
    free(str);
  }
  else if (lpCommandLine)
    pArgs = CommandLineToArgvA(lpCommandLine, &numArgs);
  else
    pArgs = CommandLineToArgvA(lpApplicationName, &numArgs);

  if (!pArgs)
    return FALSE;

  token = (WINPR_ACCESS_TOKEN*)hToken;

  if (lpEnvironment)
  {
    envp = EnvironmentBlockToEnvpA(lpEnvironment);
  }
  else
  {
    lpszEnvironmentBlock = GetEnvironmentStrings();

    if (!lpszEnvironmentBlock)
      goto finish;

    envp = EnvironmentBlockToEnvpA(lpszEnvironmentBlock);
  }

  if (!envp)
    goto finish;

  filename = FindApplicationPath(pArgs[0]);

  if (nullptr == filename)
    goto finish;

  /* Windows validates a PROC_THREAD_ATTRIBUTE_HANDLE_LIST's handles are still open before
   * creating the process at all, failing the whole call with ERROR_INVALID_PARAMETER if one
   * isn't (confirmed empirically: a handle CloseHandle()'d before this call, still listed here,
   * makes real CreateProcess fail this way rather than silently omitting it) */
  if (bInheritHandles && lpStartupInfo && (dwCreationFlags & EXTENDED_STARTUPINFO_PRESENT))
  {
    const STARTUPINFOEXA* exInfo = (const STARTUPINFOEXA*)lpStartupInfo;
    const struct WINPR_PROC_THREAD_ATTRIBUTE_LIST* list = exInfo->lpAttributeList;

    for (DWORD i = 0; list && (i < list->count); i++)
    {
      const WINPR_PROC_THREAD_ATTRIBUTE_ENTRY* entry = &list->entries[i];
      if (entry->Attribute != PROC_THREAD_ATTRIBUTE_HANDLE_LIST)
        continue;

      const HANDLE* handles = (const HANDLE*)entry->lpValue;
      const size_t count = entry->cbSize / sizeof(HANDLE);
      for (size_t h = 0; h < count; h++)
      {
        if (winpr_Handle_getFd(handles[h]) < 0)
        {
          SetLastError(ERROR_INVALID_PARAMETER);
          goto finish;
        }
      }
    }
  }

  /* block all signals so that the child can safely reset the caller's handlers */
  sigfillset(&newSigMask);
  restoreSigMask = !pthread_sigmask(SIG_SETMASK, &newSigMask, &oldSigMask);
  /* fork and exec */
  pid = fork();

  if (pid < 0)
  {
    /* fork failure */
    goto finish;
  }

  if (pid == 0)
  {
    /* child process */
#ifndef __sun
    int maxfd = 0;
#endif
    sigset_t set = WINPR_C_ARRAY_INIT;
    struct sigaction act = WINPR_C_ARRAY_INIT;

    /* resolve an explicit PROC_THREAD_ATTRIBUTE_HANDLE_LIST, if the caller opted into one
     * via a STARTUPINFOEX + EXTENDED_STARTUPINFO_PRESENT. Per documented Windows behavior:
     *  - bInheritHandles == FALSE: nothing is inherited, full stop - a handle list (if any)
     *    is ignored too, it can only narrow inheritance, never expand it.
     *  - bInheritHandles == TRUE and a handle list is present: it becomes the *exclusive*
     *    source of truth for which extra fds survive into this child - only the listed
     *    handles are inherited, even other handles independently marked inheritable are not.
     *  - bInheritHandles == TRUE and no handle list: every fd not marked close-on-exec is
     *    inherited, exactly like real Windows inheriting every handle marked inheritable -
     *    including ones WinPR doesn't know about (e.g. opened by a linked library), since
     *    Windows itself has no concept of "handles the runtime knows about" either. */
#define WINPR_MAX_INHERITED_HANDLES 64
    int keepFds[WINPR_MAX_INHERITED_HANDLES] = { -1 };
    size_t nKeepFds = 0;
    BOOL haveHandleList = FALSE;

    if (bInheritHandles && lpStartupInfo && (dwCreationFlags & EXTENDED_STARTUPINFO_PRESENT))
    {
      const STARTUPINFOEXA* exInfo = (const STARTUPINFOEXA*)lpStartupInfo;
      const struct WINPR_PROC_THREAD_ATTRIBUTE_LIST* list = exInfo->lpAttributeList;

      for (DWORD i = 0; list && (i < list->count); i++)
      {
        const WINPR_PROC_THREAD_ATTRIBUTE_ENTRY* entry = &list->entries[i];
        if (entry->Attribute != PROC_THREAD_ATTRIBUTE_HANDLE_LIST)
          continue;

        haveHandleList = TRUE;
        const HANDLE* handles = (const HANDLE*)entry->lpValue;
        const size_t count = entry->cbSize / sizeof(HANDLE);
        for (size_t h = 0; (h < count) && (nKeepFds < WINPR_MAX_INHERITED_HANDLES); h++)
        {
          const int fd = winpr_Handle_getFd(handles[h]);
          if (fd >= 0)
            keepFds[nKeepFds++] = fd;
        }
      }
    }

    /* set default signal handlers */
    act.sa_handler = SIG_DFL;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);

    for (int sig = 1; sig < NSIG; sig++)
      sigaction(sig, &act, nullptr);

    /* unblock all signals */
    sigfillset(&set);
    pthread_sigmask(SIG_UNBLOCK, &set, nullptr);

    if (lpStartupInfo)
    {
      int handle_fd = 0;
      handle_fd = winpr_Handle_getFd(lpStartupInfo->hStdOutput);

      if (handle_fd != -1)
        dup2(handle_fd, STDOUT_FILENO);

      handle_fd = winpr_Handle_getFd(lpStartupInfo->hStdError);

      if (handle_fd != -1)
        dup2(handle_fd, STDERR_FILENO);

      handle_fd = winpr_Handle_getFd(lpStartupInfo->hStdInput);

      if (handle_fd != -1)
        dup2(handle_fd, STDIN_FILENO);
    }

#ifdef __sun
    if (!bInheritHandles || !haveHandleList)
      closefrom(3);
    /* else: Solaris has no per-fd enumeration primitive as cheap as the loop below, and a
     * handle list is a narrow/rare case there - fall through without closing anything
     * rather than silently ignoring the caller's explicit allowlist. */
#else
#ifdef F_MAXFD // on some BSD derivates
    maxfd = fcntl(0, F_MAXFD);
#else
    {
      const long rc = sysconf(_SC_OPEN_MAX);
      if ((rc < INT32_MIN) || (rc > INT32_MAX))
        goto finish;
      maxfd = (int)rc;
    }
#endif

    /* - bInheritHandles == FALSE: keep stays FALSE for every fd, close everything.
     * - bInheritHandles == TRUE, handle list present: exclusive allowlist (see above).
     * - bInheritHandles == TRUE, no handle list: inherit everything not close-on-exec. */
    for (int fd = 3; fd < maxfd; fd++)
    {
      BOOL keep = FALSE;

      if (bInheritHandles)
      {
        if (haveHandleList)
        {
          for (size_t k = 0; k < nKeepFds; k++)
          {
            if (keepFds[k] == fd)
            {
              keep = TRUE;
              break;
            }
          }
        }
        else
        {
          const int flags = fcntl(fd, F_GETFD);
          keep = (flags >= 0) && !(flags & FD_CLOEXEC);
        }
      }

      if (!keep)
        close(fd);
    }

#endif // __sun

    if (token)
    {
      if (token->GroupId)
      {
        int rc = setgid((gid_t)token->GroupId);

        if (rc < 0)
        {
        }
#if !defined(__EMSCRIPTEN__)
        else
        {
          initgroups(token->Username, (gid_t)token->GroupId);
        }
#endif
      }

      if (token->UserId)
      {
        int rc = setuid((uid_t)token->UserId);
        if (rc != 0)
          goto finish;
      }
    }

    /* TODO: add better cwd handling and error checking */
    if (lpCurrentDirectory && strlen(lpCurrentDirectory) > 0)
    {
      int rc = chdir(lpCurrentDirectory);
      if (rc != 0)
        goto finish;
    }

    if (execve(filename, pArgs, envp) < 0)
    {
      /* execve failed - end the process */
      _exit(1);
    }
  }
  else
  {
    /* parent process */
  }

  process = CreateProcessHandle(pid);

  if (!process)
  {
    goto finish;
  }

  thread = CreateNoneHandle();

  if (!thread)
  {
    ProcessHandleCloseHandle(process);
    free(process);
    goto finish;
  }

  lpProcessInformation->hProcess = process;
  lpProcessInformation->hThread = thread;
  lpProcessInformation->dwProcessId = (DWORD)pid;
  lpProcessInformation->dwThreadId = (DWORD)pid;
  ret = TRUE;
finish:

  /* restore caller's original signal mask */
  if (restoreSigMask)
    pthread_sigmask(SIG_SETMASK, &oldSigMask, nullptr);

  free(filename);
  free((void*)pArgs);

  if (lpszEnvironmentBlock)
    FreeEnvironmentStrings(lpszEnvironmentBlock);

  if (envp)
  {
    int i = 0;

    while (envp[i])
    {
      free(envp[i]);
      i++;
    }

    free((void*)envp);
  }

  return ret;
}

BOOL CreateProcessA(LPCSTR lpApplicationName, LPSTR lpCommandLine,
                    LPSECURITY_ATTRIBUTES lpProcessAttributes,
                    LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles,
                    DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory,
                    LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation)
{
  return CreateProcessExA(nullptr, 0, lpApplicationName, lpCommandLine, lpProcessAttributes,
                          lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment,
                          lpCurrentDirectory, lpStartupInfo, lpProcessInformation);
}

BOOL CreateProcessW(WINPR_ATTR_UNUSED LPCWSTR lpApplicationName,
                    WINPR_ATTR_UNUSED LPWSTR lpCommandLine,
                    WINPR_ATTR_UNUSED LPSECURITY_ATTRIBUTES lpProcessAttributes,
                    WINPR_ATTR_UNUSED LPSECURITY_ATTRIBUTES lpThreadAttributes,
                    WINPR_ATTR_UNUSED BOOL bInheritHandles, WINPR_ATTR_UNUSED DWORD dwCreationFlags,
                    WINPR_ATTR_UNUSED LPVOID lpEnvironment,
                    WINPR_ATTR_UNUSED LPCWSTR lpCurrentDirectory,
                    WINPR_ATTR_UNUSED LPSTARTUPINFOW lpStartupInfo,
                    WINPR_ATTR_UNUSED LPPROCESS_INFORMATION lpProcessInformation)
{
  WINPR_ASSERT(lpStartupInfo);
  WINPR_ASSERT(lpProcessInformation);

  LPSTR lpApplicationNameA = nullptr;
  LPSTR lpCommandLineA = nullptr;
  LPSTR lpCurrentDirectoryA = nullptr;
  STARTUPINFOA StartupInfoA = { .cb = sizeof(STARTUPINFOA),
                              .lpReserved = nullptr,
                              .lpDesktop = nullptr,
                              .lpTitle = nullptr,
                              .dwX = lpStartupInfo->dwX,
                              .dwY = lpStartupInfo->dwY,
                              .dwXSize = lpStartupInfo->dwXSize,
                              .dwYSize = lpStartupInfo->dwYSize,
                              .dwXCountChars = lpStartupInfo->dwXCountChars,
                              .dwYCountChars = lpStartupInfo->dwYCountChars,
                              .dwFillAttribute = lpStartupInfo->dwFillAttribute,
                              .dwFlags = lpStartupInfo->dwFlags,
                              .wShowWindow = lpStartupInfo->wShowWindow,
                              .cbReserved2 = lpStartupInfo->cbReserved2,
                              .lpReserved2 = lpStartupInfo->lpReserved2,
                              .hStdInput = lpStartupInfo->hStdInput,
                              .hStdOutput = lpStartupInfo->hStdOutput,
                              .hStdError = lpStartupInfo->hStdError };

  BOOL rc = FALSE;
  if (lpApplicationName)
  {
    lpApplicationNameA = ConvertWCharToUtf8Alloc(lpApplicationName, nullptr);
    if (!lpApplicationNameA)
      goto fail;
  }
  if (lpCommandLine)
  {
    lpCommandLineA = ConvertWCharToUtf8Alloc(lpCommandLine, nullptr);
    if (!lpCommandLineA)
      goto fail;
  }
  if (lpCurrentDirectory)
  {
    lpCurrentDirectoryA = ConvertWCharToUtf8Alloc(lpCurrentDirectory, nullptr);
    if (!lpCurrentDirectoryA)
      goto fail;
  }
  if (lpStartupInfo->lpReserved)
  {
    StartupInfoA.lpReserved = ConvertWCharToUtf8Alloc(lpStartupInfo->lpReserved, nullptr);
    if (!StartupInfoA.lpReserved)
      goto fail;
  }
  if (lpStartupInfo->lpDesktop)
  {
    StartupInfoA.lpDesktop = ConvertWCharToUtf8Alloc(lpStartupInfo->lpDesktop, nullptr);
    if (!StartupInfoA.lpDesktop)
      goto fail;
  }
  if (lpStartupInfo->lpTitle)
  {
    StartupInfoA.lpTitle = ConvertWCharToUtf8Alloc(lpStartupInfo->lpTitle, nullptr);
    if (!StartupInfoA.lpTitle)
      goto fail;
  }

  rc = CreateProcessA(lpApplicationNameA, lpCommandLineA, lpProcessAttributes, lpThreadAttributes,
                      bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectoryA,
                      &StartupInfoA, lpProcessInformation);
fail:
  free(lpApplicationNameA);
  free(lpCommandLineA);
  free(lpCurrentDirectoryA);
  free(StartupInfoA.lpDesktop);
  free(StartupInfoA.lpReserved);
  free(StartupInfoA.lpTitle);
  return rc;
}

BOOL CreateProcessAsUserA(HANDLE hToken, LPCSTR lpApplicationName, LPSTR lpCommandLine,
                          LPSECURITY_ATTRIBUTES lpProcessAttributes,
                          LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles,
                          DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory,
                          LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation)
{
  return CreateProcessExA(hToken, 0, lpApplicationName, lpCommandLine, lpProcessAttributes,
                          lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment,
                          lpCurrentDirectory, lpStartupInfo, lpProcessInformation);
}

BOOL CreateProcessAsUserW(WINPR_ATTR_UNUSED HANDLE hToken,
                          WINPR_ATTR_UNUSED LPCWSTR lpApplicationName,
                          WINPR_ATTR_UNUSED LPWSTR lpCommandLine,
                          WINPR_ATTR_UNUSED LPSECURITY_ATTRIBUTES lpProcessAttributes,
                          WINPR_ATTR_UNUSED LPSECURITY_ATTRIBUTES lpThreadAttributes,
                          WINPR_ATTR_UNUSED BOOL bInheritHandles,
                          WINPR_ATTR_UNUSED DWORD dwCreationFlags,
                          WINPR_ATTR_UNUSED LPVOID lpEnvironment,
                          WINPR_ATTR_UNUSED LPCWSTR lpCurrentDirectory,
                          WINPR_ATTR_UNUSED LPSTARTUPINFOW lpStartupInfo,
                          WINPR_ATTR_UNUSED LPPROCESS_INFORMATION lpProcessInformation)
{
  WLog_ERR("TODO", "TODO: implement");
  return FALSE;
}

BOOL CreateProcessWithLogonA(
    WINPR_ATTR_UNUSED LPCSTR lpUsername, WINPR_ATTR_UNUSED LPCSTR lpDomain,
    WINPR_ATTR_UNUSED LPCSTR lpPassword, WINPR_ATTR_UNUSED DWORD dwLogonFlags,
    WINPR_ATTR_UNUSED LPCSTR lpApplicationName, WINPR_ATTR_UNUSED LPSTR lpCommandLine,
    WINPR_ATTR_UNUSED DWORD dwCreationFlags, WINPR_ATTR_UNUSED LPVOID lpEnvironment,
    WINPR_ATTR_UNUSED LPCSTR lpCurrentDirectory, WINPR_ATTR_UNUSED LPSTARTUPINFOA lpStartupInfo,
    WINPR_ATTR_UNUSED LPPROCESS_INFORMATION lpProcessInformation)
{
  WLog_ERR("TODO", "TODO: implement");
  return FALSE;
}

BOOL CreateProcessWithLogonW(
    WINPR_ATTR_UNUSED LPCWSTR lpUsername, WINPR_ATTR_UNUSED LPCWSTR lpDomain,
    WINPR_ATTR_UNUSED LPCWSTR lpPassword, WINPR_ATTR_UNUSED DWORD dwLogonFlags,
    WINPR_ATTR_UNUSED LPCWSTR lpApplicationName, WINPR_ATTR_UNUSED LPWSTR lpCommandLine,
    WINPR_ATTR_UNUSED DWORD dwCreationFlags, WINPR_ATTR_UNUSED LPVOID lpEnvironment,
    WINPR_ATTR_UNUSED LPCWSTR lpCurrentDirectory, WINPR_ATTR_UNUSED LPSTARTUPINFOW lpStartupInfo,
    WINPR_ATTR_UNUSED LPPROCESS_INFORMATION lpProcessInformation)
{
  WLog_ERR("TODO", "TODO: implement");
  return FALSE;
}

BOOL CreateProcessWithTokenA(WINPR_ATTR_UNUSED HANDLE hToken, WINPR_ATTR_UNUSED DWORD dwLogonFlags,
                             LPCSTR lpApplicationName, LPSTR lpCommandLine, DWORD dwCreationFlags,
                             LPVOID lpEnvironment, LPCSTR lpCurrentDirectory,
                             LPSTARTUPINFOA lpStartupInfo,
                             LPPROCESS_INFORMATION lpProcessInformation)
{
  return CreateProcessExA(nullptr, 0, lpApplicationName, lpCommandLine, nullptr, nullptr, FALSE,
                          dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo,
                          lpProcessInformation);
}

BOOL CreateProcessWithTokenW(WINPR_ATTR_UNUSED HANDLE hToken, WINPR_ATTR_UNUSED DWORD dwLogonFlags,
                             WINPR_ATTR_UNUSED LPCWSTR lpApplicationName,
                             WINPR_ATTR_UNUSED LPWSTR lpCommandLine,
                             WINPR_ATTR_UNUSED DWORD dwCreationFlags,
                             WINPR_ATTR_UNUSED LPVOID lpEnvironment,
                             WINPR_ATTR_UNUSED LPCWSTR lpCurrentDirectory,
                             WINPR_ATTR_UNUSED LPSTARTUPINFOW lpStartupInfo,
                             WINPR_ATTR_UNUSED LPPROCESS_INFORMATION lpProcessInformation)
{
  WLog_ERR("TODO", "TODO: implement");
  return FALSE;
}

VOID ExitProcess(UINT uExitCode)
{
  // NOLINTNEXTLINE(concurrency-mt-unsafe)
  exit((int)uExitCode);
}

BOOL GetExitCodeProcess(HANDLE hProcess, LPDWORD lpExitCode)
{
  WINPR_PROCESS* process = nullptr;

  if (!hProcess)
    return FALSE;

  if (!lpExitCode)
    return FALSE;

  process = (WINPR_PROCESS*)hProcess;
  *lpExitCode = process->dwExitCode;
  return TRUE;
}

HANDLE _GetCurrentProcess(VOID)
{
  WLog_ERR("TODO", "TODO: implement");
  return nullptr;
}

DWORD GetCurrentProcessId(VOID)
{
  return ((DWORD)getpid());
}

BOOL TerminateProcess(HANDLE hProcess, WINPR_ATTR_UNUSED UINT uExitCode)
{
  WINPR_PROCESS* process = nullptr;
  process = (WINPR_PROCESS*)hProcess;

  if (!process || (process->pid <= 0))
    return FALSE;

  if (kill(process->pid, SIGTERM))
    return FALSE;

  return TRUE;
}

static BOOL ProcessHandleCloseHandle(HANDLE handle)
{
  WINPR_PROCESS* process = (WINPR_PROCESS*)handle;
  WINPR_ASSERT(process);
  if (process->fd >= 0)
  {
    close(process->fd);
    process->fd = -1;
  }
  return TRUE;
}

static BOOL ProcessHandleIsHandle(HANDLE handle)
{
  return WINPR_HANDLE_IS_HANDLED(handle, HANDLE_TYPE_PROCESS, FALSE);
}

static int ProcessGetFd(HANDLE handle)
{
  WINPR_PROCESS* process = (WINPR_PROCESS*)handle;

  if (!ProcessHandleIsHandle(handle))
    return -1;

  return process->fd;
}

static DWORD ProcessCleanupHandle(HANDLE handle)
{
  WINPR_PROCESS* process = (WINPR_PROCESS*)handle;

  WINPR_ASSERT(process);
  if (process->fd > 0)
  {
    if (waitpid(process->pid, &process->status, WNOHANG) == process->pid)
    {
      if (WIFEXITED(process->status))
        process->dwExitCode = (DWORD)WEXITSTATUS(process->status);
      else if (WIFSIGNALED(process->status))
        process->dwExitCode = (DWORD)(128 + WTERMSIG(process->status));
      else
        process->dwExitCode = (DWORD)process->status;
    }
  }
  return WAIT_OBJECT_0;
}

static HANDLE_OPS ops = { ProcessHandleIsHandle,
                        ProcessHandleCloseHandle,
                        ProcessGetFd,
                        ProcessCleanupHandle, /* CleanupHandle */
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr };

static int pidfd_open(pid_t pid)
{
#ifdef __linux__
#if !defined(__NR_pidfd_open)
#define __NR_pidfd_open 434
#endif /* __NR_pidfd_open */

#ifndef PIDFD_NONBLOCK
#define PIDFD_NONBLOCK O_NONBLOCK
#endif /* PIDFD_NONBLOCK */

  long fd = syscall(__NR_pidfd_open, pid, PIDFD_NONBLOCK);
  if (fd < 0 && errno == EINVAL)
  {
    /* possibly PIDFD_NONBLOCK is not supported, let's try to create a pidfd and set it
     * non blocking afterward */
    int flags = 0;
    fd = syscall(__NR_pidfd_open, pid, 0);
    if ((fd < 0) || (fd > INT32_MAX))
      return -1;

    flags = fcntl((int)fd, F_GETFL);
    if ((flags < 0) || fcntl((int)fd, F_SETFL, flags | O_NONBLOCK) < 0)
    {
      close((int)fd);
      fd = -1;
    }
  }
  if ((fd < 0) || (fd > INT32_MAX))
    return -1;
  return (int)fd;
#else
  return -1;
#endif
}

HANDLE CreateProcessHandle(pid_t pid)
{
  WINPR_PROCESS* process = nullptr;
  process = (WINPR_PROCESS*)calloc(1, sizeof(WINPR_PROCESS));

  if (!process)
    return nullptr;

  process->pid = pid;
  process->common.Type = HANDLE_TYPE_PROCESS;
  process->common.ops = &ops;
  process->common.refCount = 1;
  process->fd = pidfd_open(pid);
  if (process->fd >= 0)
    process->common.Mode = WINPR_FD_READ;
  return (HANDLE)process;
}

#endif

Coverage Report

Created: 2026-10-28 06:54