handle.c

 
#include <winpr/config.h>
 
#include <winpr/handle.h>
#include <winpr/assert.h>
 
#include "../log.h"
#define TAG WINPR_TAG("handle")
 
#ifndef _WIN32
 
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <string.h>
 
#include "../synch/synch.h"
#include "../thread/thread.h"
#include "../pipe/pipe.h"
#include "../comm/comm.h"
#include "../security/security.h"
 
#ifdef WINPR_HAVE_UNISTD_H
#include <unistd.h>
#endif
 
#include "../handle/handle.h"
 
#endif
 
/* finds the "{}" placeholder in `format`, splitting it into the literal text before and after it.
 * Returns FALSE (and leaves *prefixLen and *suffix untouched) if `format` has none. */
WINPR_ATTR_NODISCARD
static BOOL winpr_handle_format_split(const char* format, size_t* prefixLen, const char** suffix)
{
  const char* placeholder = strstr(format, "{}");
  if (!placeholder)
  {
    WLog_ERR(TAG, "format string '%s' has no {} placeholder for the handle value", format);
    return FALSE;
  }
 
  *prefixLen = (size_t)(placeholder - format);
  *suffix = placeholder + 2;
  return TRUE;
}
 
#ifndef _WIN32
/* single-character tag identifying a handle's type in the exported value (see
 * winpr_exportHandleToString()/winpr_importHandleFromString()), so a POSIX-side import knows how
 * to rebuild the right kind of HANDLE around the fd. Only pipes (as returned by CreatePipe()) are
 * supported for now; add a case here (and a matching one in winpr_importHandleFromString()) when
 * another handle type needs to cross a fork()+exec(). */
WINPR_ATTR_NODISCARD
static char winpr_handle_export_type_tag(ULONG type)
{
  switch (type)
  {
    case HANDLE_TYPE_ANONYMOUS_PIPE:
      return 'P';
    default:
      return '\0';
  }
}
#endif
 
BOOL winpr_exportHandleToString(HANDLE h, const char* format, char* outStr, size_t outSz)
{
  if (!format || !outStr || (outSz == 0))
    return FALSE;
 
  size_t prefixLen = 0;
  const char* suffix = nullptr;
  if (!winpr_handle_format_split(format, &prefixLen, &suffix))
    return FALSE;
 
  if (!h || (h == INVALID_HANDLE_VALUE))
  {
    WLog_ERR(TAG, "refusing to export an invalid handle");
    return FALSE;
  }
  size_t remaining = outSz - 1;
  if (remaining <= prefixLen)
    return FALSE;
  remaining -= prefixLen;
 
  size_t suffixLen = strlen(suffix);
  if (remaining <= suffixLen)
    return FALSE;
  remaining -= suffixLen;
 
  char value[32] = WINPR_C_ARRAY_INIT;
#ifdef _WIN32
  const int valueLenInt = snprintf(value, sizeof(value), "%llx", (unsigned long long)(UINT_PTR)h);
#else
  ULONG type = 0;
  WINPR_HANDLE* hdl = nullptr;
  if (!winpr_Handle_GetInfo(h, &type, &hdl))
  {
    WLog_ERR(TAG, "unable to resolve handle info");
    return FALSE;
  }
 
  const char typeTag = winpr_handle_export_type_tag(type);
  if (typeTag == '\0')
  {
    WLog_ERR(TAG,
             "exporting handle type %" PRIu32 " is not supported, only pipe handles can be "
             "exported for now",
             type);
    return FALSE;
  }
 
  const int fd = winpr_Handle_getFd(h);
  if (fd < 0)
  {
    WLog_ERR(TAG, "unable to resolve a file descriptor for this handle");
    return FALSE;
  }
  const int valueLenInt = snprintf(value, sizeof(value), "%c%x", typeTag, (unsigned)fd);
#endif
  if (valueLenInt <= 0)
    return FALSE;
  const size_t valueLen = (size_t)valueLenInt;
 
  if (valueLen > remaining)
    return FALSE;
 
  memcpy(outStr, format, prefixLen);
  memcpy(outStr + prefixLen, value, valueLen);
  memcpy(outStr + prefixLen + valueLen, suffix, suffixLen + 1);
  return TRUE;
}
 
HANDLE winpr_importHandleFromString(const char* str, const char* format)
{
  if (!str || !format)
    return INVALID_HANDLE_VALUE;
 
  size_t prefixLen = 0;
  const char* suffix = nullptr;
  if (!winpr_handle_format_split(format, &prefixLen, &suffix))
    return INVALID_HANDLE_VALUE;
 
  const size_t suffixLen = strlen(suffix);
  const size_t strLen = strlen(str);
  if ((strLen < prefixLen + suffixLen) || (strncmp(str, format, prefixLen) != 0) ||
      (strcmp(str + strLen - suffixLen, suffix) != 0))
  {
    WLog_ERR(TAG, "input string '%s' does not match format '%s'", str, format);
    return INVALID_HANDLE_VALUE;
  }
 
  char value[32] = WINPR_C_ARRAY_INIT;
  size_t valueLen = strLen - prefixLen - suffixLen;
  const char* valueStart = str + prefixLen;
  if ((valueLen == 0) || (valueLen >= sizeof(value)))
  {
    WLog_ERR(TAG, "input string '%s' has no usable handle value", str);
    return INVALID_HANDLE_VALUE;
  }
 
#ifndef _WIN32
  /* first character is the type tag written by winpr_exportHandleToString() (see
   * winpr_handle_export_type_tag()) - only pipes are supported for now. */
  const char typeTag = valueStart[0];
  if (typeTag != 'P')
  {
    WLog_ERR(TAG,
             "unsupported handle type tag '%c' in '%s', only pipe handles ('P') can be "
             "imported for now",
             typeTag, str);
    return INVALID_HANDLE_VALUE;
  }
  valueStart++;
  valueLen--;
  if (valueLen == 0)
  {
    WLog_ERR(TAG, "input string '%s' has no usable handle value after the type tag", str);
    return INVALID_HANDLE_VALUE;
  }
#endif
 
  memcpy(value, valueStart, valueLen);
  value[valueLen] = '\0';
 
  char* end = nullptr;
  const unsigned long long numeric = strtoull(value, &end, 16);
  if (!end || (*end != '\0'))
  {
    WLog_ERR(TAG, "invalid handle value '%s'", value);
    return INVALID_HANDLE_VALUE;
  }
 
#ifdef _WIN32
  return (HANDLE)(UINT_PTR)numeric;
#else
  if (numeric > INT32_MAX)
  {
    WLog_ERR(TAG, "handle value '%s' out of range for a file descriptor", value);
    return INVALID_HANDLE_VALUE;
  }
  return winpr_Pipe_FromFd((int)numeric);
#endif
}
 
