/**

 * 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 <signal.h>

#include <sys/types.h>

#include <sys/wait.h>

#ifdef __linux__

#include <sys/syscall.h>

#include <fcntl.h>

#include <errno.h>

#endif /* __linux__ */

#include "thread.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.

 */

static char* FindApplicationPath(char* application)

{

  LPCSTR pathName = "PATH";

  char* path = nullptr;

  char* save = nullptr;

  DWORD nSize = 0;

  LPSTR lpSystemPath = nullptr;

  char* filename = nullptr;

  if (!application)

    return nullptr;

  if (application[0] == '/')

    return _strdup(application);

  nSize = GetEnvironmentVariableA(pathName, nullptr, 0);

  if (!nSize)

    return _strdup(application);

  lpSystemPath = (LPSTR)malloc(nSize);

  if (!lpSystemPath)

    return nullptr;

  if (GetEnvironmentVariableA(pathName, lpSystemPath, nSize) != nSize - 1)

  {

    free(lpSystemPath);

    return nullptr;

  }

  save = nullptr;

  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,

                             WINPR_ATTR_UNUSED BOOL bInheritHandles,

                             WINPR_ATTR_UNUSED 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;

  /* 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;

    /* 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

    closefrom(3);

#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

    for (int fd = 3; fd < maxfd; fd++)

      close(fd);

#endif // __sun

    if (token)

    {

      if (token->GroupId)

      {

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

        if (rc < 0)

        {

        }

        else

        {

          initgroups(token->Username, (gid_t)token->GroupId);

        }

      }

      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);

    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;

  }

  free(process);

  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->fd = pidfd_open(pid);

  if (process->fd >= 0)

    process->common.Mode = WINPR_FD_READ;

  return (HANDLE)process;

}

#endif