#ifndef _WIN32
 
BOOL CloseHandle(HANDLE hObject)
{
  ULONG type = 0;
  WINPR_HANDLE* hdl = nullptr;
 
  if (!winpr_Handle_GetInfo(hObject, &type, &hdl) || !hdl || !hdl->ops)
    return FALSE;
 
  BOOL ok = TRUE;
  if (hdl->ops->CloseHandle)
    ok = hdl->ops->CloseHandle(hObject);
 
  /* a type's CloseHandle op can legitimately refuse (e.g. file.c won't close the pStdHandleFile
   * singleton unless forced) - if it did, this handle wasn't actually closed, so leave its
   * refcount/memory alone entirely. */
  if (!ok)
    return FALSE;
 
  /* WINPR_THREAD manages its own close/free lifecycle: closing the handle of a still-running
   * thread detaches it instead of freeing it, and the free only happens later, from the
   * thread's own pthread routine once it actually returns (see ThreadCloseHandle() /
   * cleanup_handle() in thread.c). Applying the generic release-then-maybe-free sequence below
   * on top of that would free the struct while the thread may still be running against it. */
  if (type == HANDLE_TYPE_THREAD)
    return TRUE;
 
  if (!winpr_Handle_Release(hObject))
    winpr_Handle_ConvertToNone(hObject);
 
  return TRUE;
}
 
BOOL DuplicateHandle(WINPR_ATTR_UNUSED HANDLE hSourceProcessHandle,
                     WINPR_ATTR_UNUSED HANDLE hSourceHandle,
                     WINPR_ATTR_UNUSED HANDLE hTargetProcessHandle,
                     WINPR_ATTR_UNUSED LPHANDLE lpTargetHandle,
                     WINPR_ATTR_UNUSED DWORD dwDesiredAccess, WINPR_ATTR_UNUSED BOOL bInheritHandle,
                     WINPR_ATTR_UNUSED DWORD dwOptions)
{
  WLog_ERR(TAG, "DuplicateHandle not implemented");
  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  return FALSE;
}
 
BOOL GetHandleInformation(HANDLE hObject, LPDWORD lpdwFlags)
{
  if (!lpdwFlags)
    return FALSE;
 
  const int fd = winpr_Handle_getFd(hObject);
  if (fd < 0)
  {
    WLog_ERR(TAG, "unable to resolve a file descriptor for this handle type");
    return FALSE;
  }
 
  const int flags = fcntl(fd, F_GETFD);
  if (flags < 0)
  {
    char buffer[64] = WINPR_C_ARRAY_INIT;
    WLog_ERR(TAG, "fcntl(F_GETFD) failed: %s", winpr_strerror(errno, buffer, sizeof(buffer)));
    return FALSE;
  }
 
  *lpdwFlags = (flags & FD_CLOEXEC) ? 0 : HANDLE_FLAG_INHERIT;
  return TRUE;
}
 
BOOL SetHandleInformation(HANDLE hObject, DWORD dwMask, DWORD dwFlags)
{
  const int fd = winpr_Handle_getFd(hObject);
  if (fd < 0)
  {
    WLog_ERR(TAG, "unable to resolve a file descriptor for this handle type");
    return FALSE;
  }
 
  /* only HANDLE_FLAG_INHERIT is meaningful on POSIX; ignore any other bit in the mask rather
   * than failing, matching how Windows treats masks it doesn't recognize on other handle
   * types */
  if (!(dwMask & HANDLE_FLAG_INHERIT))
    return TRUE;
 
  int flags = fcntl(fd, F_GETFD);
  if (flags < 0)
  {
    char buffer[64] = WINPR_C_ARRAY_INIT;
    WLog_ERR(TAG, "fcntl(F_GETFD) failed: %s", winpr_strerror(errno, buffer, sizeof(buffer)));
    return FALSE;
  }
 
  flags = (dwFlags & HANDLE_FLAG_INHERIT) ? (flags & ~FD_CLOEXEC) : (flags | FD_CLOEXEC);
  if (fcntl(fd, F_SETFD, flags) < 0)
  {
    char buffer[64] = WINPR_C_ARRAY_INIT;
    WLog_ERR(TAG, "fcntl(F_SETFD) failed: %s", winpr_strerror(errno, buffer, sizeof(buffer)));
    return FALSE;
  }
 
  return TRUE;
}
 
BOOL winpr_set_cloexec(int fd, BOOL cloexec)
{
  const int flags = fcntl(fd, F_GETFD);
  if (flags < 0)
    return FALSE;
 
  const int newFlags = cloexec ? (flags | FD_CLOEXEC) : (flags & ~FD_CLOEXEC);
  return fcntl(fd, F_SETFD, newFlags) >= 0;
}
 
#endif