win32.c

/*
 *  Copyright (c) 1993, Intergraph Corporation
 *
 *  You may distribute under the terms of either the GNU General Public
 *  License or the Artistic License, as specified in the perl README file.
 *
 *  Various Unix compatibility functions and NT specific functions.
 *
 *  Some of this code was derived from the MSDOS port(s) and the OS/2 port.
 *
 */
/*
  The parts licensed under above copyright notice are marked as "Artistic or
  GPL".
  Another parts are licensed under Ruby's License.
 
  Copyright (C) 1993-2011 Yukihiro Matsumoto
  Copyright (C) 2000  Network Applied Communication Laboratory, Inc.
  Copyright (C) 2000  Information-technology Promotion Agency, Japan
 */
 
#undef __STRICT_ANSI__
 
/* Visual C++ 2015 (14.0):
 * - _MSC_VER: 1900
 * - MSVCRT_VERSION: 140
 */
#include "ruby/ruby.h"
#include "ruby/encoding.h"
#include "ruby/io.h"
#include "ruby/util.h"
#include <fcntl.h>
#include <process.h>
#include <sys/stat.h>
/* #include <sys/wait.h> */
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <assert.h>
#include <ctype.h>
 
#include <windows.h>
#include <winbase.h>
#include <wincon.h>
#include <share.h>
#include <shlobj.h>
#include <mbstring.h>
#include <shlwapi.h>
#if defined _MSC_VER
#include <crtdbg.h>
#include <rtcapi.h>
#endif
#ifdef __MINGW32__
#include <mswsock.h>
#endif
#ifdef HAVE_AFUNIX_H
# include <afunix.h>
#endif
#include "ruby/win32.h"
#include "ruby/vm.h"
#include "win32/dir.h"
#include "win32/file.h"
#include "id.h"
#include "internal.h"
#include "internal/enc.h"
#include "internal/object.h"
#include "internal/static_assert.h"
#include "ruby/internal/stdbool.h"
#include "encindex.h"
#define isdirsep(x) ((x) == '/' || (x) == '\\')
 
static int w32_wopen(const WCHAR *file, int oflag, int perm);
static int w32_stati128(const char *path, struct stati128 *st, UINT cp, BOOL lstat);
static char *w32_getenv(const char *name, UINT cp);
 
#undef getenv
/*
 * Do not remove the macros to substitute functions in dln_find.c.
 */
#define DLN_FIND_EXTRA_ARG_DECL ,UINT cp
#define DLN_FIND_EXTRA_ARG ,cp
#define rb_w32_stati128(path, st) w32_stati128(path, st, cp, FALSE)
#define getenv(name) w32_getenv(name, cp) /* Necessarily For dln.c */
#define DLN_CHAR_NEXT(p) CharNextExA(cp, (p), 0)
#define dln_find_exe_r rb_w32_udln_find_exe_r
#define dln_find_file_r rb_w32_udln_find_file_r
#include "dln.h"
#include "dln_find.c"
#undef MAXPATHLEN
#undef rb_w32_stati128
#undef dln_find_exe_r
#undef dln_find_file_r
#define dln_find_exe_r(fname, path, buf, size) rb_w32_udln_find_exe_r(fname, path, buf, size, cp)
#define dln_find_file_r(fname, path, buf, size) rb_w32_udln_find_file_r(fname, path, buf, size, cp)
#undef CharNext                 /* no default cp version */
#undef getenv
 
#ifndef PATH_MAX
# if defined MAX_PATH
#   define PATH_MAX MAX_PATH
# elif defined HAVE_SYS_PARAM_H
#   include <sys/param.h>
#   define PATH_MAX MAXPATHLEN
# endif
#endif
#define ENV_MAX 512
 
#undef stat
#undef fclose
#undef close
#undef setsockopt
#undef dup2
#undef strdup
 
#define _filbuf _fgetc_nolock
#define _flsbuf _fputc_nolock
#define enough_to_get(n) (--(n) >= 0)
#define enough_to_put(n) (--(n) >= 0)
 
#ifdef WIN32_DEBUG
#define Debug(something) something
#else
#define Debug(something) /* nothing */
#endif
 
#define TO_SOCKET(x)    _get_osfhandle(x)
 
int rb_w32_reparse_symlink_p(const WCHAR *path);
 
static int has_redirection(const char *, UINT);
int rb_w32_wait_events(HANDLE *events, int num, DWORD timeout);
static int rb_w32_open_osfhandle(intptr_t osfhandle, int flags);
static int wstati128(const WCHAR *path, struct stati128 *st, BOOL lstat);
VALUE rb_w32_conv_from_wchar(const WCHAR *wstr, rb_encoding *enc);
int ruby_brace_glob_with_enc(const char *str, int flags, ruby_glob_func *func, VALUE arg, rb_encoding *enc);
static FARPROC get_proc_address(const char *module, const char *func, HANDLE *mh);
 
#define RUBY_CRITICAL if (0) {} else /* just remark */
 
/* errno mapping */
static const struct {
    DWORD winerr;
    int err;
} errmap[] = {
    {   ERROR_INVALID_FUNCTION,         EINVAL          },
    {   ERROR_FILE_NOT_FOUND,           ENOENT          },
    {   ERROR_PATH_NOT_FOUND,           ENOENT          },
    {   ERROR_TOO_MANY_OPEN_FILES,      EMFILE          },
    {   ERROR_ACCESS_DENIED,            EACCES          },
    {   ERROR_INVALID_HANDLE,           EBADF           },
    {   ERROR_ARENA_TRASHED,            ENOMEM          },
    {   ERROR_NOT_ENOUGH_MEMORY,        ENOMEM          },
    {   ERROR_INVALID_BLOCK,            ENOMEM          },
    {   ERROR_BAD_ENVIRONMENT,          E2BIG           },
    {   ERROR_BAD_FORMAT,               ENOEXEC         },
    {   ERROR_INVALID_ACCESS,           EINVAL          },
    {   ERROR_INVALID_DATA,             EINVAL          },
    {   ERROR_INVALID_DRIVE,            ENOENT          },
    {   ERROR_CURRENT_DIRECTORY,        EACCES          },
    {   ERROR_NOT_SAME_DEVICE,          EXDEV           },
    {   ERROR_NO_MORE_FILES,            ENOENT          },
    {   ERROR_WRITE_PROTECT,            EROFS           },
    {   ERROR_BAD_UNIT,                 ENODEV          },
    {   ERROR_NOT_READY,                ENXIO           },
    {   ERROR_BAD_COMMAND,              EACCES          },
    {   ERROR_CRC,                      EACCES          },
    {   ERROR_BAD_LENGTH,               EACCES          },
    {   ERROR_SEEK,                     EIO             },
    {   ERROR_NOT_DOS_DISK,             EACCES          },
    {   ERROR_SECTOR_NOT_FOUND,         EACCES          },
    {   ERROR_OUT_OF_PAPER,             EACCES          },
    {   ERROR_WRITE_FAULT,              EIO             },
    {   ERROR_READ_FAULT,               EIO             },
    {   ERROR_GEN_FAILURE,              EACCES          },
    {   ERROR_LOCK_VIOLATION,           EACCES          },
    {   ERROR_SHARING_VIOLATION,        EACCES          },
    {   ERROR_WRONG_DISK,               EACCES          },
    {   ERROR_SHARING_BUFFER_EXCEEDED,  EACCES          },
    {   ERROR_BAD_NETPATH,              ENOENT          },
    {   ERROR_NETWORK_ACCESS_DENIED,    EACCES          },
    {   ERROR_BAD_NET_NAME,             ENOENT          },
    {   ERROR_FILE_EXISTS,              EEXIST          },
    {   ERROR_CANNOT_MAKE,              EACCES          },
    {   ERROR_FAIL_I24,                 EACCES          },
    {   ERROR_INVALID_PARAMETER,        EINVAL          },
    {   ERROR_NO_PROC_SLOTS,            EAGAIN          },
    {   ERROR_DRIVE_LOCKED,             EACCES          },
    {   ERROR_BROKEN_PIPE,              EPIPE           },
    {   ERROR_DISK_FULL,                ENOSPC          },
    {   ERROR_INVALID_TARGET_HANDLE,    EBADF           },
    {   ERROR_INVALID_HANDLE,           EINVAL          },
    {   ERROR_WAIT_NO_CHILDREN,         ECHILD          },
    {   ERROR_CHILD_NOT_COMPLETE,       ECHILD          },
    {   ERROR_DIRECT_ACCESS_HANDLE,     EBADF           },
    {   ERROR_NEGATIVE_SEEK,            EINVAL          },
    {   ERROR_SEEK_ON_DEVICE,           EACCES          },
    {   ERROR_DIR_NOT_EMPTY,            ENOTEMPTY       },
    {   ERROR_DIRECTORY,                ENOTDIR         },
    {   ERROR_NOT_LOCKED,               EACCES          },
    {   ERROR_BAD_PATHNAME,             ENOENT          },
    {   ERROR_MAX_THRDS_REACHED,        EAGAIN          },
    {   ERROR_LOCK_FAILED,              EACCES          },
    {   ERROR_ALREADY_EXISTS,           EEXIST          },
    {   ERROR_INVALID_STARTING_CODESEG, ENOEXEC         },
    {   ERROR_INVALID_STACKSEG,         ENOEXEC         },
    {   ERROR_INVALID_MODULETYPE,       ENOEXEC         },
    {   ERROR_INVALID_EXE_SIGNATURE,    ENOEXEC         },
    {   ERROR_EXE_MARKED_INVALID,       ENOEXEC         },
    {   ERROR_BAD_EXE_FORMAT,           ENOEXEC         },
    {   ERROR_ITERATED_DATA_EXCEEDS_64k,ENOEXEC         },
    {   ERROR_INVALID_MINALLOCSIZE,     ENOEXEC         },
    {   ERROR_DYNLINK_FROM_INVALID_RING,ENOEXEC         },
    {   ERROR_IOPL_NOT_ENABLED,         ENOEXEC         },
    {   ERROR_INVALID_SEGDPL,           ENOEXEC         },
    {   ERROR_AUTODATASEG_EXCEEDS_64k,  ENOEXEC         },
    {   ERROR_RING2SEG_MUST_BE_MOVABLE, ENOEXEC         },
    {   ERROR_RELOC_CHAIN_XEEDS_SEGLIM, ENOEXEC         },
    {   ERROR_INFLOOP_IN_RELOC_CHAIN,   ENOEXEC         },
    {   ERROR_FILENAME_EXCED_RANGE,     ENOENT          },
    {   ERROR_NESTING_NOT_ALLOWED,      EAGAIN          },
#ifndef ERROR_PIPE_LOCAL
#define ERROR_PIPE_LOCAL        229L
#endif
    {   ERROR_PIPE_LOCAL,               EPIPE           },
    {   ERROR_BAD_PIPE,                 EPIPE           },
    {   ERROR_PIPE_BUSY,                EAGAIN          },
    {   ERROR_NO_DATA,                  EPIPE           },
    {   ERROR_PIPE_NOT_CONNECTED,       EPIPE           },
    {   ERROR_OPERATION_ABORTED,        EINTR           },
    {   ERROR_NOT_ENOUGH_QUOTA,         ENOMEM          },
    {   ERROR_MOD_NOT_FOUND,            ENOENT          },
    {   ERROR_PRIVILEGE_NOT_HELD,       EACCES,         },
    {   ERROR_CANT_RESOLVE_FILENAME,    ELOOP,          },
    {   WSAEINTR,                       EINTR           },
    {   WSAEBADF,                       EBADF           },
    {   WSAEACCES,                      EACCES          },
    {   WSAEFAULT,                      EFAULT          },
    {   WSAEINVAL,                      EINVAL          },
    {   WSAEMFILE,                      EMFILE          },
    {   WSAEWOULDBLOCK,                 EWOULDBLOCK     },
    {   WSAEINPROGRESS,                 EINPROGRESS     },
    {   WSAEALREADY,                    EALREADY        },
    {   WSAENOTSOCK,                    ENOTSOCK        },
    {   WSAEDESTADDRREQ,                EDESTADDRREQ    },
    {   WSAEMSGSIZE,                    EMSGSIZE        },
    {   WSAEPROTOTYPE,                  EPROTOTYPE      },
    {   WSAENOPROTOOPT,                 ENOPROTOOPT     },
    {   WSAEPROTONOSUPPORT,             EPROTONOSUPPORT },
    {   WSAESOCKTNOSUPPORT,             ESOCKTNOSUPPORT },
    {   WSAEOPNOTSUPP,                  EOPNOTSUPP      },
    {   WSAEPFNOSUPPORT,                EPFNOSUPPORT    },
    {   WSAEAFNOSUPPORT,                EAFNOSUPPORT    },
    {   WSAEADDRINUSE,                  EADDRINUSE      },
    {   WSAEADDRNOTAVAIL,               EADDRNOTAVAIL   },
    {   WSAENETDOWN,                    ENETDOWN        },
    {   WSAENETUNREACH,                 ENETUNREACH     },
    {   WSAENETRESET,                   ENETRESET       },
    {   WSAECONNABORTED,                ECONNABORTED    },
    {   WSAECONNRESET,                  ECONNRESET      },
    {   WSAENOBUFS,                     ENOBUFS         },
    {   WSAEISCONN,                     EISCONN         },
    {   WSAENOTCONN,                    ENOTCONN        },
    {   WSAESHUTDOWN,                   ESHUTDOWN       },
    {   WSAETOOMANYREFS,                ETOOMANYREFS    },
    {   WSAETIMEDOUT,                   ETIMEDOUT       },
    {   WSAECONNREFUSED,                ECONNREFUSED    },
    {   WSAELOOP,                       ELOOP           },
    {   WSAENAMETOOLONG,                ENAMETOOLONG    },
    {   WSAEHOSTDOWN,                   EHOSTDOWN       },
    {   WSAEHOSTUNREACH,                EHOSTUNREACH    },
    {   WSAEPROCLIM,                    EPROCLIM        },
    {   WSAENOTEMPTY,                   ENOTEMPTY       },
    {   WSAEUSERS,                      EUSERS          },
    {   WSAEDQUOT,                      EDQUOT          },
    {   WSAESTALE,                      ESTALE          },
    {   WSAEREMOTE,                     EREMOTE         },
};
 
/* License: Ruby's */
int
rb_w32_map_errno(DWORD winerr)
{
    int i;
 
    if (winerr == 0) {
        return 0;
    }
 
    for (i = 0; i < (int)(sizeof(errmap) / sizeof(*errmap)); i++) {
        if (errmap[i].winerr == winerr) {
            return errmap[i].err;
        }
    }
 
    if (winerr >= WSABASEERR) {
        return winerr;
    }
    return EINVAL;
}
 
#define map_errno rb_w32_map_errno
 
static const char *NTLoginName;
 
static OSVERSIONINFO osver;
 
/* License: Artistic or GPL */
static void
get_version(void)
{
    memset(&osver, 0, sizeof(OSVERSIONINFO));
    osver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    GetVersionEx(&osver);
}
 
/* License: Artistic or GPL */
DWORD
rb_w32_osver(void)
{
    return osver.dwMajorVersion;
}
 
/* simulate flock by locking a range on the file */
 
/* License: Artistic or GPL */
#define LK_ERR(f,i) \
    do {                                                                \
        if (f)                                                          \
            i = 0;                                                      \
        else {                                                          \
            DWORD err = GetLastError();                                 \
            if (err == ERROR_LOCK_VIOLATION || err == ERROR_IO_PENDING) \
                errno = EWOULDBLOCK;                                    \
            else if (err == ERROR_NOT_LOCKED)                           \
                i = 0;                                                  \
            else                                                        \
                errno = map_errno(err);                                 \
        }                                                               \
    } while (0)
#define LK_LEN      ULONG_MAX
 
/* License: Artistic or GPL */
static uintptr_t
flock_winnt(uintptr_t self, int argc, uintptr_t* argv)
{
    OVERLAPPED o;
    int i = -1;
    const HANDLE fh = (HANDLE)self;
    const int oper = argc;
 
    memset(&o, 0, sizeof(o));
 
    switch (oper) {
      case LOCK_SH:             /* shared lock */
        LK_ERR(LockFileEx(fh, 0, 0, LK_LEN, LK_LEN, &o), i);
        break;
      case LOCK_EX:             /* exclusive lock */
        LK_ERR(LockFileEx(fh, LOCKFILE_EXCLUSIVE_LOCK, 0, LK_LEN, LK_LEN, &o), i);
        break;
      case LOCK_SH|LOCK_NB:     /* non-blocking shared lock */
        LK_ERR(LockFileEx(fh, LOCKFILE_FAIL_IMMEDIATELY, 0, LK_LEN, LK_LEN, &o), i);
        break;
      case LOCK_EX|LOCK_NB:     /* non-blocking exclusive lock */
        LK_ERR(LockFileEx(fh,
                          LOCKFILE_EXCLUSIVE_LOCK|LOCKFILE_FAIL_IMMEDIATELY,
                          0, LK_LEN, LK_LEN, &o), i);
        break;
      case LOCK_UN:             /* unlock lock */
      case LOCK_UN|LOCK_NB:     /* unlock is always non-blocking, I hope */
        LK_ERR(UnlockFileEx(fh, 0, LK_LEN, LK_LEN, &o), i);
        break;
      default:            /* unknown */
        errno = EINVAL;
        break;
    }
    return i;
}
 
#undef LK_ERR
 
/* License: Artistic or GPL */
int
flock(int fd, int oper)
{
    const asynchronous_func_t locker = flock_winnt;
 
    return rb_w32_asynchronize(locker,
                              (VALUE)_get_osfhandle(fd), oper, NULL,
                              (DWORD)-1);
}
 
/* License: Ruby's */
static inline WCHAR *
translate_wchar(WCHAR *p, int from, int to)
{
    for (; *p; p++) {
        if (*p == from)
            *p = to;
    }
    return p;
}
 
/* License: Ruby's */
static inline char *
translate_char(char *p, int from, int to, UINT cp)
{
    while (*p) {
        if ((unsigned char)*p == from)
            *p = to;
        p = CharNextExA(cp, p, 0);
    }
    return p;
}
 
#ifndef CSIDL_LOCAL_APPDATA
#define CSIDL_LOCAL_APPDATA 28
#endif
#ifndef CSIDL_COMMON_APPDATA
#define CSIDL_COMMON_APPDATA 35
#endif
#ifndef CSIDL_WINDOWS
#define CSIDL_WINDOWS   36
#endif
#ifndef CSIDL_SYSTEM
#define CSIDL_SYSTEM    37
#endif
#ifndef CSIDL_PROFILE
#define CSIDL_PROFILE 40
#endif
 
/* License: Ruby's */
static BOOL
get_special_folder(int n, WCHAR *buf, size_t len)
{
    LPITEMIDLIST pidl;
    LPMALLOC alloc;
    BOOL f = FALSE;
 
    if (SHGetSpecialFolderLocation(NULL, n, &pidl) == 0) {
        f = SHGetPathFromIDListEx(pidl, buf, len, 0);
        SHGetMalloc(&alloc);
        alloc->lpVtbl->Free(alloc, pidl);
        alloc->lpVtbl->Release(alloc);
    }
    return f;
}
 
/* License: Ruby's */
static void
regulate_path(WCHAR *path)
{
    WCHAR *p = translate_wchar(path, L'\\', L'/');
    if (p - path == 2 && path[1] == L':') {
        *p++ = L'/';
        *p = L'\0';
    }
}
 
/* License: Ruby's */
static FARPROC
get_proc_address(const char *module, const char *func, HANDLE *mh)
{
    HANDLE h;
    FARPROC ptr;
 
    if (mh)
        h = LoadLibrary(module);
    else
        h = GetModuleHandle(module);
    if (!h)
        return NULL;
 
    ptr = GetProcAddress(h, func);
    if (mh) {
        if (ptr)
            *mh = h;
        else
            FreeLibrary(h);
    }
    return ptr;
}
 
/* License: Ruby's */
VALUE
rb_w32_special_folder(int type)
{
    WCHAR path[PATH_MAX];
 
    if (!get_special_folder(type, path, numberof(path))) return Qnil;
    regulate_path(path);
    return rb_w32_conv_from_wchar(path, rb_filesystem_encoding());
}
 
/* License: Ruby's */
UINT
rb_w32_system_tmpdir(WCHAR *path, UINT len)
{
    static const WCHAR temp[] = L"temp";
    WCHAR *p;
 
    if (!get_special_folder(CSIDL_LOCAL_APPDATA, path, len)) {
        if (GetSystemWindowsDirectoryW(path, len)) return 0;
    }
    p = translate_wchar(path, L'\\', L'/');
    if (*(p - 1) != L'/') *p++ = L'/';
    if ((UINT)(p - path + numberof(temp)) >= len) return 0;
    memcpy(p, temp, sizeof(temp));
    return (UINT)(p - path + numberof(temp) - 1);
}
 
/*
  Return user's home directory using environment variables combinations.
  Memory allocated by this function should be manually freed
  afterwards with xfree.
 
  Try:
  HOME, USERPROFILE, HOMEDRIVE + HOMEPATH environment variables
  Special Folders - Profile and Personal
*/
WCHAR *
rb_w32_home_dir(void)
{
    WCHAR *buffer = NULL;
    size_t buffer_len = MAX_PATH, len = 0;
    enum {
        HOME_NONE, ENV_HOME, ENV_USERPROFILE, ENV_DRIVEPATH
    } home_type = HOME_NONE;
 
    if ((len = GetEnvironmentVariableW(L"HOME", NULL, 0)) != 0) {
        buffer_len = len;
        home_type = ENV_HOME;
    }
    else if ((len = GetEnvironmentVariableW(L"USERPROFILE", NULL, 0)) != 0) {
        buffer_len = len;
        home_type = ENV_USERPROFILE;
    }
    else if ((len = GetEnvironmentVariableW(L"HOMEDRIVE", NULL, 0)) != 0) {
        buffer_len = len;
        if ((len = GetEnvironmentVariableW(L"HOMEPATH", NULL, 0)) != 0) {
            buffer_len += len;
            home_type = ENV_DRIVEPATH;
        }
    }
 
    /* can't use xmalloc here, since it's called too early from init_env() */
    buffer = malloc(sizeof(WCHAR) * buffer_len);
    if (buffer == NULL) return NULL;
 
    switch (home_type) {
      case ENV_HOME:
        GetEnvironmentVariableW(L"HOME", buffer, buffer_len);
        break;
      case ENV_USERPROFILE:
        GetEnvironmentVariableW(L"USERPROFILE", buffer, buffer_len);
        break;
      case ENV_DRIVEPATH:
        len = GetEnvironmentVariableW(L"HOMEDRIVE", buffer, buffer_len);
        GetEnvironmentVariableW(L"HOMEPATH", buffer + len, buffer_len - len);
        break;
      default:
        if (!get_special_folder(CSIDL_PROFILE, buffer, buffer_len) &&
            !get_special_folder(CSIDL_PERSONAL, buffer, buffer_len)) {
            free(buffer);
            return NULL;
        }
        buffer = realloc(buffer, sizeof(WCHAR) * (lstrlenW(buffer) + 1));
        break;
    }
 
    /* sanitize backslashes with forwardslashes */
    regulate_path(buffer);
 
    return buffer;
}
 
/* License: Ruby's */
static void
init_env(void)
{
    WCHAR env[ENV_MAX];
 
    if (!GetEnvironmentVariableW(L"HOME", env, numberof(env))) {
        WCHAR *whome = rb_w32_home_dir();
        if (whome) {
            _wputenv_s(L"HOME", whome);
            free(whome);
        }
    }
 
    if (!GetEnvironmentVariableW(L"USER", env, numberof(env))) {
        DWORD len;
        if (!GetEnvironmentVariableW(L"USERNAME", env, numberof(env)) &&
            !GetUserNameW(env, (len = numberof(env), &len))) {
            NTLoginName = "<Unknown>";
        }
        else {
            _wputenv_s(L"USER", env);
            NTLoginName = rb_w32_wstr_to_mbstr(CP_UTF8, env, -1, NULL);
        }
    }
    else {
        NTLoginName = rb_w32_wstr_to_mbstr(CP_UTF8, env, -1, NULL);
    }
 
    if (!GetEnvironmentVariableW(L"TMPDIR", env, numberof(env)) &&
        !GetEnvironmentVariableW(L"TMP", env, numberof(env)) &&
        !GetEnvironmentVariableW(L"TEMP", env, numberof(env)) &&
        rb_w32_system_tmpdir(env, numberof(env))) {
        _wputenv_s(L"TMPDIR", env);
    }
}
 
static void init_stdhandle(void);
 
/* License: Ruby's */
static void
invalid_parameter(const wchar_t *expr, const wchar_t *func, const wchar_t *file, unsigned int line, uintptr_t dummy)
{
    // nothing to do
}
 
int ruby_w32_rtc_error;
 
#ifndef __MINGW32__
/* License: Ruby's */
RBIMPL_ATTR_NONNULL((5))
RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 5, 6)
static int __cdecl
rtc_error_handler(int e, const char *src, int line, const char *exe, const char *fmt, ...)
{
    va_list ap;
    VALUE str;
 
    if (!ruby_w32_rtc_error) return 0;
    str = rb_sprintf("%s:%d: ", src, line);
    va_start(ap, fmt);
    rb_str_vcatf(str, fmt, ap);
    va_end(ap);
    rb_str_cat(str, "\n", 1);
    rb_write_error2(RSTRING_PTR(str), RSTRING_LEN(str));
    return 0;
}
#endif
 
static CRITICAL_SECTION select_mutex;
 
static CRITICAL_SECTION socklist_mutex;
static st_table *socklist = NULL;
 
static CRITICAL_SECTION conlist_mutex;
static st_table *conlist = NULL;
#define conlist_disabled ((st_table *)-1)
 
#define thread_exclusive(obj) \
    for (bool exclusive_for_##obj = (EnterCriticalSection(&obj##_mutex), true); \
         exclusive_for_##obj; \
         exclusive_for_##obj = (LeaveCriticalSection(&obj##_mutex), false))
 
static CRITICAL_SECTION uenvarea_mutex;
static char *uenvarea;
 
/* License: Ruby's */
struct constat {
    struct {
        int state, seq[16], reverse;
        WORD attr;
        COORD saved;
    } vt100;
};
enum {constat_init = -2, constat_esc = -1, constat_seq = 0};
 
/* License: Ruby's */
static int
free_conlist(st_data_t key, st_data_t val, st_data_t arg)
{
    xfree((struct constat *)val);
    return ST_DELETE;
}
 
/* License: Ruby's */
static void
constat_delete(HANDLE h)
{
    thread_exclusive(conlist) {
        if (conlist && conlist != conlist_disabled) {
            st_data_t key = (st_data_t)h, val;
            st_delete(conlist, &key, &val);
            xfree((struct constat *)val);
        }
    }
}
 
/* License: Ruby's */
static void
exit_handler(void)
{
    WSACleanup();
    DeleteCriticalSection(&select_mutex);
    DeleteCriticalSection(&socklist_mutex);
    DeleteCriticalSection(&conlist_mutex);
    thread_exclusive(uenvarea) {
        if (uenvarea) {
            free(uenvarea);
            uenvarea = NULL;
        }
    }
    DeleteCriticalSection(&uenvarea_mutex);
}
 
/* License: Ruby's */
static void
vm_exit_handler(ruby_vm_t *vm)
{
    EnterCriticalSection(&socklist_mutex);
    if (socklist) {
        st_free_table(socklist);
        socklist = NULL;
    }
    LeaveCriticalSection(&socklist_mutex);
 
    EnterCriticalSection(&conlist_mutex);
    if (conlist && conlist != conlist_disabled) {
        st_foreach(conlist, free_conlist, 0);
        st_free_table(conlist);
        conlist = NULL;
    }
    LeaveCriticalSection(&conlist_mutex);
}
 
#define ATOMIC_LONG_CAS(var, oldval, newval) InterlockedCompareExchange(&(var), (newval), (oldval))
 
/* License: Ruby's */
static void
install_vm_exit_handler(void)
{
    static LONG installed = 0;
    LONG i;
 
    while ((i = ATOMIC_LONG_CAS(installed, 0, -1)) != 1) {
        if (i != 0) {
            Sleep(1);
            continue;
        }
        ruby_vm_at_exit(vm_exit_handler);
        ATOMIC_LONG_CAS(installed, -1, 1);
        break;
    }
}
 
/* License: Artistic or GPL */
static void
StartSockets(void)
{
    WORD version;
    WSADATA retdata;
 
    //
    // initialize the winsock interface and insure that it's
    // cleaned up at exit.
    //
    version = MAKEWORD(2, 0);
    if (WSAStartup(version, &retdata))
        rb_fatal("Unable to locate winsock library!");
    if (LOBYTE(retdata.wVersion) != 2)
        rb_fatal("could not find version 2 of winsock dll");
 
    InitializeCriticalSection(&select_mutex);
    InitializeCriticalSection(&socklist_mutex);
    InitializeCriticalSection(&conlist_mutex);
 
    atexit(exit_handler);
}
 
#define MAKE_SOCKDATA(af, fl)   ((int)((((int)af)<<4)|((fl)&0xFFFF)))
#define GET_FAMILY(v)           ((int)(((v)>>4)&0xFFFF))
#define GET_FLAGS(v)            ((int)((v)&0xFFFF))
 
/* License: Ruby's */
static inline int
socklist_insert(SOCKET sock, int flag)
{
    int ret;
 
    thread_exclusive(socklist) {
        if (!socklist) {
            socklist = st_init_numtable();
            install_vm_exit_handler();
        }
        ret = st_insert(socklist, (st_data_t)sock, (st_data_t)flag);
    }
 
    return ret;
}
 
/* License: Ruby's */
static inline int
socklist_lookup(SOCKET sock, int *flagp)
{
    st_data_t data;
    int ret = 0;
 
    thread_exclusive(socklist) {
        if (!socklist) continue;
        ret = st_lookup(socklist, (st_data_t)sock, &data);
        if (ret && flagp)
            *flagp = (int)data;
    }
 
    return ret;
}
 
/* License: Ruby's */
static inline int
socklist_delete(SOCKET *sockp, int *flagp)
{
    st_data_t key;
    st_data_t data;
    int ret = 0;
 
    thread_exclusive(socklist) {
        if (!socklist) continue;
        key = (st_data_t)*sockp;
        if (flagp)
            data = (st_data_t)*flagp;
        ret = st_delete(socklist, &key, &data);
        if (ret) {
            *sockp = (SOCKET)key;
            if (flagp)
                *flagp = (int)data;
        }
    }
 
    return ret;
}
 
# ifdef __MINGW32__
#  define _CrtSetReportMode(type,mode) ((void)0)
#  define _RTC_SetErrorFunc(func) ((void)0)
# endif
static void set_pioinfo_extra(void);
static int w32_cmdvector(const WCHAR *, char ***, UINT, rb_encoding *);
//
// Initialization stuff
//
 
/* License: Ruby's */
/* Enable long path names for this process, whatever the registry value
 * HKLM\SYSTEM\CurrentControlSet\Control\FileSystem\LongPathsEnabled is.  The
 * loader sets the same PEB bit for longPathAware in the manifest, but only
 * when that registry value is set, so the manifest alone is not enough on a
 * stock machine.  Undocumented, and taken from initLongPathSupport in Go's
 * runtime <https://go.dev/src/runtime/os_windows.go>, whose maintainers have
 * proposed to drop it <https://github.com/golang/go/issues/66560>.
 *
 * Called from ruby_setup, not from rb_w32_sysinit, which a program that
 * embeds libruby is not expected to call. */
void
rb_w32_init_long_paths(void)
{
    /* PEB.BitField, and the IsLongPathAwareProcess bit in it */
    enum {peb_bit_field_offset = 3, is_long_path_aware_process = 0x80};
    typedef long (WINAPI version_func)(OSVERSIONINFOW *);
    typedef void *(WINAPI peb_func)(void);
    version_func *pRtlGetVersion;
    peb_func *pRtlGetCurrentPeb;
    OSVERSIONINFOW osvi;
    BYTE *bit_field;
 
    pRtlGetVersion = (version_func *)get_proc_address("ntdll.dll", "RtlGetVersion", NULL);
    if (!pRtlGetVersion) return;
    memset(&osvi, 0, sizeof(osvi));
    osvi.dwOSVersionInfoSize = sizeof(osvi);
    if (pRtlGetVersion(&osvi)) return;
 
    /* the PEB bit is honored since Windows 10 1703 (10.0.15063) */
    if (osvi.dwMajorVersion < 10) return;
    if (osvi.dwMajorVersion == 10 && osvi.dwMinorVersion == 0 &&
        osvi.dwBuildNumber < 15063) return;
 
    pRtlGetCurrentPeb = (peb_func *)get_proc_address("ntdll.dll", "RtlGetCurrentPeb", NULL);
    if (!pRtlGetCurrentPeb) return;
    bit_field = (BYTE *)pRtlGetCurrentPeb() + peb_bit_field_offset;
    *bit_field |= is_long_path_aware_process;
}
 
/* License: Ruby's */
void
rb_w32_sysinit(int *argc, char ***argv)
{
    _CrtSetReportMode(_CRT_ASSERT, 0);
    _set_invalid_parameter_handler(invalid_parameter);
    _RTC_SetErrorFunc(rtc_error_handler);
    set_pioinfo_extra();
    SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOGPFAULTERRORBOX);
 
    get_version();
 
    //
    // subvert cmd.exe's feeble attempt at command line parsing
    //
    *argc = w32_cmdvector(GetCommandLineW(), argv, CP_UTF8, &OnigEncodingUTF_8);
 
    //
    // Now set up the correct time stuff
    //
 
    tzset();
 
    InitializeCriticalSection(&uenvarea_mutex);
    init_env();
 
    init_stdhandle();
 
    // Initialize Winsock
    StartSockets();
}
 
char *
getlogin(void)
{
    return (char *)NTLoginName;
}
 
#define MAXCHILDNUM 256 /* max num of child processes */
 
/* License: Ruby's */
static struct ChildRecord {
    HANDLE hProcess;    /* process handle */
    rb_pid_t pid;       /* process id */
} ChildRecord[MAXCHILDNUM];
 
/* License: Ruby's */
#define FOREACH_CHILD(v) do { \
    struct ChildRecord* v; \
    for (v = ChildRecord; v < ChildRecord + sizeof(ChildRecord) / sizeof(ChildRecord[0]); ++v)
#define END_FOREACH_CHILD } while (0)
 
/* License: Ruby's */
static struct ChildRecord *
FindChildSlot(rb_pid_t pid)
{
 
    FOREACH_CHILD(child) {
        if (child->pid == pid) {
            return child;
        }
    } END_FOREACH_CHILD;
    return NULL;
}
 
/* License: Ruby's */
static struct ChildRecord *
FindChildSlotByHandle(HANDLE h)
{
 
    FOREACH_CHILD(child) {
        if (child->hProcess == h) {
            return child;
        }
    } END_FOREACH_CHILD;
    return NULL;
}
 
/* License: Ruby's */
static void
CloseChildHandle(struct ChildRecord *child)
{
    HANDLE h = child->hProcess;
    child->hProcess = NULL;
    child->pid = 0;
    CloseHandle(h);
}
 
/* License: Ruby's */
static struct ChildRecord *
FindFreeChildSlot(void)
{
    FOREACH_CHILD(child) {
        if (!child->pid) {
            child->pid = -1;    /* lock the slot */
            child->hProcess = NULL;
            return child;
        }
    } END_FOREACH_CHILD;
    return NULL;
}
 
 
#define InternalCmdsMax 8
static const char szInternalCmds[][InternalCmdsMax+1] = {
    "assoc",
    "break",
    "call",
    "cd",
    "chdir",
    "cls",
    "color",
    "copy",
    "date",
    "del",
    "dir",
    "echo",
    "endlocal",
    "erase",
    "exit",
    "for",
    "ftype",
    "goto",
    "if",
    "md",
    "mkdir",
    "mklink",
    "move",
    "path",
    "pause",
    "popd",
    "prompt",
    "pushd",
    "rd",
    "rem",
    "ren",
    "rename",
    "rmdir",
    "set",
    "setlocal",
    "shift",
    "start",
    "time",
    "title",
    "type",
    "ver",
    "verify",
    "vol",
};
 
/* License: Ruby's */
static int
internal_match(const void *key, const void *elem)
{
    return strncmp(key, elem, InternalCmdsMax);
}
 
static int internal_cmd_match(const char *cmdname);
 
/* License: Ruby's */
static int
is_internal_cmd(const char *cmd)
{
    char cmdname[InternalCmdsMax+1], *b = cmdname, c;
 
    do {
        if (!(c = *cmd++)) return 0;
    } while (isspace(c));
    if (c == '@')
        return 1;
    while (isalpha(c)) {
        *b++ = tolower(c);
        if (b == cmdname + sizeof(cmdname)) return 0;
        c = *cmd++;
    }
    if (c == '.') c = *cmd;
    switch (c) {
      case '<': case '>': case '|':
        return 1;
      case '\0': case ' ': case '\t': case '\n':
        break;
      default:
        return 0;
    }
    *b = 0;
    return internal_cmd_match(cmdname);
}
 
/* License: Ruby's */
static int
internal_cmd_match(const char *cmdname)
{
    char *nm;
 
    nm = bsearch(cmdname, szInternalCmds,
                 numberof(szInternalCmds),
                 sizeof(*szInternalCmds),
                 internal_match);
 
    return !!nm;
}
 
/* License: Ruby's */
SOCKET
rb_w32_get_osfhandle(int fh)
{
    return _get_osfhandle(fh);
}
 
/* License: Ruby's */
static int
join_argv(char *cmd, char *const *argv, BOOL escape, UINT cp, int backslash, BOOL quote_bs)
{
    const char *p, *s;
    char *q, *const *t;
    int len, n, bs, quote;
 
    for (t = argv, q = cmd, len = 0; (p = *t) != 0; t++) {
        quote = 0;
        s = p;
        if (!*p || strpbrk(p, " \t\"'")) {
            quote = 1;
            len++;
            if (q) *q++ = '"';
        }
        for (bs = 0; *p; ++p) {
            switch (*p) {
              case '\\':
                ++bs;
                break;
              case '"':
                len += n = p - s;
                if (q) {
                    memcpy(q, s, n);
                    q += n;
                }
                s = p;
                len += ++bs;
                if (q) {
                    memset(q, '\\', bs);
                    q += bs;
                }
                bs = 0;
                break;
              case '<': case '>': case '|': case '^':
                if (escape && !quote) {
                    len += (n = p - s) + 1;
                    if (q) {
                        memcpy(q, s, n);
                        q += n;
                        *q++ = '^';
                    }
                    s = p;
                    break;
                }
              default:
                bs = 0;
                p = CharNextExA(cp, p, 0) - 1;
                break;
            }
        }
        len += (n = p - s) + 1;
        if (quote) len += (quote_bs ? bs : 0) + 1;
        if (q) {
            memcpy(q, s, n);
            if (backslash > 0) {
                --backslash;
                q[n] = 0;
                translate_char(q, '/', '\\', cp);
            }
            q += n;
            if (quote) {
                // See [Bug #22199]
                if (quote_bs && bs) {
                    memset(q, '\\', bs);
                    q += bs;
                }
                *q++ = '"';
            }
            *q++ = ' ';
        }
    }
    if (q > cmd) --len;
    if (q) {
        if (q > cmd) --q;
        *q = '\0';
    }
    return len;
}
 
/* License: Ruby's */
#define STRNDUPV(ptr, v, src, len)                                      \
    (((char *)memcpy(((ptr) = ALLOCV((v), (len) + 1)), (src), (len)))[len] = 0)
 
/* License: Ruby's */
static int
check_spawn_mode(int mode)
{
    switch (mode) {
      case P_NOWAIT:
      case P_OVERLAY:
        return 0;
      default:
        errno = EINVAL;
        return -1;
    }
}
 
/* License: Ruby's */
static rb_pid_t
child_result(struct ChildRecord *child, int mode)
{
    DWORD exitcode;
 
    if (!child) {
        return -1;
    }
 
    if (mode == P_OVERLAY) {
        WaitForSingleObject(child->hProcess, INFINITE);
        GetExitCodeProcess(child->hProcess, &exitcode);
        CloseChildHandle(child);
        _exit(exitcode);
    }
    return child->pid;
}
 
/* License: Ruby's */
static int
CreateChild(struct ChildRecord *child, const WCHAR *cmd, const WCHAR *prog, HANDLE hInput, HANDLE hOutput, HANDLE hError, DWORD dwCreationFlags)
{
    BOOL fRet;
    STARTUPINFOW aStartupInfo;
    PROCESS_INFORMATION aProcessInformation;
    SECURITY_ATTRIBUTES sa;
 
    if (!cmd && !prog) {
        errno = EFAULT;
        return FALSE;
    }
 
    if (!child) {
        errno = EAGAIN;
        return FALSE;
    }
 
    sa.nLength              = sizeof(SECURITY_ATTRIBUTES);
    sa.lpSecurityDescriptor = NULL;
    sa.bInheritHandle       = TRUE;
 
    memset(&aStartupInfo, 0, sizeof(aStartupInfo));
    memset(&aProcessInformation, 0, sizeof(aProcessInformation));
    aStartupInfo.cb = sizeof(aStartupInfo);
    aStartupInfo.dwFlags = STARTF_USESTDHANDLES;
    if (hInput) {
        aStartupInfo.hStdInput  = hInput;
    }
    else {
        aStartupInfo.hStdInput  = GetStdHandle(STD_INPUT_HANDLE);
    }
    if (hOutput) {
        aStartupInfo.hStdOutput = hOutput;
    }
    else {
        aStartupInfo.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    }
    if (hError) {
        aStartupInfo.hStdError = hError;
    }
    else {
        aStartupInfo.hStdError = GetStdHandle(STD_ERROR_HANDLE);
    }
 
    dwCreationFlags |= NORMAL_PRIORITY_CLASS;
 
    if (lstrlenW(cmd) > 32767) {
        child->pid = 0;         /* release the slot */
        errno = E2BIG;
        return FALSE;
    }
 
    RUBY_CRITICAL {
        fRet = CreateProcessW(prog, (WCHAR *)cmd, &sa, &sa,
                              sa.bInheritHandle, dwCreationFlags, NULL, NULL,
                              &aStartupInfo, &aProcessInformation);
        errno = map_errno(GetLastError());
    }
 
    if (!fRet) {
        child->pid = 0;         /* release the slot */
        return FALSE;
    }
 
    CloseHandle(aProcessInformation.hThread);
 
    child->hProcess = aProcessInformation.hProcess;
    child->pid = (rb_pid_t)aProcessInformation.dwProcessId;
 
    return TRUE;
}
 
/* License: Ruby's */
static int
is_batch(const char *cmd)
{
    int len = strlen(cmd);
    if (len <= 4) return 0;
    cmd += len - 4;
    if (*cmd++ != '.') return 0;
    if (strcasecmp(cmd, "bat") == 0) return 1;
    if (strcasecmp(cmd, "cmd") == 0) return 1;
    return 0;
}
 
#define filecp rb_w32_filecp
#define mbstr_to_wstr rb_w32_mbstr_to_wstr
#define wstr_to_mbstr rb_w32_wstr_to_mbstr
#define acp_to_wstr(str, plen) mbstr_to_wstr(CP_ACP, str, -1, plen)
#define wstr_to_acp(str, plen) wstr_to_mbstr(CP_ACP, str, -1, plen)
#define filecp_to_wstr(str, plen) mbstr_to_wstr(filecp(), str, -1, plen)
#define wstr_to_filecp(str, plen) wstr_to_mbstr(filecp(), str, -1, plen)
#define utf8_to_wstr(str, plen) mbstr_to_wstr(CP_UTF8, str, -1, plen)
#define wstr_to_utf8(str, plen) wstr_to_mbstr(CP_UTF8, str, -1, plen)
 
/* License: Artistic or GPL */
static rb_pid_t
w32_spawn(int mode, const char *cmd, const char *prog, UINT cp)
{
    char fbuf[PATH_MAX];
    char *p = NULL;
    const char *shell = NULL;
    WCHAR *wcmd = NULL, *wshell = NULL;
    int e = 0;
    rb_pid_t ret = -1;
    VALUE v = 0;
    VALUE v2 = 0;
    int sep = 0;
    char *cmd_sep = NULL;
 
    if (check_spawn_mode(mode)) return -1;
 
    if (prog) {
        if (!(p = dln_find_exe_r(prog, NULL, fbuf, sizeof(fbuf)))) {
            shell = prog;
        }
        else {
            shell = p;
            translate_char(p, '/', '\\', cp);
        }
    }
    else {
        int redir = -1;
        while (ISSPACE(*cmd)) cmd++;
        if ((shell = w32_getenv("RUBYSHELL", cp)) && (redir = has_redirection(cmd, cp))) {
            size_t shell_len = strlen(shell);
            size_t cmd_len = strlen(cmd) + sizeof(" -c ") + 2;
            char *tmp = ALLOCV(v, shell_len + cmd_len);
            memcpy(tmp, shell, shell_len + 1);
            translate_char(tmp, '/', '\\', cp);
            snprintf(tmp + shell_len, cmd_len, " -c \"%s\"", cmd);
            cmd = tmp;
        }
        else if ((shell = w32_getenv("COMSPEC", cp)) &&
                 ((redir < 0 ? has_redirection(cmd, cp) : redir) || is_internal_cmd(cmd))) {
            size_t cmd_len = strlen(shell) + strlen(cmd) + sizeof(" /c \"\"");
            char *tmp = ALLOCV(v, cmd_len);
            snprintf(tmp, cmd_len, "%s /c \"%s\"", shell, cmd);
            cmd = tmp;
        }
        else {
            int len = 0, quote = (*cmd == '"') ? '"' : (*cmd == '\'') ? '\'' : 0;
            int slash = 0;
            for (prog = cmd + !!quote;; prog = CharNextExA(cp, prog, 0)) {
                if (*prog == '/') slash = 1;
                if (!*prog) {
                    len = prog - cmd;
                    if (slash) {
                        STRNDUPV(p, v2, cmd, len);
                        cmd = p;
                    }
                    shell = cmd;
                    break;
                }
                if ((unsigned char)*prog == quote) {
                    len = prog++ - cmd - 1;
                    STRNDUPV(p, v2, cmd + 1, len);
                    shell = p;
                    break;
                }
                if (quote) continue;
                if (ISSPACE(*prog) || strchr("<>|*?\"", *prog)) {
                    len = prog - cmd;
                    STRNDUPV(p, v2, cmd, len + (slash ? strlen(prog) : 0));
                    if (slash) {
                        cmd = p;
                        sep = *(cmd_sep = &p[len]);
                        *cmd_sep = '\0';
                    }
                    shell = p;
                    break;
                }
            }
            shell = dln_find_exe_r(shell, NULL, fbuf, sizeof(fbuf));
            if (p && slash) translate_char(p, '/', '\\', cp);
            if (!shell) {
                shell = p ? p : cmd;
            }
            else {
                len = strlen(shell);
                if (strchr(shell, ' ')) quote = -1;
                if (shell == fbuf) {
                    p = fbuf;
                }
                else if (shell != p && strchr(shell, '/')) {
                    STRNDUPV(p, v2, shell, len);
                    shell = p;
                }
                if (p) translate_char(p, '/', '\\', cp);
                if (is_batch(shell)) {
                    int alen = strlen(prog);
                    cmd = p = ALLOCV(v, len + alen + (quote ? 2 : 0) + 1);
                    if (quote) *p++ = '"';
                    memcpy(p, shell, len);
                    p += len;
                    if (quote) *p++ = '"';
                    memcpy(p, prog, alen + 1);
                    shell = 0;
                }
            }
        }
    }
 
    if (!e && shell && !(wshell = mbstr_to_wstr(cp, shell, -1, NULL))) e = E2BIG;
    if (cmd_sep) *cmd_sep = sep;
    if (!e && cmd && !(wcmd = mbstr_to_wstr(cp, cmd, -1, NULL))) e = E2BIG;
    if (v2) ALLOCV_END(v2);
    if (v) ALLOCV_END(v);
 
    if (!e) {
        struct ChildRecord *child = FindFreeChildSlot();
        if (CreateChild(child, wcmd, wshell, NULL, NULL, NULL, 0)) {
            ret = child_result(child, mode);
        }
    }
    free(wshell);
    free(wcmd);
    if (e) errno = e;
    return ret;
}
 
/* License: Ruby's */
rb_pid_t
rb_w32_spawn(int mode, const char *cmd, const char *prog)
{
    /* assume ACP */
    return w32_spawn(mode, cmd, prog, filecp());
}
 
/* License: Ruby's */
rb_pid_t
rb_w32_uspawn(int mode, const char *cmd, const char *prog)
{
    return w32_spawn(mode, cmd, prog, CP_UTF8);
}
 
/* License: Artistic or GPL */
static rb_pid_t
w32_spawn_process(int mode, const char *prog, char *const *argv,
                  int in_fd, int out_fd, int err_fd, DWORD flags, UINT cp)
{
    int c_switch = 0;
    size_t len;
    const char *shell;
    char *cmd, fbuf[PATH_MAX];
    WCHAR *wcmd = NULL, *wprog = NULL;
    int e = 0;
    rb_pid_t ret = -1;
    VALUE v = 0;
    HANDLE in_handle = NULL, out_handle = NULL, err_handle = NULL;
 
    if (check_spawn_mode(mode)) return -1;
 
    if (in_fd >= 0) {
        in_handle = (HANDLE)rb_w32_get_osfhandle(in_fd);
    }
    if (out_fd >= 0) {
        out_handle = (HANDLE)rb_w32_get_osfhandle(out_fd);
    }
    if (err_fd >= 0) {
        err_handle = (HANDLE)rb_w32_get_osfhandle(err_fd);
    }
 
    if (!prog) prog = argv[0];
    if ((shell = w32_getenv("COMSPEC", cp)) && internal_cmd_match(prog)) {
        prog = shell;
        c_switch = 1;
    }
    else if ((cmd = dln_find_exe_r(prog, NULL, fbuf, sizeof(fbuf)))) {
        if (cmd == prog) strlcpy(cmd = fbuf, prog, sizeof(fbuf));
        translate_char(cmd, '/', '\\', cp);
        prog = cmd;
    }
    else if (strchr(prog, '/')) {
        len = strlen(prog);
        if (len < sizeof(fbuf))
            strlcpy(cmd = fbuf, prog, sizeof(fbuf));
        else
            STRNDUPV(cmd, v, prog, len);
        translate_char(cmd, '/', '\\', cp);
        prog = cmd;
    }
    if (c_switch || is_batch(prog)) {
        char *progs[2];
        progs[0] = (char *)prog;
        progs[1] = NULL;
        len = join_argv(NULL, progs, TRUE, cp, 1, FALSE);
        if (c_switch) len += 3;
        else ++argv;
        if (argv[0]) len += join_argv(NULL, argv, TRUE, cp, 0, FALSE);
        cmd = ALLOCV(v, len);
        join_argv(cmd, progs, TRUE, cp, 1, FALSE);
        if (c_switch) strlcat(cmd, " /c", len);
        if (argv[0]) join_argv(cmd + strlcat(cmd, " ", len), argv, TRUE, cp, 0, FALSE);
        prog = c_switch ? shell : 0;
    }
    else {
        len = join_argv(NULL, argv, FALSE, cp, 1, TRUE);
        cmd = ALLOCV(v, len);
        join_argv(cmd, argv, FALSE, cp, 1, TRUE);
    }
 
    if (!e && cmd && !(wcmd = mbstr_to_wstr(cp, cmd, -1, NULL))) e = E2BIG;
    if (v) ALLOCV_END(v);
    if (!e && prog && !(wprog = mbstr_to_wstr(cp, prog, -1, NULL))) e = E2BIG;
 
    if (!e) {
        struct ChildRecord *child = FindFreeChildSlot();
        if (CreateChild(child, wcmd, wprog, in_handle, out_handle, err_handle, flags)) {
            ret = child_result(child, mode);
        }
    }
    free(wprog);
    free(wcmd);
    if (e) errno = e;
    return ret;
}
 
/* License: Ruby's */
rb_pid_t
rb_w32_aspawn_flags(int mode, const char *prog, char *const *argv, DWORD flags)
{
    /* assume ACP */
    return w32_spawn_process(mode, prog, argv, -1, -1, -1, flags, filecp());
}
 
/* License: Ruby's */
rb_pid_t
rb_w32_uaspawn_flags(int mode, const char *prog, char *const *argv, DWORD flags)
{
    return w32_spawn_process(mode, prog, argv, -1, -1, -1, flags, CP_UTF8);
}
 
/* License: Ruby's */
rb_pid_t
rb_w32_aspawn(int mode, const char *prog, char *const *argv)
{
    return w32_spawn_process(mode, prog, argv, -1, -1, -1, 0, filecp());
}
 
/* License: Ruby's */
rb_pid_t
rb_w32_uaspawn(int mode, const char *prog, char *const *argv)
{
    return rb_w32_uaspawn_flags(mode, prog, argv, 0);
}
 
/* License: Ruby's */
rb_pid_t
rb_w32_uspawn_process(int mode, const char *prog, char *const *argv,
                      int in_fd, int out_fd, int err_fd, DWORD flags)
{
    return w32_spawn_process(mode, prog, argv, in_fd, out_fd, err_fd,
                             flags, CP_UTF8);
}
 
/* License: Artistic or GPL */
typedef struct _NtCmdLineElement {
    struct _NtCmdLineElement *next;
    char *str;
    long len;
    int flags;
} NtCmdLineElement;
 
//
// Possible values for flags
//
 
#define NTGLOB   0x1    // element contains a wildcard
#define NTMALLOC 0x2    // string in element was malloc'ed
#define NTSTRING 0x4    // element contains a quoted string
 
/* License: Ruby's */
static int
insert(const char *path, VALUE vinfo, void *enc)
{
    NtCmdLineElement *tmpcurr;
    NtCmdLineElement ***tail = (NtCmdLineElement ***)vinfo;
 
    tmpcurr = (NtCmdLineElement *)malloc(sizeof(NtCmdLineElement));
    if (!tmpcurr) return -1;
    MEMZERO(tmpcurr, NtCmdLineElement, 1);
    tmpcurr->len = strlen(path);
    tmpcurr->str = strdup(path);
    if (!tmpcurr->str) return -1;
    tmpcurr->flags |= NTMALLOC;
    **tail = tmpcurr;
    *tail = &tmpcurr->next;
 
    return 0;
}
 
/* License: Artistic or GPL */
static NtCmdLineElement **
cmdglob(NtCmdLineElement *patt, NtCmdLineElement **tail, UINT cp, rb_encoding *enc)
{
    char buffer[PATH_MAX], *buf = buffer;
    NtCmdLineElement **last = tail;
    int status;
 
    if (patt->len >= PATH_MAX)
        if (!(buf = malloc(patt->len + 1))) return 0;
 
    memcpy(buf, patt->str, patt->len);
    buf[patt->len] = '\0';
    translate_char(buf, '\\', '/', cp);
    status = ruby_brace_glob_with_enc(buf, 0, insert, (VALUE)&tail, enc);
    if (buf != buffer)
        free(buf);
 
    if (status || last == tail) return 0;
    if (patt->flags & NTMALLOC)
        free(patt->str);
    free(patt);
    return tail;
}
 
//
// Check a command string to determine if it has I/O redirection
// characters that require it to be executed by a command interpreter
//
 
/* License: Artistic or GPL */
static int
has_redirection(const char *cmd, UINT cp)
{
    char quote = '\0';
    const char *ptr;
 
    //
    // Scan the string, looking for redirection characters (< or >), pipe
    // character (|) or newline (\n) that are not in a quoted string
    //
 
    for (ptr = cmd; *ptr;) {
        switch (*ptr) {
          case '\'':
          case '\"':
            if (!quote)
                quote = *ptr;
            else if (quote == *ptr)
                quote = '\0';
            ptr++;
            break;
 
          case '>':
          case '<':
          case '|':
          case '&':
          case '\n':
            if (!quote)
                return TRUE;
            ptr++;
            break;
 
          case '%':
            if (*++ptr != '_' && !ISALPHA(*ptr)) break;
            while (*++ptr == '_' || ISALNUM(*ptr));
            if (*ptr && *ptr++ == '%') return TRUE;
            break;
 
          case '\\':
            ptr++;
          default:
            ptr = CharNextExA(cp, ptr, 0);
            break;
        }
    }
    return FALSE;
}
 
/* License: Ruby's */
static inline WCHAR *
skipspace(WCHAR *ptr)
{
    while (ISSPACE(*ptr))
        ptr++;
    return ptr;
}
 
/* License: Artistic or GPL */
static int
w32_cmdvector(const WCHAR *cmd, char ***vec, UINT cp, rb_encoding *enc)
{
    int globbing, len;
    int elements, strsz, done;
    int slashes, escape;
    WCHAR *ptr, *base, *cmdline;
    char *cptr, *buffer;
    char **vptr;
    WCHAR quote;
    NtCmdLineElement *curr, **tail;
    NtCmdLineElement *cmdhead = NULL, **cmdtail = &cmdhead;
 
    //
    // just return if we don't have a command line
    //
    while (ISSPACE(*cmd))
        cmd++;
    if (!*cmd) {
        *vec = NULL;
        return 0;
    }
 
    ptr = cmdline = wcsdup(cmd);
 
    //
    // Ok, parse the command line, building a list of CmdLineElements.
    // When we've finished, and it's an input command (meaning that it's
    // the processes argv), we'll do globing and then build the argument
    // vector.
    // The outer loop does one iteration for each element seen.
    // The inner loop does one iteration for each character in the element.
    //
 
    while (*(ptr = skipspace(ptr))) {
        base = ptr;
        quote = slashes = globbing = escape = 0;
        for (done = 0; !done && *ptr; ) {
            //
            // Switch on the current character. We only care about the
            // white-space characters, the  wild-card characters, and the
            // quote characters.
            //
 
            switch (*ptr) {
              case L'\\':
                if (quote != L'\'') slashes++;
                break;
 
              case L' ':
              case L'\t':
              case L'\n':
                //
                // if we're not in a string, then we're finished with this
                // element
                //
 
                if (!quote) {
                    *ptr = 0;
                    done = 1;
                }
                slashes = 0;
                break;
 
              case L'*':
              case L'?':
              case L'[':
              case L'{':
                //
                // record the fact that this element has a wildcard character
                // N.B. Don't glob if inside a single quoted string
                //
 
                if (quote != L'\'')
                    globbing++;
                slashes = 0;
                break;
 
              case L'\'':
              case L'\"':
                //
                // if we're already in a string, see if this is the
                // terminating close-quote. If it is, we're finished with
                // the string, but not necessarily with the element.
                // If we're not already in a string, start one.
                //
 
                if (!(slashes & 1)) {
                    if (!quote)
                        quote = *ptr;
                    else if (quote == *ptr) {
                        if (quote == L'"' && quote == ptr[1])
                            ptr++;
                        quote = L'\0';
                    }
                }
                escape++;
                slashes = 0;
                break;
 
              default:
                ptr = CharNextW(ptr);
                slashes = 0;
                continue;
            }
            ptr++;
        }
 
        //
        // when we get here, we've got a pair of pointers to the element,
        // base and ptr. Base points to the start of the element while ptr
        // points to the character following the element.
        //
 
        len = ptr - base;
        if (done) --len;
 
        //
        // if it's an input vector element and it's enclosed by quotes,
        // we can remove them.
        //
 
        if (escape) {
            WCHAR *p = base, c;
            slashes = quote = 0;
            while (p < base + len) {
                switch (c = *p) {
                  case L'\\':
                    p++;
                    if (quote != L'\'') slashes++;
                    break;
 
                  case L'\'':
                  case L'"':
                    if (!(slashes & 1) && quote && quote != c) {
                        p++;
                        slashes = 0;
                        break;
                    }
                    memcpy(p - ((slashes + 1) >> 1), p + (~slashes & 1),
                           sizeof(WCHAR) * (base + len - p));
                    len -= ((slashes + 1) >> 1) + (~slashes & 1);
                    p -= (slashes + 1) >> 1;
                    if (!(slashes & 1)) {
                        if (quote) {
                            if (quote == L'"' && quote == *p)
                                p++;
                            quote = L'\0';
                        }
                        else
                            quote = c;
                    }
                    else
                        p++;
                    slashes = 0;
                    break;
 
                  default:
                    p = CharNextW(p);
                    slashes = 0;
                    break;
                }
            }
        }
 
        curr = (NtCmdLineElement *)calloc(1, sizeof(NtCmdLineElement));
        if (!curr) goto do_nothing;
        curr->str = rb_w32_wstr_to_mbstr(cp, base, len, &curr->len);
        curr->flags |= NTMALLOC;
 
        if (globbing && (tail = cmdglob(curr, cmdtail, cp, enc))) {
            cmdtail = tail;
        }
        else {
            *cmdtail = curr;
            cmdtail = &curr->next;
        }
    }
 
    //
    // Almost done!
    // Count up the elements, then allocate space for a vector of pointers
    // (argv) and a string table for the elements.
    //
 
    for (elements = 0, strsz = 0, curr = cmdhead; curr; curr = curr->next) {
        elements++;
        strsz += (curr->len + 1);
    }
 
    len = (elements+1)*sizeof(char *) + strsz;
    buffer = (char *)malloc(len);
    if (!buffer) {
      do_nothing:
        while ((curr = cmdhead) != 0) {
            cmdhead = curr->next;
            if (curr->flags & NTMALLOC) free(curr->str);
            free(curr);
        }
        free(cmdline);
        for (vptr = *vec; *vptr; ++vptr);
        return vptr - *vec;
    }
 
    //
    // make vptr point to the start of the buffer
    // and cptr point to the area we'll consider the string table.
    //
    //   buffer (*vec)
    //   |
    //   V       ^---------------------V
    //   +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
    //   |   |       | ....  | NULL  |   | ..... |\0 |   | ..... |\0 |...
    //   +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
    //   |-  elements+1             -| ^ 1st element   ^ 2nd element
 
    vptr = (char **) buffer;
 
    cptr = buffer + (elements+1) * sizeof(char *);
 
    while ((curr = cmdhead) != 0) {
        memcpy(cptr, curr->str, curr->len);
        cptr[curr->len] = '\0';
        *vptr++ = cptr;
        cptr += curr->len + 1;
        cmdhead = curr->next;
        if (curr->flags & NTMALLOC) free(curr->str);
        free(curr);
    }
    *vptr = 0;
 
    *vec = (char **) buffer;
    free(cmdline);
    return elements;
}
 
//
// UNIX compatible directory access functions for NT
//
 
/* License: Ruby's */
/* TODO: better name */
static HANDLE
open_special(const WCHAR *path, DWORD access, DWORD flags)
{
    const DWORD share_mode =
        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
    return CreateFileW(path, access, share_mode, NULL, OPEN_EXISTING,
                       FILE_FLAG_BACKUP_SEMANTICS|flags, NULL);
}
 
//
// The idea here is to read all the directory names into a string table
// (separated by nulls) and when one of the other dir functions is called
// return the pointer to the current file name.
//
 
/* License: Ruby's */
#define GetBit(bits, i) ((bits)[(i) / CHAR_BIT] &  (1 << (i) % CHAR_BIT))
#define SetBit(bits, i) ((bits)[(i) / CHAR_BIT] |= (1 << (i) % CHAR_BIT))
 
#define BitOfIsDir(n) ((n) * 2)
#define BitOfIsRep(n) ((n) * 2 + 1)
#define DIRENT_PER_CHAR (CHAR_BIT / 2)
 
static const WCHAR namespace_prefix[] = {L'\\', L'\\', L'?', L'\\'};
 
/* License: Ruby's */
/* returns 0 on failure, otherwise stores tha path in `*pathptr` and
 * returns the length of that path.  The path must be freed. */
static DWORD
get_handle_pathname(HANDLE fh, WCHAR **pathptr, DWORD add)
{
    DWORD len = GetFinalPathNameByHandleW(fh, NULL, 0, 0);
    if (!len) return 0;
    WCHAR *path = malloc((len + add + 1) * sizeof(WCHAR));
    if (!(*pathptr = path)) return 0;
    len = GetFinalPathNameByHandleW(fh, path, len + 1, 0);
    if (!len) {
        free(path);
        *pathptr = NULL;
    }
    return len;
}
 
/* License: Artistic or GPL */
static HANDLE
open_dir_handle(const WCHAR *filename, WIN32_FIND_DATAW *fd)
{
    HANDLE fh;
    int wildcard_len = rb_strlen_lit("\\*");
    WCHAR *fullname = 0;
    WCHAR *p;
    int len = 0;
 
    //
    // Create the search pattern
    //
 
    fh = open_special(filename, 0, 0);
    if (fh != INVALID_HANDLE_VALUE) {
        len = get_handle_pathname(fh, &fullname, wildcard_len);
        CloseHandle(fh);
    }
    if (!len) {
        len = lstrlenW(filename);
        fullname = malloc((len + wildcard_len + 1) * sizeof(WCHAR));
        if (!fullname) return INVALID_HANDLE_VALUE;
        MEMCPY(fullname, filename, WCHAR, len);
    }
    else {
        RUBY_ASSERT(fullname);
    }
    p = &fullname[len-1];
    if (!(isdirsep(*p) || *p == L':')) *++p = L'\\';
    *++p = L'*';
    *++p = L'\0';
 
    //
    // do the FindFirstFile call
    //
    fh = FindFirstFileW(fullname, fd);
    if (fh == INVALID_HANDLE_VALUE) {
        errno = map_errno(GetLastError());
    }
    free(fullname);
    return fh;
}
 
/* License: Artistic or GPL */
static DIR *
w32_wopendir(const WCHAR *wpath)
{
    struct stati128 sbuf;
    WIN32_FIND_DATAW fd;
    HANDLE fh;
    DIR *p;
    long pathlen;
    long len;
    long altlen;
    long idx;
    WCHAR *tmpW;
    char *tmp;
 
    //
    // check to see if we've got a directory
    //
    if (wstati128(wpath, &sbuf, FALSE) < 0) {
        return NULL;
    }
    if (!(sbuf.st_mode & S_IFDIR) &&
        (!ISALPHA(wpath[0]) || wpath[1] != L':' || wpath[2] != L'\0' ||
         ((1 << ((wpath[0] & 0x5f) - 'A')) & GetLogicalDrives()) == 0)) {
        errno = ENOTDIR;
        return NULL;
    }
    fh = open_dir_handle(wpath, &fd);
    if (fh == INVALID_HANDLE_VALUE) {
        return NULL;
    }
 
    //
    // Get us a DIR structure
    //
    p = calloc(1, sizeof(DIR));
    if (p == NULL)
        return NULL;
 
    pathlen = lstrlenW(wpath);
    idx = 0;
 
    //
    // loop finding all the files that match the wildcard
    // (which should be all of them in this directory!).
    // the variable idx should point one past the null terminator
    // of the previous string found.
    //
    do {
        len = lstrlenW(fd.cFileName) + 1;
        altlen = lstrlenW(fd.cAlternateFileName) + 1;
 
        //
        // bump the string table size by enough for the
        // new name and it's null terminator
        //
        tmpW = realloc(p->start, (idx + len + altlen) * sizeof(WCHAR));
        if (!tmpW) {
          error:
            rb_w32_closedir(p);
            FindClose(fh);
            errno = ENOMEM;
            return NULL;
        }
 
        p->start = tmpW;
        memcpy(&p->start[idx], fd.cFileName, len * sizeof(WCHAR));
        memcpy(&p->start[idx + len], fd.cAlternateFileName, altlen * sizeof(WCHAR));
 
        if (p->nfiles % DIRENT_PER_CHAR == 0) {
            tmp = realloc(p->bits, p->nfiles / DIRENT_PER_CHAR + 1);
            if (!tmp)
                goto error;
            p->bits = tmp;
            p->bits[p->nfiles / DIRENT_PER_CHAR] = 0;
        }
        if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
            SetBit(p->bits, BitOfIsDir(p->nfiles));
        if (fd.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) {
            WCHAR *tmppath = malloc((pathlen + len + 1) * sizeof(WCHAR));
            memcpy(tmppath, wpath, pathlen * sizeof(WCHAR));
            tmppath[pathlen] = L'\\';
            memcpy(tmppath + pathlen + 1, fd.cFileName, len * sizeof(WCHAR));
            if (rb_w32_reparse_symlink_p(tmppath))
                SetBit(p->bits, BitOfIsRep(p->nfiles));
            free(tmppath);
        }
 
        p->nfiles++;
        idx += len + altlen;
    } while (FindNextFileW(fh, &fd));
    FindClose(fh);
    p->size = idx;
    p->curr = p->start;
    return p;
}
 
/* License: Ruby's */
UINT
filecp(void)
{
    UINT cp = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
    return cp;
}
 
/* License: Ruby's */
char *
rb_w32_wstr_to_mbstr(UINT cp, const WCHAR *wstr, int clen, long *plen)
{
    char *ptr;
    int len = WideCharToMultiByte(cp, 0, wstr, clen, NULL, 0, NULL, NULL);
    if (!(ptr = malloc(len))) return 0;
    WideCharToMultiByte(cp, 0, wstr, clen, ptr, len, NULL, NULL);
    if (plen) {
        /* exclude NUL only if NUL-terminated string */
        if (clen == -1) --len;
        *plen = len;
    }
    return ptr;
}
 
/* License: Ruby's */
WCHAR *
rb_w32_mbstr_to_wstr(UINT cp, const char *str, int clen, long *plen)
{
    WCHAR *ptr;
    int len = MultiByteToWideChar(cp, 0, str, clen, NULL, 0);
    if (!(ptr = malloc(sizeof(WCHAR) * len))) return 0;
    MultiByteToWideChar(cp, 0, str, clen, ptr, len);
    if (plen) {
        /* exclude NUL only if NUL-terminated string */
        if (clen == -1) --len;
        *plen = len;
    }
    return ptr;
}
 
/* License: Ruby's */
DIR *
rb_w32_opendir(const char *filename)
{
    DIR *ret;
    WCHAR *wpath = filecp_to_wstr(filename, NULL);
    if (!wpath)
        return NULL;
    ret = w32_wopendir(wpath);
    free(wpath);
    return ret;
}
 
/* License: Ruby's */
DIR *
rb_w32_uopendir(const char *filename)
{
    DIR *ret;
    WCHAR *wpath = utf8_to_wstr(filename, NULL);
    if (!wpath)
        return NULL;
    ret = w32_wopendir(wpath);
    free(wpath);
    return ret;
}
 
//
// Move to next entry
//
 
/* License: Artistic or GPL */
static void
move_to_next_entry(DIR *dirp)
{
    if (dirp->curr) {
        dirp->loc++;
        dirp->curr += lstrlenW(dirp->curr) + 1;
        dirp->curr += lstrlenW(dirp->curr) + 1;
        if (dirp->curr >= (dirp->start + dirp->size)) {
            dirp->curr = NULL;
        }
    }
}
 
//
// Readdir just returns the current string pointer and bumps the
// string pointer to the next entry.
//
/* License: Ruby's */
static BOOL
win32_direct_conv(const WCHAR *file, const WCHAR *alt, struct direct *entry, const void *enc)
{
    UINT cp = *((UINT *)enc);
    if (!(entry->d_name = wstr_to_mbstr(cp, file, -1, &entry->d_namlen)))
        return FALSE;
    if (alt && *alt) {
        long altlen = 0;
        entry->d_altname = wstr_to_mbstr(cp, alt, -1, &altlen);
        entry->d_altlen = altlen;
    }
    return TRUE;
}
 
/* License: Ruby's */
VALUE
rb_w32_conv_from_wchar(const WCHAR *wstr, rb_encoding *enc)
{
    VALUE src;
    long len = lstrlenW(wstr);
    int encindex = rb_enc_to_index(enc);
 
    if (encindex == ENCINDEX_UTF_16LE) {
        return rb_enc_str_new((char *)wstr, len * sizeof(WCHAR), enc);
    }
    else {
#if SIZEOF_INT < SIZEOF_LONG
# error long should equal to int on Windows
#endif
        int clen = rb_long2int(len);
        len = WideCharToMultiByte(CP_UTF8, 0, wstr, clen, NULL, 0, NULL, NULL);
        src = rb_enc_str_new(0, len, rb_enc_from_index(ENCINDEX_UTF_8));
        WideCharToMultiByte(CP_UTF8, 0, wstr, clen, RSTRING_PTR(src), len, NULL, NULL);
    }
    switch (encindex) {
      case ENCINDEX_ASCII_8BIT:
      case ENCINDEX_US_ASCII:
        /* assume UTF-8 */
      case ENCINDEX_UTF_8:
        /* do nothing */
        return src;
    }
    return rb_str_conv_enc_opts(src, NULL, enc, ECONV_UNDEF_REPLACE, Qnil);
}
 
/* License: Ruby's */
char *
rb_w32_conv_from_wstr(const WCHAR *wstr, long *lenp, rb_encoding *enc)
{
    VALUE str = rb_w32_conv_from_wchar(wstr, enc);
    long len;
    char *ptr;
 
    if (NIL_P(str)) return wstr_to_utf8(wstr, lenp);
    *lenp = len = RSTRING_LEN(str);
    memcpy(ptr = malloc(len + 1), RSTRING_PTR(str), len);
    ptr[len] = '\0';
    return ptr;
}
 
/* License: Ruby's */
static BOOL
ruby_direct_conv(const WCHAR *file, const WCHAR *alt, struct direct *entry, const void *enc)
{
    if (!(entry->d_name = rb_w32_conv_from_wstr(file, &entry->d_namlen, enc)))
        return FALSE;
    if (alt && *alt) {
        long altlen = 0;
        entry->d_altname = rb_w32_conv_from_wstr(alt, &altlen, enc);
        entry->d_altlen = altlen;
    }
    return TRUE;
}
 
/* License: Artistic or GPL */
static struct direct *
readdir_internal(DIR *dirp, BOOL (*conv)(const WCHAR *, const WCHAR *, struct direct *, const void *), const void *enc)
{
    static long dummy_ino = 0;
 
    if (dirp->curr) {
 
        //
        // first set up the structure to return
        //
        free(dirp->dirstr.d_name);
        free(dirp->dirstr.d_altname);
        dirp->dirstr.d_altname = 0;
        dirp->dirstr.d_altlen = 0;
        conv(dirp->curr, dirp->curr + lstrlenW(dirp->curr) + 1, &dirp->dirstr, enc);
 
        //
        // Fake inode
        //
        dirp->dirstr.d_ino = (ino_t)(InterlockedIncrement(&dummy_ino) - 1);
 
        //
        // Attributes
        //
        /* ignore FILE_ATTRIBUTE_DIRECTORY as unreliable for reparse points */
        if (GetBit(dirp->bits, BitOfIsRep(dirp->loc)))
            dirp->dirstr.d_type = DT_LNK;
        else if (GetBit(dirp->bits, BitOfIsDir(dirp->loc)))
            dirp->dirstr.d_type = DT_DIR;
        else
            dirp->dirstr.d_type = DT_REG;
 
        //
        // Now set up for the next call to readdir
        //
 
        move_to_next_entry(dirp);
 
        return &(dirp->dirstr);
 
    }
    else
        return NULL;
}
 
/* License: Ruby's */
struct direct  *
rb_w32_readdir(DIR *dirp, rb_encoding *enc)
{
    int idx = rb_enc_to_index(enc);
    if (idx == ENCINDEX_ASCII_8BIT) {
        const UINT cp = filecp();
        return readdir_internal(dirp, win32_direct_conv, &cp);
    }
    else if (idx == ENCINDEX_UTF_8) {
        const UINT cp = CP_UTF8;
        return readdir_internal(dirp, win32_direct_conv, &cp);
    }
    else
        return readdir_internal(dirp, ruby_direct_conv, enc);
}
 
/* License: Ruby's */
struct direct  *
rb_w32_ureaddir(DIR *dirp)
{
    const UINT cp = CP_UTF8;
    return readdir_internal(dirp, win32_direct_conv, &cp);
}
 
//
// Telldir returns the current string pointer position
//
 
/* License: Artistic or GPL */
long
rb_w32_telldir(DIR *dirp)
{
    return dirp->loc;
}
 
//
// Seekdir moves the string pointer to a previously saved position
// (Saved by telldir).
 
/* License: Ruby's */
void
rb_w32_seekdir(DIR *dirp, long loc)
{
    if (dirp->loc > loc) rb_w32_rewinddir(dirp);
 
    while (dirp->curr && dirp->loc < loc) {
        move_to_next_entry(dirp);
    }
}
 
//
// Rewinddir resets the string pointer to the start
//
 
/* License: Artistic or GPL */
void
rb_w32_rewinddir(DIR *dirp)
{
    dirp->curr = dirp->start;
    dirp->loc = 0;
}
 
//
// This just free's the memory allocated by opendir
//
 
/* License: Artistic or GPL */
int
rb_w32_closedir(DIR *dirp)
{
    if (dirp) {
        free(dirp->dirstr.d_name);
        free(dirp->dirstr.d_altname);
        free(dirp->start);
        free(dirp->bits);
        free(dirp);
    }
    return 0;
}
 
typedef struct {
    union
    {
        FILE  _public_file;
        char* _ptr;
    };
 
    char*            _base;
    int              _cnt;
    long             _flags;
    long             _file;
    int              _charbuf;
    int              _bufsiz;
    char*            _tmpfname;
    CRITICAL_SECTION _lock;
} vcruntime_file;
#define FILE_COUNT(stream) ((vcruntime_file*)stream)->_cnt
#define FILE_READPTR(stream) ((vcruntime_file*)stream)->_ptr
#define FILE_FILENO(stream) ((vcruntime_file*)stream)->_file
 
/* License: Ruby's */
typedef char lowio_text_mode;
typedef char lowio_pipe_lookahead[3];
 
typedef struct {
    CRITICAL_SECTION           lock;
    intptr_t                   osfhnd;          // underlying OS file HANDLE
    __int64                    startpos;        // File position that matches buffer start
    unsigned char              osfile;          // Attributes of file (e.g., open in text mode?)
    lowio_text_mode            textmode;
    lowio_pipe_lookahead       _pipe_lookahead;
 
    uint8_t unicode          : 1; // Was the file opened as unicode?
    uint8_t utf8translations : 1; // Buffer contains translations other than CRLF
    uint8_t dbcsBufferUsed   : 1; // Is the dbcsBuffer in use?
    char    dbcsBuffer;           // Buffer for the lead byte of DBCS when converting from DBCS to Unicode
} ioinfo;
 
#if !defined _CRTIMP || defined __MINGW32__
#undef _CRTIMP
#define _CRTIMP __declspec(dllimport)
#endif
 
static ioinfo ** __pioinfo = NULL;
#define IOINFO_L2E 6
static inline ioinfo* _pioinfo(int);
 
 
#define IOINFO_ARRAY_ELTS       (1 << IOINFO_L2E)
#define _osfhnd(i)  (_pioinfo(i)->osfhnd)
#define _osfile(i)  (_pioinfo(i)->osfile)
#define rb_acrt_lowio_lock_fh(i)   EnterCriticalSection(&_pioinfo(i)->lock)
#define rb_acrt_lowio_unlock_fh(i) LeaveCriticalSection(&_pioinfo(i)->lock)
 
static size_t pioinfo_extra = 0;        /* workaround for VC++8 SP1 */
 
/* License: Ruby's */
static void
set_pioinfo_extra(void)
{
#define FUNCTION_RET 0xc3 /* ret */
#ifdef _DEBUG
# define UCRTBASE "ucrtbased.dll"
#else
# define UCRTBASE "ucrtbase.dll"
#endif
    /* get __pioinfo addr with _isatty */
    /*
     * Why Ruby depends to _pioinfo is
     * * to associate socket and fd: CRuby creates fd with dummy file handle
     *   and set socket to emulate Unix-like behavior. Without __pioinfo
     *   we need something which manages the fd number allocation
     * * to implement overlapped I/O for Windows 2000/XP
     * * to emulate fcntl(2)
     *
     * see also
     * * https://bugs.ruby-lang.org/issues/11118
     * * https://bugs.ruby-lang.org/issues/18605
     */
    char *p = (char*)get_proc_address(UCRTBASE, "_isatty", NULL);
    /* _osfile(fh) & FDEV */
 
#if defined(_M_ARM64) || defined(__aarch64__)
#define IS_INSN(pc, name) ((*(pc) & name##_mask) == name##_id)
    const int max_num_inst = 500;
    uint32_t *start = (uint32_t*)p;
    uint32_t *end_limit = (start + max_num_inst);
    uint32_t *pc = start;
 
    if (!p) {
        fprintf(stderr, "_isatty proc not found in " UCRTBASE "\n");
        _exit(1);
    }
 
    /* end of function */
    const uint32_t ret_id = 0xd65f0000;
    const uint32_t ret_mask = 0xfffffc1f;
    for(; pc < end_limit; pc++) {
        if (IS_INSN(pc, ret)) {
            break;
        }
    }
    if (pc == end_limit) {
        fprintf(stderr, "end of _isatty not found in " UCRTBASE "\n");
        _exit(1);
    }
 
    /* pioinfo instruction mark */
    const uint32_t adrp_id = 0x90000000;
    const uint32_t adrp_mask = 0x9f000000;
    const uint32_t add_id = 0x11000000;
    const uint32_t add_mask = 0x7fc00000;
    for(; pc > start; pc--) {
        if (IS_INSN(pc, adrp) && IS_INSN(pc + 1, add)) {
            break;
        }
    }
    if(pc == start) {
        fprintf(stderr, "pioinfo mark not found in " UCRTBASE "\n");
        _exit(1);
    }
 
    /* We now point to instructions that load address of __pioinfo:
     * adrp     x8, 0x1801d8000
     * add      x8, x8, #0xdb0
     * https://devblogs.microsoft.com/oldnewthing/20220809-00/?p=106955
     * The last adrp/add sequence before ret is what we are looking for.
     */
    const uint32_t adrp_insn = *pc;
    const uint32_t adrp_immhi = (adrp_insn & 0x00ffffe0) >> 5;
    const uint32_t adrp_immlo = (adrp_insn & 0x60000000) >> (5 + 19 + 5);
    const int64_t  adrp_sign  = (adrp_insn & 0x00800000) ? ~0x001fffff : 0;
    /* imm = SignExtend(immhi:immlo:Zeros(12), 64) */
    const int64_t adrp_imm = (adrp_sign | (adrp_immhi << 2) | adrp_immlo) << 12;
    /* base = PC64<63:12>:Zeros(12) */
    const uint64_t adrp_base = (uint64_t)pc & 0xfffffffffffff000;
 
    const uint32_t add_insn = *(pc + 1);
    const uint64_t add_imm = (add_insn & 0x3ffc00) >> (5 + 5);
 
    __pioinfo = (ioinfo**)(adrp_base + adrp_imm + add_imm);
#else /* _M_ARM64 */
    char *pend = p;
 
# ifdef _WIN64
    int32_t rel;
    char *rip;
    /* add rsp, _ */
#  define FUNCTION_BEFORE_RET_MARK "\x48\x83\xc4"
#  define FUNCTION_SKIP_BYTES 1
#  ifdef _DEBUG
    /* lea rcx,[__pioinfo's addr in RIP-relative 32bit addr] */
#   define PIOINFO_MARK "\x48\x8d\x0d"
#  else
    /* lea rdx,[__pioinfo's addr in RIP-relative 32bit addr] */
#   define PIOINFO_MARK "\x48\x8d\x15"
#  endif
 
# else /* x86 */
    /* pop ebp */
#  define FUNCTION_BEFORE_RET_MARK "\x5d"
    /* leave */
#  define FUNCTION_BEFORE_RET_MARK_2 "\xc9"
#  define FUNCTION_SKIP_BYTES 0
    /* mov eax,dword ptr [eax*4+100EB430h] */
#  define PIOINFO_MARK "\x8B\x04\x85"
# endif
    if (p) {
        for (pend += 10; pend < p + 500; pend++) {
            // find end of function
            if ((memcmp(pend, FUNCTION_BEFORE_RET_MARK, sizeof(FUNCTION_BEFORE_RET_MARK) - 1) == 0
# ifdef FUNCTION_BEFORE_RET_MARK_2
                || memcmp(pend, FUNCTION_BEFORE_RET_MARK_2, sizeof(FUNCTION_BEFORE_RET_MARK_2) - 1) == 0
# endif
                ) &&
                *(pend + (sizeof(FUNCTION_BEFORE_RET_MARK) - 1) + FUNCTION_SKIP_BYTES) == (char)FUNCTION_RET) {
                // search backwards from end of function
                for (pend -= (sizeof(PIOINFO_MARK) - 1); pend > p; pend--) {
                    if (memcmp(pend, PIOINFO_MARK, sizeof(PIOINFO_MARK) - 1) == 0) {
                        p = pend;
                        goto found;
                    }
                }
                break;
            }
        }
    }
    fprintf(stderr, "unexpected " UCRTBASE "\n");
    _exit(1);
 
    found:
    p += sizeof(PIOINFO_MARK) - 1;
#ifdef _WIN64
    rel = *(int32_t*)(p);
    rip = p + sizeof(int32_t);
    __pioinfo = (ioinfo**)(rip + rel);
#else
    __pioinfo = *(ioinfo***)(p);
#endif
#endif /* _M_ARM64 */
    int fd;
 
    fd = _open("NUL", O_RDONLY);
    for (pioinfo_extra = 0; pioinfo_extra <= 64; pioinfo_extra += sizeof(void *)) {
        if (_osfhnd(fd) == _get_osfhandle(fd)) {
            break;
        }
    }
    _close(fd);
 
    if (pioinfo_extra > 64) {
        /* not found, maybe something wrong... */
        pioinfo_extra = 0;
    }
}
 
static inline ioinfo*
_pioinfo(int fd)
{
    const size_t sizeof_ioinfo = sizeof(ioinfo) + pioinfo_extra;
    return (ioinfo*)((char*)__pioinfo[fd >> IOINFO_L2E] +
                     (fd & (IOINFO_ARRAY_ELTS - 1)) * sizeof_ioinfo);
}
 
#define _set_osfhnd(fh, osfh) (void)(_osfhnd(fh) = osfh)
#define _set_osflags(fh, flags) (_osfile(fh) = (flags))
 
#define FOPEN                   0x01    /* file handle open */
#define FEOFLAG                 0x02    /* end of file has been encountered */
#define FPIPE                   0x08    /* file handle refers to a pipe */
#define FNOINHERIT              0x10    /* file handle opened O_NOINHERIT */
#define FAPPEND                 0x20    /* file handle opened O_APPEND */
#define FDEV                    0x40    /* file handle refers to device */
#define FTEXT                   0x80    /* file handle is in text mode */
 
static int is_socket(SOCKET);
static int is_console(SOCKET);
 
/* License: Ruby's */
int
rb_w32_io_cancelable_p(int fd)
{
    return is_socket(TO_SOCKET(fd)) || !is_console(TO_SOCKET(fd));
}
 
/* License: Ruby's */
static int
rb_w32_open_osfhandle(intptr_t osfhandle, int flags)
{
    int fh;
    char fileflags;             /* _osfile flags */
    HANDLE hF;
 
    /* copy relevant flags from second parameter */
    fileflags = FDEV;
 
    if (flags & O_APPEND)
        fileflags |= FAPPEND;
 
    if (flags & O_TEXT)
        fileflags |= FTEXT;
 
    if (flags & O_NOINHERIT)
        fileflags |= FNOINHERIT;
 
    /* attempt to allocate a C Runtime file handle */
    hF = CreateFile("NUL", 0, 0, NULL, OPEN_ALWAYS, 0, NULL);
    fh = _open_osfhandle((intptr_t)hF, 0);
    CloseHandle(hF);
    if (fh == -1) {
        errno = EMFILE;         /* too many open files */
        _doserrno = 0L;         /* not an OS error */
    }
    else {
 
        rb_acrt_lowio_lock_fh(fh);
        /* the file is open. now, set the info in _osfhnd array */
        _set_osfhnd(fh, osfhandle);
 
        fileflags |= FOPEN;             /* mark as open */
 
        _set_osflags(fh, fileflags); /* set osfile entry */
        rb_acrt_lowio_unlock_fh(fh);
    }
    return fh;                  /* return handle */
}
 
/* License: Ruby's */
static void
init_stdhandle(void)
{
    int nullfd = -1;
    int keep = 0;
#define open_null(fd)                                           \
    (((nullfd < 0) ?                                            \
      (nullfd = open("NUL", O_RDWR)) : 0),              \
     ((nullfd == (fd)) ? (keep = 1) : dup2(nullfd, fd)),        \
     (fd))
 
    if (fileno(stdin) < 0) {
        FILE_FILENO(stdin) = open_null(0);
    }
    else {
        setmode(fileno(stdin), O_BINARY);
    }
    if (fileno(stdout) < 0) {
        FILE_FILENO(stdout) = open_null(1);
    }
    if (fileno(stderr) < 0) {
        FILE_FILENO(stderr) = open_null(2);
    }
    if (nullfd >= 0 && !keep) close(nullfd);
    setvbuf(stderr, NULL, _IONBF, 0);
 
    {
        HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
        DWORD m;
        if (GetConsoleMode(h, &m)) {
#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
#define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x4
#endif
            SetConsoleMode(h, m | ENABLE_VIRTUAL_TERMINAL_PROCESSING);
        }
    }
}
 
#undef getsockopt
 
/* License: Ruby's */
static int
is_socket(SOCKET sock)
{
    if (socklist_lookup(sock, NULL))
        return TRUE;
    else
        return FALSE;
}
 
/* License: Ruby's */
int
rb_w32_is_socket(int fd)
{
    return is_socket(TO_SOCKET(fd));
}
 
//
// Since the errors returned by the socket error function
// WSAGetLastError() are not known by the library routine strerror
// we have to roll our own.
//
 
#undef strerror
 
/* License: Artistic or GPL */
char *
rb_w32_strerror(int e)
{
    static char buffer[512];
    DWORD source = 0;
    char *p;
 
    if (e < 0)
        strlcpy(buffer, "Unknown Error", sizeof(buffer));
    else if (e > sys_nerr) {
#if WSAEWOULDBLOCK != EWOULDBLOCK
        if (e >= EADDRINUSE && e <= EWOULDBLOCK) {
            static int s = -1;
            int i;
            if (s < 0)
                for (s = 0; s < (int)(sizeof(errmap)/sizeof(*errmap)); s++)
                    if (errmap[s].winerr == WSAEWOULDBLOCK)
                        break;
            for (i = s; i < (int)(sizeof(errmap)/sizeof(*errmap)); i++)
                if (errmap[i].err == e) {
                    e = errmap[i].winerr;
                    break;
                }
        }
#endif
        if (FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
                          FORMAT_MESSAGE_IGNORE_INSERTS, &source, e,
                          MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
                          buffer, sizeof(buffer), NULL) == 0 &&
            FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
                          FORMAT_MESSAGE_IGNORE_INSERTS, &source, e, 0,
                          buffer, sizeof(buffer), NULL) == 0)
            strlcpy(buffer, "Unknown Error", sizeof(buffer));
    }
    else
        strlcpy(buffer, strerror(e), sizeof(buffer));
 
    p = buffer;
    while ((p = strpbrk(p, "\r\n")) != NULL) {
        memmove(p, p + 1, strlen(p));
    }
    return buffer;
}
 
//
// various stubs
//
 
 
// Ownership
//
// Just pretend that everyone is a superuser. NT will let us know if
// we don't really have permission to do something.
//
 
#define ROOT_UID        0
#define ROOT_GID        0
 
/* License: Artistic or GPL */
rb_uid_t
getuid(void)
{
        return ROOT_UID;
}
 
/* License: Artistic or GPL */
rb_uid_t
geteuid(void)
{
        return ROOT_UID;
}
 
/* License: Artistic or GPL */
rb_gid_t
getgid(void)
{
        return ROOT_GID;
}
 
/* License: Artistic or GPL */
rb_gid_t
getegid(void)
{
    return ROOT_GID;
}
 
/* License: Artistic or GPL */
int
setuid(rb_uid_t uid)
{
    return (uid == ROOT_UID ? 0 : -1);
}
 
/* License: Artistic or GPL */
int
setgid(rb_gid_t gid)
{
    return (gid == ROOT_GID ? 0 : -1);
}
 
//
// File system stuff
//
 
/* License: Artistic or GPL */
int
ioctl(int i, int u, ...)
{
    errno = EINVAL;
    return -1;
}
 
void
rb_w32_fdset(int fd, fd_set *set)
{
    FD_SET(fd, set);
}
 
#undef FD_CLR
 
/* License: Ruby's */
void
rb_w32_fdclr(int fd, fd_set *set)
{
    unsigned int i;
    SOCKET s = TO_SOCKET(fd);
 
    for (i = 0; i < set->fd_count; i++) {
        if (set->fd_array[i] == s) {
            memmove(&set->fd_array[i], &set->fd_array[i+1],
                    sizeof(set->fd_array[0]) * (--set->fd_count - i));
            break;
        }
    }
}
 
#undef FD_ISSET
 
/* License: Ruby's */
int
rb_w32_fdisset(int fd, fd_set *set)
{
    int ret;
    SOCKET s = TO_SOCKET(fd);
    if (s == (SOCKET)INVALID_HANDLE_VALUE)
        return 0;
    RUBY_CRITICAL {ret = __WSAFDIsSet(s, set);}
    return ret;
}
 
/* License: Ruby's */
void
rb_w32_fd_copy(rb_fdset_t *dst, const fd_set *src, int max)
{
    max = min(src->fd_count, (UINT)max);
    if ((UINT)dst->capa < (UINT)max) {
        dst->capa = (src->fd_count / FD_SETSIZE + 1) * FD_SETSIZE;
        dst->fdset = xrealloc(dst->fdset, offsetof(fd_set, fd_array) + sizeof(SOCKET) * dst->capa);
    }
 
    memcpy(dst->fdset->fd_array, src->fd_array,
           max * sizeof(src->fd_array[0]));
    dst->fdset->fd_count = src->fd_count;
}
 
/* License: Ruby's */
void
rb_w32_fd_dup(rb_fdset_t *dst, const rb_fdset_t *src)
{
    if ((UINT)dst->capa < src->fdset->fd_count) {
        dst->capa = (src->fdset->fd_count / FD_SETSIZE + 1) * FD_SETSIZE;
        dst->fdset = xrealloc(dst->fdset, offsetof(fd_set, fd_array) + sizeof(SOCKET) * dst->capa);
    }
 
    memcpy(dst->fdset->fd_array, src->fdset->fd_array,
           src->fdset->fd_count * sizeof(src->fdset->fd_array[0]));
    dst->fdset->fd_count = src->fdset->fd_count;
}
 
//
// Networking trampolines
// These are used to avoid socket startup/shutdown overhead in case
// the socket routines aren't used.
//
 
#undef select
 
/* License: Ruby's */
static int
extract_fd(rb_fdset_t *dst, fd_set *src, int (*func)(SOCKET))
{
    unsigned int s = 0;
    unsigned int m = 0;
    if (!src) return 0;
 
    while (s < src->fd_count) {
        SOCKET fd = src->fd_array[s];
 
        if (!func || (*func)(fd)) {
            if (dst) { /* move it to dst */
                unsigned int d;
 
                for (d = 0; d < dst->fdset->fd_count; d++) {
                    if (dst->fdset->fd_array[d] == fd)
                        break;
                }
                if (d == dst->fdset->fd_count) {
                    if ((int)dst->fdset->fd_count >= dst->capa) {
                        dst->capa = (dst->fdset->fd_count / FD_SETSIZE + 1) * FD_SETSIZE;
                        dst->fdset = xrealloc(dst->fdset, offsetof(fd_set, fd_array) + sizeof(SOCKET) * dst->capa);
                    }
                    dst->fdset->fd_array[dst->fdset->fd_count++] = fd;
                }
                memmove(
                    &src->fd_array[s],
                    &src->fd_array[s+1],
                    sizeof(src->fd_array[0]) * (--src->fd_count - s));
            }
            else {
                m++;
                s++;
            }
        }
        else s++;
    }
 
    return dst ? dst->fdset->fd_count : m;
}
 
/* License: Ruby's */
static int
copy_fd(fd_set *dst, fd_set *src)
{
    unsigned int s;
    if (!src || !dst) return 0;
 
    for (s = 0; s < src->fd_count; ++s) {
        SOCKET fd = src->fd_array[s];
        unsigned int d;
        for (d = 0; d < dst->fd_count; ++d) {
            if (dst->fd_array[d] == fd)
                break;
        }
        if (d == dst->fd_count) {
            dst->fd_array[dst->fd_count++] = fd;
        }
    }
 
    return dst->fd_count;
}
 
/* License: Ruby's */
static void
save_fd(SOCKET *dst, const fd_set *src)
{
    if (src) memcpy(dst, src->fd_array, src->fd_count * sizeof(SOCKET));
}
 
/* License: Ruby's */
static void
restore_fd(fd_set *dst, const SOCKET *src, UINT count)
{
    if (!dst) return;
    memcpy(dst->fd_array, src, count * sizeof(SOCKET));
    dst->fd_count = count;
}
 
/* License: Ruby's */
static int
is_not_socket(SOCKET sock)
{
    return !is_socket(sock);
}
 
/* License: Ruby's */
static int
is_pipe(SOCKET sock) /* DONT call this for SOCKET! it claims it is PIPE. */
{
    int ret;
 
    RUBY_CRITICAL {
        ret = (GetFileType((HANDLE)sock) == FILE_TYPE_PIPE);
    }
 
    return ret;
}
 
/* License: Ruby's */
static int
is_readable_pipe(SOCKET sock) /* call this for pipe only */
{
    int ret;
    DWORD n = 0;
 
    RUBY_CRITICAL {
        if (PeekNamedPipe((HANDLE)sock, NULL, 0, NULL, &n, NULL)) {
            ret = (n > 0);
        }
        else {
            ret = (GetLastError() == ERROR_BROKEN_PIPE); /* pipe was closed */
        }
    }
 
    return ret;
}
 
/* License: Ruby's */
static int
is_console(SOCKET sock) /* DONT call this for SOCKET! */
{
    int ret;
    DWORD n = 0;
    INPUT_RECORD ir;
 
    RUBY_CRITICAL {
        ret = (PeekConsoleInputW((HANDLE)sock, &ir, 1, &n));
    }
 
    return ret;
}
 
/* License: Ruby's */
static int
is_readable_console(SOCKET sock) /* call this for console only */
{
    int ret = 0;
    DWORD n = 0;
    INPUT_RECORD ir;
 
    RUBY_CRITICAL {
        if (PeekConsoleInputW((HANDLE)sock, &ir, 1, &n) && n > 0) {
            if (ir.EventType == KEY_EVENT && ir.Event.KeyEvent.bKeyDown &&
                ir.Event.KeyEvent.uChar.UnicodeChar) {
                ret = 1;
            }
            else if (ir.EventType == KEY_EVENT && !ir.Event.KeyEvent.bKeyDown &&
                ir.Event.KeyEvent.wVirtualKeyCode == VK_MENU /* ALT key */ &&
                ir.Event.KeyEvent.uChar.UnicodeChar) {
                ret = 1;
            }
            else {
                ReadConsoleInputW((HANDLE)sock, &ir, 1, &n);
            }
        }
    }
 
    return ret;
}
 
/* License: Ruby's */
static int
is_invalid_handle(SOCKET sock)
{
    return (HANDLE)sock == INVALID_HANDLE_VALUE;
}
 
/* License: Artistic or GPL */
static int
do_select(int nfds, fd_set *rd, fd_set *wr, fd_set *ex,
          struct timeval *timeout)
{
    int r = 0;
 
    if (nfds == 0) {
        if (timeout)
            rb_w32_sleep(timeout->tv_sec * 1000 + timeout->tv_usec / 1000);
        else
            rb_w32_sleep(INFINITE);
    }
    else {
        RUBY_CRITICAL {
            thread_exclusive(select) {
                r = select(nfds, rd, wr, ex, timeout);
            }
            if (r == SOCKET_ERROR) {
                errno = map_errno(WSAGetLastError());
                r = -1;
            }
        }
    }
 
    return r;
}
 
/*
 * rest -= wait
 * return 0 if rest is smaller than wait.
 */
/* License: Ruby's */
int
rb_w32_time_subtract(struct timeval *rest, const struct timeval *wait)
{
    if (rest->tv_sec < wait->tv_sec) {
        return 0;
    }
    while (rest->tv_usec < wait->tv_usec) {
        if (rest->tv_sec <= wait->tv_sec) {
            return 0;
        }
        rest->tv_sec -= 1;
        rest->tv_usec += 1000 * 1000;
    }
    rest->tv_sec -= wait->tv_sec;
    rest->tv_usec -= wait->tv_usec;
    return rest->tv_sec != 0 || rest->tv_usec != 0;
}
 
/* License: Ruby's */
static inline int
compare(const struct timeval *t1, const struct timeval *t2)
{
    if (t1->tv_sec < t2->tv_sec)
        return -1;
    if (t1->tv_sec > t2->tv_sec)
        return 1;
    if (t1->tv_usec < t2->tv_usec)
        return -1;
    if (t1->tv_usec > t2->tv_usec)
        return 1;
    return 0;
}
 
#undef Sleep
 
int rb_w32_check_interrupt(void *);     /* @internal */
 
/* @internal */
/* License: Ruby's */
int
rb_w32_select_with_thread(int nfds, fd_set *rd, fd_set *wr, fd_set *ex,
                          struct timeval *timeout, void *th)
{
    int r;
    rb_fdset_t pipe_rd;
    rb_fdset_t cons_rd;
    rb_fdset_t else_rd;
    rb_fdset_t else_wr;
    rb_fdset_t except;
    int nonsock = 0;
    struct timeval limit = {0, 0};
 
    if (nfds < 0 || (timeout && (timeout->tv_sec < 0 || timeout->tv_usec < 0))) {
        errno = EINVAL;
        return -1;
    }
 
    if (timeout) {
        if (timeout->tv_sec < 0 ||
            timeout->tv_usec < 0 ||
            timeout->tv_usec >= 1000000) {
            errno = EINVAL;
            return -1;
        }
        gettimeofday(&limit, NULL);
        limit.tv_sec += timeout->tv_sec;
        limit.tv_usec += timeout->tv_usec;
        if (limit.tv_usec >= 1000000) {
            limit.tv_usec -= 1000000;
            limit.tv_sec++;
        }
    }
 
    // assume else_{rd,wr} (other than socket, pipe reader, console reader)
    // are always readable/writable. but this implementation still has
    // problem. if pipe's buffer is full, writing to pipe will block
    // until some data is read from pipe. but ruby is single threaded system,
    // so whole system will be blocked forever.
 
    rb_fd_init(&else_rd);
    nonsock += extract_fd(&else_rd, rd, is_not_socket);
 
    rb_fd_init(&else_wr);
    nonsock += extract_fd(&else_wr, wr, is_not_socket);
 
    // check invalid handles
    if (extract_fd(NULL, else_rd.fdset, is_invalid_handle) > 0 ||
        extract_fd(NULL, else_wr.fdset, is_invalid_handle) > 0) {
        rb_fd_term(&else_wr);
        rb_fd_term(&else_rd);
        errno = EBADF;
        return -1;
    }
 
    rb_fd_init(&pipe_rd);
    extract_fd(&pipe_rd, else_rd.fdset, is_pipe); // should not call is_pipe for socket
 
    rb_fd_init(&cons_rd);
    extract_fd(&cons_rd, else_rd.fdset, is_console); // ditto
 
    rb_fd_init(&except);
    extract_fd(&except, ex, is_not_socket); // drop only
 
    r = 0;
    if (rd && (int)rd->fd_count > r) r = (int)rd->fd_count;
    if (wr && (int)wr->fd_count > r) r = (int)wr->fd_count;
    if (ex && (int)ex->fd_count > r) r = (int)ex->fd_count;
    if (nfds > r) nfds = r;
 
    {
        struct timeval rest;
        const struct timeval wait = {0, 10 * 1000}; // 10ms
        struct timeval zero = {0, 0};               // 0ms
        // the sets may hold more than FD_SETSIZE sockets
        UINT nrd = rd ? rd->fd_count : 0;
        UINT nwr = wr ? wr->fd_count : 0;
        UINT nex = ex ? ex->fd_count : 0;
        SOCKET *orig = ALLOC_N(SOCKET, nrd + nwr + nex);
 
        save_fd(orig, rd);
        save_fd(orig + nrd, wr);
        save_fd(orig + nrd + nwr, ex);
        for (;;) {
            if (th && rb_w32_check_interrupt(th) != WAIT_TIMEOUT) {
                r = -1;
                break;
            }
            if (nonsock) {
                // modifying {else,pipe,cons}_rd is safe because
                // if they are modified, function returns immediately.
                extract_fd(&else_rd, pipe_rd.fdset, is_readable_pipe);
                extract_fd(&else_rd, cons_rd.fdset, is_readable_console);
            }
 
            if (else_rd.fdset->fd_count || else_wr.fdset->fd_count) {
                r = do_select(nfds, rd, wr, ex, &zero); // polling
                if (r < 0) break; // XXX: should I ignore error and return signaled handles?
                // else_{rd,wr} came out of {rd,wr}, which have room for them
                r += copy_fd(rd, else_rd.fdset);
                r += copy_fd(wr, else_wr.fdset);
                if (ex)
                    r += ex->fd_count;
                break;
            }
            else {
                const struct timeval *dowait = &wait;
 
                r = do_select(nfds, rd, wr, ex, &zero); // polling
                if (r != 0) break; // signaled or error
 
                if (timeout) {
                    struct timeval now;
                    gettimeofday(&now, NULL);
                    rest = limit;
                    if (!rb_w32_time_subtract(&rest, &now)) break; // leave the sets empty
                    if (compare(&rest, &wait) < 0) dowait = &rest;
                }
                restore_fd(rd, orig, nrd);
                restore_fd(wr, orig + nrd, nwr);
                restore_fd(ex, orig + nrd + nwr, nex);
                Sleep(dowait->tv_sec * 1000 + (dowait->tv_usec + 999) / 1000);
            }
        }
        ruby_xfree_sized(orig, sizeof(SOCKET) * (nrd + nwr + nex));
    }
 
    rb_fd_term(&except);
    rb_fd_term(&cons_rd);
    rb_fd_term(&pipe_rd);
    rb_fd_term(&else_wr);
    rb_fd_term(&else_rd);
 
    return r;
}
 
/* License: Ruby's */
int WSAAPI
rb_w32_select(int nfds, fd_set *rd, fd_set *wr, fd_set *ex,
              struct timeval *timeout)
{
    return rb_w32_select_with_thread(nfds, rd, wr, ex, timeout, 0);
}
 
/* License: Ruby's */
static FARPROC
get_wsa_extension_function(SOCKET s, GUID guid)
{
    DWORD dmy;
    FARPROC ptr = NULL;
 
    WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &guid, sizeof(guid),
             &ptr, sizeof(ptr), &dmy, NULL, NULL);
    if (!ptr)
        errno = ENOSYS;
    return ptr;
}
 
#undef accept
 
/* License: Artistic or GPL */
int WSAAPI
rb_w32_accept(int s, struct sockaddr *addr, int *addrlen)
{
    SOCKET r;
    int fd;
 
    RUBY_CRITICAL {
        r = accept(TO_SOCKET(s), addr, addrlen);
        if (r != INVALID_SOCKET) {
            SetHandleInformation((HANDLE)r, HANDLE_FLAG_INHERIT, 0);
            fd = rb_w32_open_osfhandle((intptr_t)r, O_RDWR|O_BINARY|O_NOINHERIT);
            if (fd != -1)
                socklist_insert(r, 0);
            else
                closesocket(r);
        }
        else {
            errno = map_errno(WSAGetLastError());
            fd = -1;
        }
    }
    return fd;
}
 
#undef bind
 
/* License: Artistic or GPL */
int WSAAPI
rb_w32_bind(int s, const struct sockaddr *addr, int addrlen)
{
    int r;
 
    RUBY_CRITICAL {
        r = bind(TO_SOCKET(s), addr, addrlen);
        if (r == SOCKET_ERROR)
            errno = map_errno(WSAGetLastError());
    }
    return r;
}
 
#undef connect
 
/* License: Artistic or GPL */
int WSAAPI
rb_w32_connect(int s, const struct sockaddr *addr, int addrlen)
{
    int r;
    RUBY_CRITICAL {
        r = connect(TO_SOCKET(s), addr, addrlen);
        if (r == SOCKET_ERROR) {
            int err = WSAGetLastError();
            if (err != WSAEWOULDBLOCK)
                errno = map_errno(err);
            else
                errno = EINPROGRESS;
        }
    }
    return r;
}
 
 
#undef getpeername
 
/* License: Artistic or GPL */
int WSAAPI
rb_w32_getpeername(int s, struct sockaddr *addr, int *addrlen)
{
    int r;
    RUBY_CRITICAL {
        r = getpeername(TO_SOCKET(s), addr, addrlen);
        if (r == SOCKET_ERROR)
            errno = map_errno(WSAGetLastError());
    }
    return r;
}
 
#undef getsockname
 
/* License: Artistic or GPL */
int WSAAPI
rb_w32_getsockname(int fd, struct sockaddr *addr, int *addrlen)
{
    int sock;
    int r;
    RUBY_CRITICAL {
        sock = TO_SOCKET(fd);
        r = getsockname(sock, addr, addrlen);
        if (r == SOCKET_ERROR) {
            DWORD wsaerror = WSAGetLastError();
            if (wsaerror == WSAEINVAL) {
                int flags;
                if (socklist_lookup(sock, &flags)) {
                    int af = GET_FAMILY(flags);
                    if (af) {
                        memset(addr, 0, *addrlen);
                        addr->sa_family = af;
                        return 0;
                    }
                }
            }
            errno = map_errno(wsaerror);
        }
    }
    return r;
}
 
#undef getsockopt
 
/* License: Artistic or GPL */
int WSAAPI
rb_w32_getsockopt(int s, int level, int optname, char *optval, int *optlen)
{
    int r;
    RUBY_CRITICAL {
        r = getsockopt(TO_SOCKET(s), level, optname, optval, optlen);
        if (r == SOCKET_ERROR)
            errno = map_errno(WSAGetLastError());
    }
    /* Winsock leaves a WSA error code in SO_ERROR, but the callers expect
     * an errno as on the other platforms.  [Bug #18661] */
    if (r == 0 && level == SOL_SOCKET && optname == SO_ERROR &&
        *optlen == (int)sizeof(int)) {
        int sockerr;
        memcpy(&sockerr, optval, sizeof(sockerr));
        sockerr = map_errno(sockerr);
        memcpy(optval, &sockerr, sizeof(sockerr));
    }
    return r;
}
 
#undef ioctlsocket
 
/* License: Artistic or GPL */
int WSAAPI
rb_w32_ioctlsocket(int s, long cmd, u_long *argp)
{
    int r;
    RUBY_CRITICAL {
        r = ioctlsocket(TO_SOCKET(s), cmd, argp);
        if (r == SOCKET_ERROR)
            errno = map_errno(WSAGetLastError());
    }
    return r;
}
 
#undef listen
 
/* License: Artistic or GPL */
int WSAAPI
rb_w32_listen(int s, int backlog)
{
    int r;
    RUBY_CRITICAL {
        r = listen(TO_SOCKET(s), backlog);
        if (r == SOCKET_ERROR)
            errno = map_errno(WSAGetLastError());
    }
    return r;
}
 
#undef recv
#undef recvfrom
#undef send
#undef sendto
 
/* License: Ruby's */
static int
finish_overlapped_socket(BOOL input, SOCKET s, WSAOVERLAPPED *wol, int result, DWORD *len, DWORD size)
{
    DWORD flg;
    int err;
 
    if (result != SOCKET_ERROR)
        *len = size;
    else if ((err = WSAGetLastError()) == WSA_IO_PENDING) {
        switch (rb_w32_wait_events_blocking(&wol->hEvent, 1, INFINITE)) {
          case WAIT_OBJECT_0:
            RUBY_CRITICAL {
                result = WSAGetOverlappedResult(s, wol, &size, TRUE, &flg);
            }
            if (result) {
                result = 0;
                *len = size;
                break;
            }
            result = SOCKET_ERROR;
            /* thru */
          default:
            if ((err = WSAGetLastError()) == WSAECONNABORTED && !input)
                errno = EPIPE;
            else if (err == WSAEMSGSIZE && input) {
                result = 0;
                *len = size;
                break;
            }
            else
                errno = map_errno(err);
            /* thru */
          case WAIT_OBJECT_0 + 1:
            /* interrupted */
            *len = -1;
            CancelIo((HANDLE)s);
            break;
        }
    }
    else {
        if (err == WSAECONNABORTED && !input)
            errno = EPIPE;
        else
            errno = map_errno(err);
        *len = -1;
    }
    CloseHandle(wol->hEvent);
 
    return result;
}
 
/* License: Artistic or GPL */
static int
overlapped_socket_io(BOOL input, int fd, char *buf, int len, int flags,
                     struct sockaddr *addr, int *addrlen)
{
    int r;
    int ret;
    int mode = 0;
    DWORD flg;
    WSAOVERLAPPED wol;
    WSABUF wbuf;
    SOCKET s;
 
    s = TO_SOCKET(fd);
    socklist_lookup(s, &mode);
    if (GET_FLAGS(mode) & O_NONBLOCK) {
        RUBY_CRITICAL {
            if (input) {
                if (addr && addrlen)
                    r = recvfrom(s, buf, len, flags, addr, addrlen);
                else
                    r = recv(s, buf, len, flags);
                if (r == SOCKET_ERROR)
                    errno = map_errno(WSAGetLastError());
            }
            else {
                if (addr && addrlen)
                    r = sendto(s, buf, len, flags, addr, *addrlen);
                else
                    r = send(s, buf, len, flags);
                if (r == SOCKET_ERROR) {
                    DWORD err = WSAGetLastError();
                    if (err == WSAECONNABORTED)
                        errno = EPIPE;
                    else
                        errno = map_errno(err);
                }
            }
        }
    }
    else {
        DWORD size;
        DWORD rlen;
        wbuf.len = len;
        wbuf.buf = buf;
        memset(&wol, 0, sizeof(wol));
        RUBY_CRITICAL {
            wol.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
            if (input) {
                flg = flags;
                if (addr && addrlen)
                    ret = WSARecvFrom(s, &wbuf, 1, &size, &flg, addr, addrlen,
                                      &wol, NULL);
                else
                    ret = WSARecv(s, &wbuf, 1, &size, &flg, &wol, NULL);
            }
            else {
                if (addr && addrlen)
                    ret = WSASendTo(s, &wbuf, 1, &size, flags, addr, *addrlen,
                                    &wol, NULL);
                else
                    ret = WSASend(s, &wbuf, 1, &size, flags, &wol, NULL);
            }
        }
 
        finish_overlapped_socket(input, s, &wol, ret, &rlen, size);
        r = (int)rlen;
    }
 
    return r;
}
 
/* License: Ruby's */
int WSAAPI
rb_w32_recv(int fd, char *buf, int len, int flags)
{
    return overlapped_socket_io(TRUE, fd, buf, len, flags, NULL, NULL);
}
 
/* License: Ruby's */
int WSAAPI
rb_w32_recvfrom(int fd, char *buf, int len, int flags,
                struct sockaddr *from, int *fromlen)
{
    return overlapped_socket_io(TRUE, fd, buf, len, flags, from, fromlen);
}
 
/* License: Ruby's */
int WSAAPI
rb_w32_send(int fd, const char *buf, int len, int flags)
{
    return overlapped_socket_io(FALSE, fd, (char *)buf, len, flags, NULL, NULL);
}
 
/* License: Ruby's */
int WSAAPI
rb_w32_sendto(int fd, const char *buf, int len, int flags,
              const struct sockaddr *to, int tolen)
{
    return overlapped_socket_io(FALSE, fd, (char *)buf, len, flags,
                                (struct sockaddr *)to, &tolen);
}
 
#if !defined(MSG_TRUNC) && !defined(__MINGW32__)
/* License: Ruby's */
typedef struct {
    SOCKADDR *name;
    int namelen;
    WSABUF *lpBuffers;
    DWORD dwBufferCount;
    WSABUF Control;
    DWORD dwFlags;
} WSAMSG;
#endif
#ifndef WSAID_WSARECVMSG
#define WSAID_WSARECVMSG {0xf689d7c8,0x6f1f,0x436b,{0x8a,0x53,0xe5,0x4f,0xe3,0x51,0xc3,0x22}}
#endif
#ifndef WSAID_WSASENDMSG
#define WSAID_WSASENDMSG {0xa441e712,0x754f,0x43ca,{0x84,0xa7,0x0d,0xee,0x44,0xcf,0x60,0x6d}}
#endif
 
/* License: Ruby's */
#define msghdr_to_wsamsg(msg, wsamsg) \
    do { \
        int i; \
        (wsamsg)->name = (msg)->msg_name; \
        (wsamsg)->namelen = (msg)->msg_namelen; \
        (wsamsg)->lpBuffers = ALLOCA_N(WSABUF, (msg)->msg_iovlen); \
        (wsamsg)->dwBufferCount = (msg)->msg_iovlen; \
        for (i = 0; i < (msg)->msg_iovlen; ++i) { \
            (wsamsg)->lpBuffers[i].buf = (msg)->msg_iov[i].iov_base; \
            (wsamsg)->lpBuffers[i].len = (msg)->msg_iov[i].iov_len; \
        } \
        (wsamsg)->Control.buf = (msg)->msg_control; \
        (wsamsg)->Control.len = (msg)->msg_controllen; \
        (wsamsg)->dwFlags = (msg)->msg_flags; \
    } while (0)
 
/* License: Ruby's */
int
recvmsg(int fd, struct msghdr *msg, int flags)
{
    typedef int (WSAAPI *WSARecvMsg_t)(SOCKET, WSAMSG *, DWORD *, WSAOVERLAPPED *, LPWSAOVERLAPPED_COMPLETION_ROUTINE);
    static WSARecvMsg_t pWSARecvMsg = NULL;
    WSAMSG wsamsg;
    SOCKET s;
    int mode = 0;
    DWORD len;
    int ret;
 
    s = TO_SOCKET(fd);
 
    if (!pWSARecvMsg) {
        static const GUID guid = WSAID_WSARECVMSG;
        pWSARecvMsg = (WSARecvMsg_t)get_wsa_extension_function(s, guid);
        if (!pWSARecvMsg)
            return -1;
    }
 
    msghdr_to_wsamsg(msg, &wsamsg);
    wsamsg.dwFlags |= flags;
 
    socklist_lookup(s, &mode);
    if (GET_FLAGS(mode) & O_NONBLOCK) {
        RUBY_CRITICAL {
            if ((ret = pWSARecvMsg(s, &wsamsg, &len, NULL, NULL)) == SOCKET_ERROR) {
                errno = map_errno(WSAGetLastError());
                len = -1;
            }
        }
    }
    else {
        DWORD size;
        WSAOVERLAPPED wol;
        memset(&wol, 0, sizeof(wol));
        RUBY_CRITICAL {
            wol.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
            ret = pWSARecvMsg(s, &wsamsg, &size, &wol, NULL);
        }
 
        ret = finish_overlapped_socket(TRUE, s, &wol, ret, &len, size);
    }
    if (ret == SOCKET_ERROR)
        return -1;
 
    /* WSAMSG to msghdr */
    msg->msg_name = wsamsg.name;
    msg->msg_namelen = wsamsg.namelen;
    msg->msg_flags = wsamsg.dwFlags;
 
    return len;
}
 
/* License: Ruby's */
int
sendmsg(int fd, const struct msghdr *msg, int flags)
{
    typedef int (WSAAPI *WSASendMsg_t)(SOCKET, const WSAMSG *, DWORD, DWORD *, WSAOVERLAPPED *, LPWSAOVERLAPPED_COMPLETION_ROUTINE);
    static WSASendMsg_t pWSASendMsg = NULL;
    WSAMSG wsamsg;
    SOCKET s;
    int mode = 0;
    DWORD len;
    int ret;
 
    s = TO_SOCKET(fd);
 
    if (!pWSASendMsg) {
        static const GUID guid = WSAID_WSASENDMSG;
        pWSASendMsg = (WSASendMsg_t)get_wsa_extension_function(s, guid);
        if (!pWSASendMsg)
            return -1;
    }
 
    msghdr_to_wsamsg(msg, &wsamsg);
 
    socklist_lookup(s, &mode);
    if (GET_FLAGS(mode) & O_NONBLOCK) {
        RUBY_CRITICAL {
            if ((ret = pWSASendMsg(s, &wsamsg, flags, &len, NULL, NULL)) == SOCKET_ERROR) {
                errno = map_errno(WSAGetLastError());
                len = -1;
            }
        }
    }
    else {
        DWORD size;
        WSAOVERLAPPED wol;
        memset(&wol, 0, sizeof(wol));
        RUBY_CRITICAL {
            wol.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
            ret = pWSASendMsg(s, &wsamsg, flags, &size, &wol, NULL);
        }
 
        finish_overlapped_socket(FALSE, s, &wol, ret, &len, size);
    }
 
    return len;
}
 
#undef setsockopt
 
/* License: Artistic or GPL */
int WSAAPI
rb_w32_setsockopt(int s, int level, int optname, const char *optval, int optlen)
{
    int r;
    RUBY_CRITICAL {
        r = setsockopt(TO_SOCKET(s), level, optname, optval, optlen);
        if (r == SOCKET_ERROR)
            errno = map_errno(WSAGetLastError());
    }
    return r;
}
 
#undef shutdown
 
/* License: Artistic or GPL */
int WSAAPI
rb_w32_shutdown(int s, int how)
{
    int r;
    RUBY_CRITICAL {
        r = shutdown(TO_SOCKET(s), how);
        if (r == SOCKET_ERROR)
            errno = map_errno(WSAGetLastError());
    }
    return r;
}
 
/* License: Ruby's */
static SOCKET
open_ifs_socket(int af, int type, int protocol)
{
    unsigned long proto_buffers_len = 0;
    int error_code;
    SOCKET out = INVALID_SOCKET;
 
    if (WSAEnumProtocols(NULL, NULL, &proto_buffers_len) == SOCKET_ERROR) {
        error_code = WSAGetLastError();
        if (error_code == WSAENOBUFS) {
            WSAPROTOCOL_INFO *proto_buffers;
            int protocols_available = 0;
 
            proto_buffers = (WSAPROTOCOL_INFO *)malloc(proto_buffers_len);
            if (!proto_buffers) {
                WSASetLastError(WSA_NOT_ENOUGH_MEMORY);
                return INVALID_SOCKET;
            }
 
            protocols_available =
                WSAEnumProtocols(NULL, proto_buffers, &proto_buffers_len);
            if (protocols_available != SOCKET_ERROR) {
                int i;
                for (i = 0; i < protocols_available; i++) {
                    if ((af != AF_UNSPEC && af != proto_buffers[i].iAddressFamily) ||
                        (type != proto_buffers[i].iSocketType) ||
                        (protocol != 0 && protocol != proto_buffers[i].iProtocol))
                        continue;
 
                    if ((proto_buffers[i].dwServiceFlags1 & XP1_IFS_HANDLES) == 0)
                        continue;
 
                    out = WSASocket(af, type, protocol, &(proto_buffers[i]), 0,
                                    WSA_FLAG_OVERLAPPED);
                    break;
                }
                if (out == INVALID_SOCKET)
                    out = WSASocket(af, type, protocol, NULL, 0, 0);
                if (out != INVALID_SOCKET)
                    SetHandleInformation((HANDLE)out, HANDLE_FLAG_INHERIT, 0);
            }
 
            free(proto_buffers);
        }
    }
 
    return out;
}
 
#undef socket
 
/* License: Artistic or GPL */
int WSAAPI
rb_w32_socket(int af, int type, int protocol)
{
    SOCKET s;
    int fd;
 
    RUBY_CRITICAL {
        s = open_ifs_socket(af, type, protocol);
        if (s == INVALID_SOCKET) {
            errno = map_errno(WSAGetLastError());
            fd = -1;
        }
        else {
            fd = rb_w32_open_osfhandle(s, O_RDWR|O_BINARY|O_NOINHERIT);
            if (fd != -1)
                socklist_insert(s, MAKE_SOCKDATA(af, 0));
            else
                closesocket(s);
        }
    }
    return fd;
}
 
#undef gethostbyaddr
 
/* License: Artistic or GPL */
struct hostent * WSAAPI
rb_w32_gethostbyaddr(const char *addr, int len, int type)
{
    struct hostent *r;
    RUBY_CRITICAL {
        r = gethostbyaddr(addr, len, type);
        if (r == NULL)
            errno = map_errno(WSAGetLastError());
    }
    return r;
}
 
#undef gethostbyname
 
/* License: Artistic or GPL */
struct hostent * WSAAPI
rb_w32_gethostbyname(const char *name)
{
    struct hostent *r;
    RUBY_CRITICAL {
        r = gethostbyname(name);
        if (r == NULL)
            errno = map_errno(WSAGetLastError());
    }
    return r;
}
 
#undef gethostname
 
/* License: Artistic or GPL */
int WSAAPI
rb_w32_gethostname(char *name, int len)
{
    int r;
    RUBY_CRITICAL {
        r = gethostname(name, len);
        if (r == SOCKET_ERROR)
            errno = map_errno(WSAGetLastError());
    }
    return r;
}
 
#undef getprotobyname
 
/* License: Artistic or GPL */
struct protoent * WSAAPI
rb_w32_getprotobyname(const char *name)
{
    struct protoent *r;
    RUBY_CRITICAL {
        r = getprotobyname(name);
        if (r == NULL)
            errno = map_errno(WSAGetLastError());
    }
    return r;
}
 
#undef getprotobynumber
 
/* License: Artistic or GPL */
struct protoent * WSAAPI
rb_w32_getprotobynumber(int num)
{
    struct protoent *r;
    RUBY_CRITICAL {
        r = getprotobynumber(num);
        if (r == NULL)
            errno = map_errno(WSAGetLastError());
    }
    return r;
}
 
#undef getservbyname
 
/* License: Artistic or GPL */
struct servent * WSAAPI
rb_w32_getservbyname(const char *name, const char *proto)
{
    struct servent *r;
    RUBY_CRITICAL {
        r = getservbyname(name, proto);
        if (r == NULL)
            errno = map_errno(WSAGetLastError());
    }
    return r;
}
 
#undef getservbyport
 
/* License: Artistic or GPL */
struct servent * WSAAPI
rb_w32_getservbyport(int port, const char *proto)
{
    struct servent *r;
    RUBY_CRITICAL {
        r = getservbyport(port, proto);
        if (r == NULL)
            errno = map_errno(WSAGetLastError());
    }
    return r;
}
 
#ifdef HAVE_AFUNIX_H
 
/* License: Ruby's */
static size_t
socketpair_unix_path(struct sockaddr_un *sock_un)
{
    SOCKET listener;
    WCHAR wpath[sizeof(sock_un->sun_path)/sizeof(*sock_un->sun_path)] = L"";
 
    /* AF_UNIX/SOCK_STREAM became available in Windows 10
     * See https://devblogs.microsoft.com/commandline/af_unix-comes-to-windows
     */
    listener = socket(AF_UNIX, SOCK_STREAM, 0);
    if (listener == INVALID_SOCKET)
        return 0;
 
    memset(sock_un, 0, sizeof(*sock_un));
    sock_un->sun_family = AF_UNIX;
 
    /* Abstract sockets (filesystem-independent) don't work, contrary to
     * the claims of the aforementioned blog post:
     * https://github.com/microsoft/WSL/issues/4240#issuecomment-549663217
     *
     * So we must use a named path, and that comes with all the attendant
     * problems of permissions and collisions. Trying various temporary
     * directories and putting high-res time and PID in the filename.
     */
    for (int try = 0; ; try++) {
        LARGE_INTEGER ticks;
        size_t path_len = 0;
        const size_t maxpath = sizeof(sock_un->sun_path)/sizeof(*sock_un->sun_path);
 
        switch (try) {
        case 0:
            /* user temp dir from TMP or TEMP env var, it ends with a backslash */
            path_len = GetTempPathW(maxpath, wpath);
            if (path_len == 0 || path_len > maxpath) {
                /* The env var path did not fit in wpath (GetTempPathW then
                 * returns the required length and leaves wpath unfilled), or
                 * the call failed.  Skip to the next candidate directory
                 * instead of reading past wpath in WideCharToMultiByte. */
                continue;
            }
            break;
        case 1:
            wcsncpy(wpath, L"C:/Temp/", maxpath);
            path_len = lstrlenW(wpath);
            break;
        case 2:
            /* Current directory */
            path_len = 0;
            break;
        case 3:
            closesocket(listener);
            return 0;
        }
 
        /* Windows UNIXSocket implementation expects UTF-8 instead of UTF16 */
        path_len = WideCharToMultiByte(CP_UTF8, 0, wpath, path_len, sock_un->sun_path, maxpath, NULL, NULL);
        QueryPerformanceCounter(&ticks);
        path_len += snprintf(sock_un->sun_path + path_len,
                 maxpath - path_len,
                 "%lld-%ld.($)",
                 ticks.QuadPart,
                 GetCurrentProcessId());
 
        /* Convert to UTF16 for DeleteFileW */
        MultiByteToWideChar(CP_UTF8, 0, sock_un->sun_path, -1, wpath, sizeof(wpath)/sizeof(*wpath));
 
        if (bind(listener, (struct sockaddr *)sock_un, sizeof(*sock_un)) != SOCKET_ERROR)
            break;
    }
    closesocket(listener);
    DeleteFileW(wpath);
    return sizeof(*sock_un);
}
#endif
 
/* License: Ruby's */
static int
socketpair_internal(int af, int type, int protocol, SOCKET *sv)
{
    SOCKET svr = INVALID_SOCKET, r = INVALID_SOCKET, w = INVALID_SOCKET;
    struct sockaddr_in sock_in4;
 
#ifdef INET6
    struct sockaddr_in6 sock_in6;
#endif
 
#ifdef HAVE_AFUNIX_H
    struct sockaddr_un sock_un = {0, {0}};
    WCHAR wpath[sizeof(sock_un.sun_path)/sizeof(*sock_un.sun_path)] = L"";
#endif
 
    struct sockaddr *addr;
    int ret = -1;
    int len;
 
    switch (af) {
      case AF_INET:
#if defined PF_INET && PF_INET != AF_INET
      case PF_INET:
#endif
        sock_in4.sin_family = AF_INET;
        sock_in4.sin_port = 0;
        sock_in4.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
        addr = (struct sockaddr *)&sock_in4;
        len = sizeof(sock_in4);
        break;
#ifdef INET6
      case AF_INET6:
        memset(&sock_in6, 0, sizeof(sock_in6));
        sock_in6.sin6_family = AF_INET6;
        sock_in6.sin6_addr = IN6ADDR_LOOPBACK_INIT;
        addr = (struct sockaddr *)&sock_in6;
        len = sizeof(sock_in6);
        break;
#endif
#ifdef HAVE_AFUNIX_H
      case AF_UNIX:
        addr = (struct sockaddr *)&sock_un;
        len = socketpair_unix_path(&sock_un);
        MultiByteToWideChar(CP_UTF8, 0, sock_un.sun_path, -1, wpath, sizeof(wpath)/sizeof(*wpath));
        if (len)
            break;
        /* fall through */
#endif
      default:
        errno = EAFNOSUPPORT;
        return -1;
    }
    if (type != SOCK_STREAM) {
        errno = EPROTOTYPE;
        return -1;
    }
 
    sv[0] = (SOCKET)INVALID_HANDLE_VALUE;
    sv[1] = (SOCKET)INVALID_HANDLE_VALUE;
    RUBY_CRITICAL {
        do {
            svr = open_ifs_socket(af, type, protocol);
            if (svr == INVALID_SOCKET)
                break;
            if (bind(svr, addr, len) < 0)
                break;
            if (getsockname(svr, addr, &len) < 0)
                break;
            if (type == SOCK_STREAM)
                listen(svr, 5);
 
            w = open_ifs_socket(af, type, protocol);
            if (w == INVALID_SOCKET)
                break;
            if (connect(w, addr, len) < 0)
                break;
 
            r = accept(svr, addr, &len);
            if (r == INVALID_SOCKET)
                break;
            SetHandleInformation((HANDLE)r, HANDLE_FLAG_INHERIT, 0);
 
            ret = 0;
        } while (0);
 
        if (ret < 0) {
            errno = map_errno(WSAGetLastError());
            if (r != INVALID_SOCKET)
                closesocket(r);
            if (w != INVALID_SOCKET)
                closesocket(w);
        }
        else {
            sv[0] = r;
            sv[1] = w;
        }
        if (svr != INVALID_SOCKET)
            closesocket(svr);
#ifdef HAVE_AFUNIX_H
        if (sock_un.sun_family == AF_UNIX)
            DeleteFileW(wpath);
#endif
    }
 
    return ret;
}
 
/* License: Ruby's */
int
socketpair(int af, int type, int protocol, int *sv)
{
    SOCKET pair[2];
 
    if (socketpair_internal(af, type, protocol, pair) < 0)
        return -1;
    sv[0] = rb_w32_open_osfhandle(pair[0], O_RDWR|O_BINARY|O_NOINHERIT);
    if (sv[0] == -1) {
        closesocket(pair[0]);
        closesocket(pair[1]);
        return -1;
    }
    sv[1] = rb_w32_open_osfhandle(pair[1], O_RDWR|O_BINARY|O_NOINHERIT);
    if (sv[1] == -1) {
        rb_w32_close(sv[0]);
        closesocket(pair[1]);
        return -1;
    }
    socklist_insert(pair[0], MAKE_SOCKDATA(af, 0));
    socklist_insert(pair[1], MAKE_SOCKDATA(af, 0));
 
    return 0;
}
 
/* License: Ruby's */
static void
str2guid(const char *str, GUID *guid)
{
#define hex2byte(str) \
    ((isdigit(*(str)) ? *(str) - '0' : toupper(*(str)) - 'A' + 10) << 4 | (isdigit(*((str) + 1)) ? *((str) + 1) - '0' : toupper(*((str) + 1)) - 'A' + 10))
    char *end;
    int i;
    if (*str == '{') str++;
    guid->Data1 = (long)strtoul(str, &end, 16);
    str += 9;
    guid->Data2 = (unsigned short)strtoul(str, &end, 16);
    str += 5;
    guid->Data3 = (unsigned short)strtoul(str, &end, 16);
    str += 5;
    guid->Data4[0] = hex2byte(str);
    str += 2;
    guid->Data4[1] = hex2byte(str);
    str += 3;
    for (i = 0; i < 6; i++) {
        guid->Data4[i + 2] = hex2byte(str);
        str += 2;
    }
}
 
/* License: Ruby's */
#ifndef HAVE_TYPE_NET_LUID
    typedef struct {
        uint64_t Value;
        struct {
            uint64_t Reserved :24;
            uint64_t NetLuidIndex :24;
            uint64_t IfType :16;
        } Info;
    } NET_LUID;
#endif
 
int
getifaddrs(struct ifaddrs **ifap)
{
    ULONG size = 0;
    ULONG ret;
    IP_ADAPTER_ADDRESSES *root, *addr;
    struct ifaddrs *prev;
 
    ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
    if (ret != ERROR_BUFFER_OVERFLOW) {
        errno = map_errno(ret);
        return -1;
    }
    root = ruby_xmalloc(size);
    ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, root, &size);
    if (ret != ERROR_SUCCESS) {
        errno = map_errno(ret);
        ruby_xfree(root);
        return -1;
    }
 
    for (prev = NULL, addr = root; addr; addr = addr->Next) {
        struct ifaddrs *ifa = ruby_xcalloc(1, sizeof(*ifa));
        char name[IFNAMSIZ];
        GUID guid;
        NET_LUID luid;
 
        if (prev)
            prev->ifa_next = ifa;
        else
            *ifap = ifa;
 
        str2guid(addr->AdapterName, &guid);
        if (ConvertInterfaceGuidToLuid(&guid, &luid) == NO_ERROR &&
            ConvertInterfaceLuidToNameA(&luid, name, sizeof(name)) == NO_ERROR) {
            ifa->ifa_name = ruby_strdup(name);
        }
        else {
            ifa->ifa_name = ruby_strdup(addr->AdapterName);
        }
 
        if (addr->IfType & IF_TYPE_SOFTWARE_LOOPBACK)
            ifa->ifa_flags |= IFF_LOOPBACK;
        if (addr->OperStatus == IfOperStatusUp) {
            ifa->ifa_flags |= IFF_UP;
 
            if (addr->FirstUnicastAddress) {
                IP_ADAPTER_UNICAST_ADDRESS *cur;
                int added = 0;
                for (cur = addr->FirstUnicastAddress; cur; cur = cur->Next) {
                    if (cur->Flags & IP_ADAPTER_ADDRESS_TRANSIENT ||
                        cur->DadState == IpDadStateDeprecated) {
                        continue;
                    }
                    if (added) {
                        prev = ifa;
                        ifa = ruby_xcalloc(1, sizeof(*ifa));
                        prev->ifa_next = ifa;
                        ifa->ifa_name = ruby_strdup(prev->ifa_name);
                        ifa->ifa_flags = prev->ifa_flags;
                    }
                    ifa->ifa_addr = ruby_xmalloc(cur->Address.iSockaddrLength);
                    memcpy(ifa->ifa_addr, cur->Address.lpSockaddr,
                           cur->Address.iSockaddrLength);
                    added = 1;
                }
            }
        }
 
        prev = ifa;
    }
 
    ruby_xfree(root);
    return 0;
}
 
/* License: Ruby's */
void
freeifaddrs(struct ifaddrs *ifp)
{
    while (ifp) {
        struct ifaddrs *next = ifp->ifa_next;
        ruby_xfree(ifp->ifa_addr);
        ruby_xfree(ifp->ifa_name);
        ruby_xfree(ifp);
        ifp = next;
    }
}
 
#if 0 // Have never been used
//
// Networking stubs
//
 
void endhostent(void) {}
void endnetent(void) {}
void endprotoent(void) {}
void endservent(void) {}
 
struct netent *getnetent (void) {return (struct netent *) NULL;}
 
struct netent *getnetbyaddr(long net, int type) {return (struct netent *)NULL;}
 
struct netent *getnetbyname(const char *name) {return (struct netent *)NULL;}
 
struct protoent *getprotoent (void) {return (struct protoent *) NULL;}
 
struct servent *getservent (void) {return (struct servent *) NULL;}
 
void sethostent (int stayopen) {}
 
void setnetent (int stayopen) {}
 
void setprotoent (int stayopen) {}
 
void setservent (int stayopen) {}
#endif
 
int rb_w32_set_nonblock2(int fd, int nonblock);
 
/* License: Ruby's */
static int
setfl(SOCKET sock, int arg)
{
    int ret;
    int af = 0;
    int flag = 0;
    u_long ioctlArg;
 
    socklist_lookup(sock, &flag);
    af = GET_FAMILY(flag);
    flag = GET_FLAGS(flag);
    if (arg & O_NONBLOCK) {
        flag |= O_NONBLOCK;
        ioctlArg = 1;
    }
    else {
        flag &= ~O_NONBLOCK;
        ioctlArg = 0;
    }
    RUBY_CRITICAL {
        ret = ioctlsocket(sock, FIONBIO, &ioctlArg);
        if (ret == 0)
            socklist_insert(sock, MAKE_SOCKDATA(af, flag));
        else
            errno = map_errno(WSAGetLastError());
    }
 
    return ret;
}
 
/* License: Ruby's */
static int
dupfd(HANDLE hDup, int flags, int minfd)
{
    int save_errno;
    int ret;
    int fds[32];
    int filled = 0;
 
    do {
        ret = _open_osfhandle((intptr_t)hDup, flags | FOPEN);
        if (ret == -1) {
            goto close_fds_and_return;
        }
        if (ret >= minfd) {
            goto close_fds_and_return;
        }
        fds[filled++] = ret;
    } while (filled < (int)numberof(fds));
 
    ret = dupfd(hDup, flags, minfd);
 
  close_fds_and_return:
    save_errno = errno;
    while (filled > 0) {
        int fd = fds[--filled];
        _set_osfhnd(fd, (intptr_t)INVALID_HANDLE_VALUE);
        close(fd);
    }
    errno = save_errno;
 
    return ret;
}
 
/* License: Ruby's */
int
fcntl(int fd, int cmd, ...)
{
    va_list va;
    int arg;
    DWORD flag;
 
    switch (cmd) {
      case F_SETFL: {
        va_start(va, cmd);
        arg = va_arg(va, int);
        va_end(va);
        return rb_w32_set_nonblock2(fd, arg);
      }
      case F_DUPFD: case F_DUPFD_CLOEXEC: {
        int ret;
        HANDLE hDup;
        flag = _osfile(fd);
        if (!(DuplicateHandle(GetCurrentProcess(), (HANDLE)_get_osfhandle(fd),
                              GetCurrentProcess(), &hDup, 0L,
                              cmd == F_DUPFD && !(flag & FNOINHERIT),
                              DUPLICATE_SAME_ACCESS))) {
            errno = map_errno(GetLastError());
            return -1;
        }
 
        va_start(va, cmd);
        arg = va_arg(va, int);
        va_end(va);
 
        if (cmd != F_DUPFD)
            flag |= FNOINHERIT;
        else
            flag &= ~FNOINHERIT;
        if ((ret = dupfd(hDup, flag, arg)) == -1)
            CloseHandle(hDup);
        return ret;
      }
      case F_GETFD: {
        SIGNED_VALUE h = _get_osfhandle(fd);
        if (h == -1) return -1;
        if (!GetHandleInformation((HANDLE)h, &flag)) {
            errno = map_errno(GetLastError());
            return -1;
        }
        return (flag & HANDLE_FLAG_INHERIT) ? 0 : FD_CLOEXEC;
      }
      case F_SETFD: {
        SIGNED_VALUE h = _get_osfhandle(fd);
        if (h == -1) return -1;
        va_start(va, cmd);
        arg = va_arg(va, int);
        va_end(va);
        if (!SetHandleInformation((HANDLE)h, HANDLE_FLAG_INHERIT,
                                  (arg & FD_CLOEXEC) ? 0 : HANDLE_FLAG_INHERIT)) {
            errno = map_errno(GetLastError());
            return -1;
        }
        if (arg & FD_CLOEXEC)
            _osfile(fd) |= FNOINHERIT;
        else
            _osfile(fd) &= ~FNOINHERIT;
        return 0;
      }
      default:
        errno = EINVAL;
        return -1;
    }
}
 
/* License: Ruby's */
int
rb_w32_set_nonblock2(int fd, int nonblock)
{
    SOCKET sock = TO_SOCKET(fd);
    if (is_socket(sock)) {
        return setfl(sock, nonblock ? O_NONBLOCK : 0);
    }
    else if (is_pipe(sock)) {
        DWORD state;
        if (!GetNamedPipeHandleState((HANDLE)sock, &state, NULL, NULL, NULL, NULL, 0)) {
            errno = map_errno(GetLastError());
            return -1;
        }
        if (nonblock) {
            state |= PIPE_NOWAIT;
        }
        else {
            state &= ~PIPE_NOWAIT;
        }
        if (!SetNamedPipeHandleState((HANDLE)sock, &state, NULL, NULL)) {
            errno = map_errno(GetLastError());
            return -1;
        }
        return 0;
    }
    else {
        errno = EBADF;
        return -1;
    }
}
 
int
rb_w32_set_nonblock(int fd)
{
    return rb_w32_set_nonblock2(fd, TRUE);
}
 
#ifndef WNOHANG
#define WNOHANG -1
#endif
 
/* License: Ruby's */
static rb_pid_t
poll_child_status(struct ChildRecord *child, int *stat_loc)
{
    DWORD exitcode;
    DWORD err;
 
    if (!GetExitCodeProcess(child->hProcess, &exitcode)) {
        /* If an error occurred, return immediately. */
        err = GetLastError();
        switch (err) {
          case ERROR_INVALID_PARAMETER:
            errno = ECHILD;
            break;
          case ERROR_INVALID_HANDLE:
            errno = EINVAL;
            break;
          default:
            errno = map_errno(err);
            break;
        }
    error_exit:
        CloseChildHandle(child);
        return -1;
    }
    if (exitcode != STILL_ACTIVE) {
        rb_pid_t pid;
        /* If already died, wait process's real termination. */
        if (rb_w32_wait_events_blocking(&child->hProcess, 1, INFINITE) != WAIT_OBJECT_0) {
            goto error_exit;
        }
        pid = child->pid;
        CloseChildHandle(child);
        if (stat_loc) {
            *stat_loc = exitcode << 8;
            if (exitcode & 0xC0000000) {
                static const struct {
                    DWORD status;
                    int sig;
                } table[] = {
                    {STATUS_ACCESS_VIOLATION,        SIGSEGV},
                    {STATUS_ILLEGAL_INSTRUCTION,     SIGILL},
                    {STATUS_PRIVILEGED_INSTRUCTION,  SIGILL},
                    {STATUS_FLOAT_DENORMAL_OPERAND,  SIGFPE},
                    {STATUS_FLOAT_DIVIDE_BY_ZERO,    SIGFPE},
                    {STATUS_FLOAT_INEXACT_RESULT,    SIGFPE},
                    {STATUS_FLOAT_INVALID_OPERATION, SIGFPE},
                    {STATUS_FLOAT_OVERFLOW,          SIGFPE},
                    {STATUS_FLOAT_STACK_CHECK,       SIGFPE},
                    {STATUS_FLOAT_UNDERFLOW,         SIGFPE},
#ifdef STATUS_FLOAT_MULTIPLE_FAULTS
                    {STATUS_FLOAT_MULTIPLE_FAULTS,   SIGFPE},
#endif
#ifdef STATUS_FLOAT_MULTIPLE_TRAPS
                    {STATUS_FLOAT_MULTIPLE_TRAPS,    SIGFPE},
#endif
                    {STATUS_CONTROL_C_EXIT,          SIGINT},
                };
                int i;
                for (i = 0; i < (int)numberof(table); i++) {
                    if (table[i].status == exitcode) {
                        *stat_loc |= table[i].sig;
                        break;
                    }
                }
                // if unknown status, assume SEGV
                if (i >= (int)numberof(table))
                    *stat_loc |= SIGSEGV;
            }
        }
        return pid;
    }
    return 0;
}
 
/* License: Artistic or GPL */
rb_pid_t
waitpid(rb_pid_t pid, int *stat_loc, int options)
{
    DWORD timeout;
 
    /* Artistic or GPL part start */
    if (options == WNOHANG) {
        timeout = 0;
    }
    else {
        timeout = INFINITE;
    }
    /* Artistic or GPL part end */
 
    if (pid == -1) {
        int count = 0;
        int ret;
        HANDLE events[MAXCHILDNUM];
        struct ChildRecord* cause;
 
        FOREACH_CHILD(child) {
            if (!child->pid || child->pid < 0) continue;
            if ((pid = poll_child_status(child, stat_loc))) return pid;
            events[count++] = child->hProcess;
        } END_FOREACH_CHILD;
        if (!count) {
            errno = ECHILD;
            return -1;
        }
 
        ret = rb_w32_wait_events_blocking(events, count, timeout);
        if (ret == WAIT_TIMEOUT) return 0;
        if ((ret -= WAIT_OBJECT_0) == count) {
            return -1;
        }
        if (ret > count) {
            errno = map_errno(GetLastError());
            return -1;
        }
 
        cause = FindChildSlotByHandle(events[ret]);
        if (!cause) {
            errno = ECHILD;
            return -1;
        }
        return poll_child_status(cause, stat_loc);
    }
    else {
        struct ChildRecord* child = FindChildSlot(pid);
        int retried = 0;
        if (!child) {
            errno = ECHILD;
            return -1;
        }
 
        while (!(pid = poll_child_status(child, stat_loc))) {
            /* wait... */
            int ret = rb_w32_wait_events_blocking(&child->hProcess, 1, timeout);
            if (ret == WAIT_OBJECT_0 + 1) return -1; /* maybe EINTR */
            if (ret != WAIT_OBJECT_0) {
                /* still active */
                if (options & WNOHANG) {
                    pid = 0;
                    break;
                }
                ++retried;
            }
        }
        if (pid == -1 && retried) pid = 0;
    }
 
    return pid;
}
 
#include <sys/timeb.h>
 
/* License: Ruby's */
#define filetime_unit (10UL * 1000 * 1000)
#define filetime_diff_days ((1970-1601)*3652425UL/10000)
#define filetime_diff_secs (filetime_diff_days * (24ULL * 60 * 60))
#define unix_to_filetime(sec) (((sec) + filetime_diff_secs) * filetime_unit)
#define filetime_unix_offset unix_to_filetime(0ULL)
 
/* License: Ruby's */
typedef union {
    /* FILETIME and ULARGE_INTEGER::u are the same layout */
    FILETIME ft;
    ULARGE_INTEGER i;
} FILETIME_INTEGER;
 
/* License: Ruby's */
/* split FILETIME value into UNIX time and sub-seconds in NT ticks */
static time_t
filetime_split(const FILETIME* ft, long *subsec)
{
    FILETIME_INTEGER fi = {.ft = *ft};
    ULONGLONG lt = fi.i.QuadPart;
 
    /* lt is now 100-nanosec intervals since 1601/01/01 00:00:00 UTC,
       convert it into UNIX time (since 1970/01/01 00:00:00 UTC).
       the first leap second is at 1972/06/30, so we doesn't need to think
       about it. */
    lt -= unix_to_filetime(0);
 
    *subsec = (long)(lt % filetime_unit);
    return (time_t)(lt / filetime_unit);
}
 
/* License: Ruby's */
int __cdecl
gettimeofday(struct timeval *tv, struct timezone *tz)
{
    FILETIME ft;
    long subsec;
 
    GetSystemTimePreciseAsFileTime(&ft);
    tv->tv_sec = filetime_split(&ft, &subsec);
    tv->tv_usec = subsec / 10;
 
    return 0;
}
 
/* License: Ruby's */
static void
filetime_to_timespec(FILETIME ft, struct timespec *sp)
{
    long subsec;
    sp->tv_sec = filetime_split(&ft, &subsec);
    sp->tv_nsec = subsec * 100;
}
 
/* License: Ruby's */
static const long secs_in_ns = 1000000000;
 
/* License: Ruby's */
int
clock_gettime(clockid_t clock_id, struct timespec *sp)
{
    switch (clock_id) {
      case CLOCK_REALTIME:
      case CLOCK_REALTIME_COARSE:
        {
            FILETIME ft;
 
            GetSystemTimePreciseAsFileTime(&ft);
            filetime_to_timespec(ft, sp);
            return 0;
        }
      case CLOCK_MONOTONIC:
        {
            LARGE_INTEGER freq;
            LARGE_INTEGER count;
            if (UNLIKELY(!QueryPerformanceFrequency(&freq))) {
                errno = map_errno(GetLastError());
                return -1;
            }
            if (UNLIKELY(!QueryPerformanceCounter(&count))) {
                errno = map_errno(GetLastError());
                return -1;
            }
            sp->tv_sec = count.QuadPart / freq.QuadPart;
            if (freq.QuadPart < secs_in_ns)
                sp->tv_nsec = (count.QuadPart % freq.QuadPart) * secs_in_ns / freq.QuadPart;
            else
                sp->tv_nsec = (long)((count.QuadPart % freq.QuadPart) * ((double)secs_in_ns / freq.QuadPart));
            return 0;
        }
      case CLOCK_PROCESS_CPUTIME_ID:
      case CLOCK_THREAD_CPUTIME_ID:
        {
            FILETIME_INTEGER c, e, k, u, total;
            BOOL ok;
            if (clock_id == CLOCK_PROCESS_CPUTIME_ID) {
                ok = GetProcessTimes(GetCurrentProcess(), &c.ft, &e.ft, &k.ft, &u.ft);
            }
            else {
                ok = GetThreadTimes(GetCurrentThread(), &c.ft, &e.ft, &k.ft, &u.ft);
            }
            if (UNLIKELY(!ok)) {
                errno = map_errno(GetLastError());
                return -1;
            }
            total.i.QuadPart = k.i.QuadPart + u.i.QuadPart;
            filetime_to_timespec(total.ft, sp);
            return 0;
        }
      default:
        errno = EINVAL;
        return -1;
    }
}
 
/* License: Ruby's */
int
clock_getres(clockid_t clock_id, struct timespec *sp)
{
    switch (clock_id) {
      case CLOCK_REALTIME:
      case CLOCK_REALTIME_COARSE:
        {
            sp->tv_sec = 0;
            sp->tv_nsec = 1000;
            return 0;
        }
      case CLOCK_MONOTONIC:
        {
            LARGE_INTEGER freq;
            if (!QueryPerformanceFrequency(&freq)) {
                errno = map_errno(GetLastError());
                return -1;
            }
            sp->tv_sec = 0;
            sp->tv_nsec = (long)((double)secs_in_ns / freq.QuadPart);
            return 0;
        }
      case CLOCK_PROCESS_CPUTIME_ID:
      case CLOCK_THREAD_CPUTIME_ID:
        {
            const int frames_in_sec = 60;
            sp->tv_sec = 0;
            sp->tv_nsec = (long)(secs_in_ns / frames_in_sec);
            return 0;
        }
      default:
        errno = EINVAL;
        return -1;
    }
}
 
/* License: Ruby's */
static char *
w32_getcwd(char *buffer, int size, UINT cp, void *alloc(int, void *), void *arg)
{
    WCHAR *p;
    int wlen, len;
 
    len = GetCurrentDirectoryW(0, NULL);
    if (!len) {
        errno = map_errno(GetLastError());
        return NULL;
    }
 
    if (buffer && size < len) {
        errno = ERANGE;
        return NULL;
    }
 
    p = ALLOCA_N(WCHAR, len);
    if (!GetCurrentDirectoryW(len, p)) {
        errno = map_errno(GetLastError());
        return NULL;
    }
 
    wlen = translate_wchar(p, L'\\', L'/') - p + 1;
    len = WideCharToMultiByte(cp, 0, p, wlen, NULL, 0, NULL, NULL);
    if (buffer) {
        if (size < len) {
            errno = ERANGE;
            return NULL;
        }
    }
    else {
        buffer = (*alloc)(len, arg);
        if (!buffer) {
            errno = ENOMEM;
            return NULL;
        }
    }
    WideCharToMultiByte(cp, 0, p, wlen, buffer, len, NULL, NULL);
 
    return buffer;
}
 
/* License: Ruby's */
static void *
getcwd_alloc(int size, void *dummy)
{
    return malloc(size);
}
 
/* License: Ruby's */
char *
rb_w32_getcwd(char *buffer, int size)
{
    return w32_getcwd(buffer, size, filecp(), getcwd_alloc, NULL);
}
 
/* License: Ruby's */
char *
rb_w32_ugetcwd(char *buffer, int size)
{
    return w32_getcwd(buffer, size, CP_UTF8, getcwd_alloc, NULL);
}
 
/* License: Ruby's */
static void *
getcwd_value(int size, void *arg)
{
    VALUE str = *(VALUE *)arg = rb_utf8_str_new(0, size - 1);
    return RSTRING_PTR(str);
}
 
/* License: Ruby's */
VALUE
rb_dir_getwd_ospath(void)
{
    VALUE cwd = Qnil;
    w32_getcwd(NULL, 0, CP_UTF8, getcwd_value, &cwd);
    return cwd;
}
 
/* License: Artistic or GPL */
int
chown(const char *path, int owner, int group)
{
    return 0;
}
 
/* License: Artistic or GPL */
int
rb_w32_uchown(const char *path, int owner, int group)
{
    return 0;
}
 
int
lchown(const char *path, int owner, int group)
{
    return 0;
}
 
int
rb_w32_ulchown(const char *path, int owner, int group)
{
    return 0;
}
 
/* License: Ruby's */
int
kill(rb_pid_t pid, int sig)
{
    int ret = 0;
    DWORD err;
 
    if (pid < 0 || (pid == 0 && sig != SIGINT)) {
        errno = EINVAL;
        return -1;
    }
 
    if ((unsigned int)pid == GetCurrentProcessId() &&
        (sig != 0 && sig != SIGKILL)) {
        if ((ret = raise(sig)) != 0) {
            /* MSVCRT doesn't set errno... */
            errno = EINVAL;
        }
        return ret;
    }
 
    switch (sig) {
      case 0:
        RUBY_CRITICAL {
            HANDLE hProc =
                OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, (DWORD)pid);
            if (hProc == NULL || hProc == INVALID_HANDLE_VALUE) {
                if (GetLastError() == ERROR_INVALID_PARAMETER) {
                    errno = ESRCH;
                }
                else {
                    errno = EPERM;
                }
                ret = -1;
            }
            else {
                CloseHandle(hProc);
            }
        }
        break;
 
      case SIGINT:
        RUBY_CRITICAL {
            DWORD ctrlEvent = CTRL_C_EVENT;
            if (pid != 0) {
                /* CTRL+C signal cannot be generated for process groups.
                 * Instead, we use CTRL+BREAK signal. */
                ctrlEvent = CTRL_BREAK_EVENT;
            }
            if (!GenerateConsoleCtrlEvent(ctrlEvent, (DWORD)pid)) {
                if ((err = GetLastError()) == 0)
                    errno = EPERM;
                else
                    errno = map_errno(GetLastError());
                ret = -1;
            }
        }
        break;
 
      case SIGKILL:
        RUBY_CRITICAL {
            HANDLE hProc;
            struct ChildRecord* child = FindChildSlot(pid);
            if (child) {
                hProc = child->hProcess;
            }
            else {
                hProc = OpenProcess(PROCESS_TERMINATE | PROCESS_QUERY_INFORMATION, FALSE, (DWORD)pid);
            }
            if (hProc == NULL || hProc == INVALID_HANDLE_VALUE) {
                if (GetLastError() == ERROR_INVALID_PARAMETER) {
                    errno = ESRCH;
                }
                else {
                    errno = EPERM;
                }
                ret = -1;
            }
            else {
                DWORD status;
                if (!GetExitCodeProcess(hProc, &status)) {
                    errno = map_errno(GetLastError());
                    ret = -1;
                }
                else if (status == STILL_ACTIVE) {
                    if (!TerminateProcess(hProc, 0)) {
                        errno = EPERM;
                        ret = -1;
                    }
                }
                else {
                    errno = ESRCH;
                    ret = -1;
                }
                if (!child) {
                    CloseHandle(hProc);
                }
            }
        }
        break;
 
      default:
        errno = EINVAL;
        ret = -1;
        break;
    }
 
    return ret;
}
 
/* License: Ruby's */
static int
wlink(const WCHAR *from, const WCHAR *to)
{
    if (!CreateHardLinkW(to, from, NULL)) {
        errno = map_errno(GetLastError());
        return -1;
    }
 
    return 0;
}
 
/* License: Ruby's */
int
rb_w32_ulink(const char *from, const char *to)
{
    WCHAR *wfrom;
    WCHAR *wto;
    int ret;
 
    if (!(wfrom = utf8_to_wstr(from, NULL)))
        return -1;
    if (!(wto = utf8_to_wstr(to, NULL))) {
        free(wfrom);
        return -1;
    }
    ret = wlink(wfrom, wto);
    free(wto);
    free(wfrom);
    return ret;
}
 
/* License: Ruby's */
int
link(const char *from, const char *to)
{
    WCHAR *wfrom;
    WCHAR *wto;
    int ret;
 
    if (!(wfrom = filecp_to_wstr(from, NULL)))
        return -1;
    if (!(wto = filecp_to_wstr(to, NULL))) {
        free(wfrom);
        return -1;
    }
    ret = wlink(wfrom, wto);
    free(wto);
    free(wfrom);
    return ret;
}
 
/* License: Public Domain, copied from mingw headers */
#ifndef FILE_DEVICE_FILE_SYSTEM
# define FILE_DEVICE_FILE_SYSTEM 0x00000009
#endif
#ifndef FSCTL_GET_REPARSE_POINT
# define FSCTL_GET_REPARSE_POINT ((0x9<<16)|(42<<2))
#endif
#ifndef IO_REPARSE_TAG_SYMLINK
# define IO_REPARSE_TAG_SYMLINK 0xA000000CL
#endif
 
/* License: Ruby's */
static int
reparse_symlink(const WCHAR *path, rb_w32_reparse_buffer_t *rp, size_t size)
{
    HANDLE f;
    DWORD ret;
    int e = 0;
 
    f = open_special(path, 0, FILE_FLAG_OPEN_REPARSE_POINT);
    if (f == INVALID_HANDLE_VALUE) {
        return GetLastError();
    }
 
    if (!DeviceIoControl(f, FSCTL_GET_REPARSE_POINT, NULL, 0,
                           rp, size, &ret, NULL)) {
        e = GetLastError();
    }
    else if (rp->ReparseTag != IO_REPARSE_TAG_SYMLINK &&
             rp->ReparseTag != IO_REPARSE_TAG_MOUNT_POINT) {
        e = ERROR_INVALID_PARAMETER;
    }
    CloseHandle(f);
    return e;
}
 
/* License: Ruby's */
int
rb_w32_reparse_symlink_p(const WCHAR *path)
{
    VALUE wtmp = 0;
    rb_w32_reparse_buffer_t rbuf, *rp = &rbuf;
    WCHAR *wbuf;
    DWORD len;
    int e;
 
    e = rb_w32_read_reparse_point(path, rp, sizeof(rbuf), &wbuf, &len);
    if (e == ERROR_MORE_DATA) {
        size_t size = rb_w32_reparse_buffer_size(len + 1);
        rp = ALLOCV(wtmp, size);
        e = rb_w32_read_reparse_point(path, rp, size, &wbuf, &len);
        ALLOCV_END(wtmp);
    }
    switch (e) {
      case 0:
      case ERROR_MORE_DATA:
        return TRUE;
    }
    return FALSE;
}
 
/* License: Ruby's */
int
rb_w32_read_reparse_point(const WCHAR *path, rb_w32_reparse_buffer_t *rp,
                          size_t bufsize, WCHAR **result, DWORD *len)
{
    int e = reparse_symlink(path, rp, bufsize);
    DWORD ret = 0;
 
    if (!e || e == ERROR_MORE_DATA) {
        void *name;
        if (rp->ReparseTag == IO_REPARSE_TAG_SYMLINK) {
            name = ((char *)rp->SymbolicLinkReparseBuffer.PathBuffer +
                    rp->SymbolicLinkReparseBuffer.PrintNameOffset);
            ret = rp->SymbolicLinkReparseBuffer.PrintNameLength;
            *len = ret / sizeof(WCHAR);
        }
        else if (rp->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT) {
            static const WCHAR volume[] = L"Volume{";
            enum {volume_prefix_len = rb_strlen_lit("\\??\\")};
            name = ((char *)rp->MountPointReparseBuffer.PathBuffer +
                    rp->MountPointReparseBuffer.SubstituteNameOffset +
                    volume_prefix_len * sizeof(WCHAR));
            ret = rp->MountPointReparseBuffer.SubstituteNameLength;
            *len = ret / sizeof(WCHAR);
            ret -= volume_prefix_len * sizeof(WCHAR);
            if (ret > sizeof(volume) - 1 * sizeof(WCHAR) &&
                memcmp(name, volume, sizeof(volume) - 1 * sizeof(WCHAR)) == 0)
                return -1;
        }
        else {
            return -1;
        }
        *result = name;
        if (e) {
            if ((char *)name + ret + sizeof(WCHAR) > (char *)rp + bufsize)
                return e;
            /* SubstituteName is not used */
        }
        ((WCHAR *)name)[ret/sizeof(WCHAR)] = L'\0';
        translate_wchar(name, L'\\', L'/');
        return 0;
    }
    else {
        return e;
    }
}
 
/* License: Ruby's */
static ssize_t
w32_readlink(UINT cp, const char *path, char *buf, size_t bufsize)
{
    VALUE rp_buf, rp_buf_bigger = 0;
    DWORD len = MultiByteToWideChar(cp, 0, path, -1, NULL, 0);
    size_t size = rb_w32_reparse_buffer_size(bufsize);
    WCHAR *wname;
    WCHAR *wpath = ALLOCV(rp_buf, sizeof(WCHAR) * len + size);
    rb_w32_reparse_buffer_t *rp = (void *)(wpath + len);
    ssize_t ret;
    int e;
 
    MultiByteToWideChar(cp, 0, path, -1, wpath, len);
    e = rb_w32_read_reparse_point(wpath, rp, size, &wname, &len);
    if (e == ERROR_MORE_DATA) {
        size = rb_w32_reparse_buffer_size(len + 1);
        rp = ALLOCV(rp_buf_bigger, size);
        e = rb_w32_read_reparse_point(wpath, rp, size, &wname, &len);
    }
    if (e) {
        ALLOCV_END(rp_buf);
        ALLOCV_END(rp_buf_bigger);
        errno = e == -1 ? EINVAL : map_errno(e);
        return -1;
    }
    len = lstrlenW(wname);
    ret = WideCharToMultiByte(cp, 0, wname, len, buf, bufsize, NULL, NULL);
    ALLOCV_END(rp_buf);
    ALLOCV_END(rp_buf_bigger);
    if (!ret) {
        ret = bufsize;
    }
    return ret;
}
 
/* License: Ruby's */
ssize_t
rb_w32_ureadlink(const char *path, char *buf, size_t bufsize)
{
    return w32_readlink(CP_UTF8, path, buf, bufsize);
}
 
/* License: Ruby's */
ssize_t
readlink(const char *path, char *buf, size_t bufsize)
{
    return w32_readlink(filecp(), path, buf, bufsize);
}
 
#ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
#define SYMBOLIC_LINK_FLAG_DIRECTORY (0x1)
#endif
#ifndef SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE
#define SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE (0x2)
#endif
 
/* License: Ruby's */
static int
w32_symlink(UINT cp, const char *src, const char *link)
{
    int atts, len1, len2;
    VALUE buf;
    WCHAR *wsrc, *wlink;
    DWORD flag = 0;
    BOOLEAN ret;
    int e;
 
    static DWORD create_flag = SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE;
 
    if (!*link) {
        errno = ENOENT;
        return -1;
    }
    if (!*src) {
        errno = EINVAL;
        return -1;
    }
    len1 = MultiByteToWideChar(cp, 0, src, -1, NULL, 0);
    len2 = MultiByteToWideChar(cp, 0, link, -1, NULL, 0);
    wsrc = ALLOCV_N(WCHAR, buf, len1+len2);
    wlink = wsrc + len1;
    MultiByteToWideChar(cp, 0, src, -1, wsrc, len1);
    MultiByteToWideChar(cp, 0, link, -1, wlink, len2);
    translate_wchar(wsrc, L'/', L'\\');
    translate_wchar(wlink, L'/', L'\\');
 
    /* A relative target is interpreted relative to the directory of the link,
       not the current directory.  Resolve it there to decide whether to create
       a directory symlink; otherwise a relative target pointing at a directory
       would wrongly become a file symlink when the current directory differs
       from the link's directory. */
    {
        WCHAR *sep;
        int independent =
            (((wsrc[0] >= L'A' && wsrc[0] <= L'Z') ||
              (wsrc[0] >= L'a' && wsrc[0] <= L'z')) && wsrc[1] == L':') ||
            wsrc[0] == L'\\';
        if (!independent && (sep = wcsrchr(wlink, L'\\')) != NULL) {
            VALUE buf2;
            size_t dirlen = sep - wlink + 1;
            size_t srclen = wcslen(wsrc) + 1;
            WCHAR *fullsrc = ALLOCV_N(WCHAR, buf2, dirlen + srclen);
            MEMCPY(fullsrc, wlink, WCHAR, dirlen);
            MEMCPY(fullsrc + dirlen, wsrc, WCHAR, srclen);
            atts = GetFileAttributesW(fullsrc);
            ALLOCV_END(buf2);
        }
        else {
            atts = GetFileAttributesW(wsrc);
        }
    }
    if (atts != -1 && atts & FILE_ATTRIBUTE_DIRECTORY)
        flag = SYMBOLIC_LINK_FLAG_DIRECTORY;
    ret = CreateSymbolicLinkW(wlink, wsrc, flag |= create_flag);
    if (!ret &&
        (e = GetLastError()) == ERROR_INVALID_PARAMETER &&
        (flag & SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE)) {
        create_flag = 0;
        flag &= ~SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE;
        ret = CreateSymbolicLinkW(wlink, wsrc, flag);
        if (!ret) e = GetLastError();
    }
    ALLOCV_END(buf);
 
    if (!ret) {
        errno = map_errno(e);
        return -1;
    }
    return 0;
}
 
/* License: Ruby's */
int
rb_w32_usymlink(const char *src, const char *link)
{
    return w32_symlink(CP_UTF8, src, link);
}
 
/* License: Ruby's */
int
symlink(const char *src, const char *link)
{
    return w32_symlink(filecp(), src, link);
}
 
/* License: Ruby's */
rb_pid_t
wait(int *status)
{
    return waitpid(-1, status, 0);
}
 
/* License: Ruby's */
static char *
w32_getenv(const char *name, UINT cp)
{
    WCHAR *wenvarea, *wenv;
    int len = strlen(name);
    char *env, *found = NULL;
    int wlen;
 
    if (len == 0) return NULL;
 
    if (!NTLoginName) {
        /* initialized in init_env, uenvarea_mutex should have been
         * initialized before it */
        return getenv(name);
    }
 
    thread_exclusive(uenvarea) {
        if (uenvarea) {
            free(uenvarea);
            uenvarea = NULL;
        }
        wenvarea = GetEnvironmentStringsW();
        if (!wenvarea) {
            map_errno(GetLastError());
            continue;
        }
        for (wenv = wenvarea, wlen = 1; *wenv; wenv += lstrlenW(wenv) + 1)
            wlen += lstrlenW(wenv) + 1;
        uenvarea = wstr_to_mbstr(cp, wenvarea, wlen, NULL);
        FreeEnvironmentStringsW(wenvarea);
        if (!uenvarea)
            continue;
 
        for (env = uenvarea; *env; env += strlen(env) + 1) {
            if (strncasecmp(env, name, len) == 0 && *(env + len) == '=') {
                found = env + len + 1;
                break;
            }
        }
    }
 
    return found;
}
 
/* License: Ruby's */
char *
rb_w32_ugetenv(const char *name)
{
    return w32_getenv(name, CP_UTF8);
}
 
/* License: Ruby's */
char *
rb_w32_getenv(const char *name)
{
    return w32_getenv(name, CP_ACP);
}
 
/* License: Ruby's */
static DWORD
get_attr_vsn(const WCHAR *path, DWORD *atts, DWORD *vsn)
{
    BY_HANDLE_FILE_INFORMATION st = {0};
    DWORD e = 0;
    HANDLE h = open_special(path, 0, FILE_FLAG_OPEN_REPARSE_POINT);
 
    if (h == INVALID_HANDLE_VALUE) {
        e = GetLastError();
        ASSUME(e);
        return e;
    }
    if (!GetFileInformationByHandle(h, &st)) {
        e = GetLastError();
        ASSUME(e);
    }
    else {
        *atts = st.dwFileAttributes;
        *vsn = st.dwVolumeSerialNumber;
    }
    CloseHandle(h);
    return e;
}
 
/* License: Artistic or GPL */
static int
wrename(const WCHAR *oldpath, const WCHAR *newpath)
{
    int res = 0;
    DWORD oldatts = 0, newatts = (DWORD)-1;
    DWORD oldvsn = 0, newvsn = 0, e;
 
    e = get_attr_vsn(oldpath, &oldatts, &oldvsn);
    if (e) {
        errno = map_errno(e);
        return -1;
    }
    if (oldatts & FILE_ATTRIBUTE_REPARSE_POINT) {
        HANDLE fh = open_special(oldpath, 0, 0);
        if (fh == INVALID_HANDLE_VALUE) {
            e = GetLastError();
            if (e == ERROR_CANT_RESOLVE_FILENAME) {
                errno = ELOOP;
                return -1;
            }
        }
        CloseHandle(fh);
    }
    get_attr_vsn(newpath, &newatts, &newvsn);
 
    RUBY_CRITICAL {
        if (newatts != (DWORD)-1 && newatts & FILE_ATTRIBUTE_READONLY)
            SetFileAttributesW(newpath, newatts & ~ FILE_ATTRIBUTE_READONLY);
 
        if (!MoveFileExW(oldpath, newpath, MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED))
            res = -1;
 
        if (res) {
            DWORD e = GetLastError();
            if ((e == ERROR_ACCESS_DENIED) && (oldatts & FILE_ATTRIBUTE_DIRECTORY) &&
                oldvsn != newvsn)
                errno = EXDEV;
            else
                errno = map_errno(e);
        }
        else
            SetFileAttributesW(newpath, oldatts);
    }
 
    return res;
}
 
/* License: Ruby's */
int
rb_w32_urename(const char *from, const char *to)
{
    WCHAR *wfrom;
    WCHAR *wto;
    int ret = -1;
 
    if (!(wfrom = utf8_to_wstr(from, NULL)))
        return -1;
    if (!(wto = utf8_to_wstr(to, NULL))) {
        free(wfrom);
        return -1;
    }
    ret = wrename(wfrom, wto);
    free(wto);
    free(wfrom);
    return ret;
}
 
/* License: Ruby's */
int
rb_w32_rename(const char *from, const char *to)
{
    WCHAR *wfrom;
    WCHAR *wto;
    int ret = -1;
 
    if (!(wfrom = filecp_to_wstr(from, NULL)))
        return -1;
    if (!(wto = filecp_to_wstr(to, NULL))) {
        free(wfrom);
        return -1;
    }
    ret = wrename(wfrom, wto);
    free(wto);
    free(wfrom);
    return ret;
}
 
/* License: Ruby's */
static int
isUNCRoot(const WCHAR *path)
{
    if (path[0] == L'\\' && path[1] == L'\\') {
        const WCHAR *p = path + 2;
        if (p[0] == L'?' && p[1] == L'\\') {
            p += 2;
        }
        for (; *p; p++) {
            if (*p == L'\\')
                break;
        }
        if (p[0] && p[1]) {
            for (p++; *p; p++) {
                if (*p == L'\\')
                    break;
            }
            if (!p[0] || !p[1] || (p[1] == L'.' && !p[2]))
                return 1;
        }
    }
    return 0;
}
 
#define COPY_STAT(src, dest, size_cast) do {    \
        (dest).st_dev   = (src).st_dev;         \
        (dest).st_ino   = (src).st_ino;         \
        (dest).st_mode  = (src).st_mode;        \
        (dest).st_nlink = (src).st_nlink;       \
        (dest).st_uid   = (src).st_uid;         \
        (dest).st_gid   = (src).st_gid;         \
        (dest).st_rdev  = (src).st_rdev;        \
        (dest).st_size  = size_cast(src).st_size; \
        (dest).st_atime = (src).st_atime;       \
        (dest).st_mtime = (src).st_mtime;       \
        (dest).st_ctime = (src).st_ctime;       \
    } while (0)
 
static time_t filetime_to_unixtime(const FILETIME *ft);
static long filetime_to_nsec(const FILETIME *ft);
static WCHAR *name_for_stat(WCHAR *buf, const WCHAR *path);
static DWORD stati128_handle(HANDLE h, struct stati128 *st);
 
#undef fstat
/* License: Ruby's */
int
rb_w32_fstat(int fd, struct stat *st)
{
    BY_HANDLE_FILE_INFORMATION info;
    int ret = fstat(fd, st);
 
    if (ret) return ret;
    if (GetEnvironmentVariableW(L"TZ", NULL, 0) == 0 && GetLastError() == ERROR_ENVVAR_NOT_FOUND) return ret;
    if (GetFileInformationByHandle((HANDLE)_get_osfhandle(fd), &info)) {
        st->st_atime = filetime_to_unixtime(&info.ftLastAccessTime);
        st->st_mtime = filetime_to_unixtime(&info.ftLastWriteTime);
        st->st_ctime = filetime_to_unixtime(&info.ftCreationTime);
    }
    return ret;
}
 
/* License: Ruby's */
int
rb_w32_fstati128(int fd, struct stati128 *st)
{
    struct stat tmp;
    int ret = fstat(fd, &tmp);
 
    if (ret) return ret;
    COPY_STAT(tmp, *st, +);
    stati128_handle((HANDLE)_get_osfhandle(fd), st);
    return ret;
}
 
#if !defined FILE_INVALID_FILE_ID && !defined __MINGW32__
typedef struct {
    BYTE  Identifier[16];
} FILE_ID_128;
#endif
 
#if !defined(_WIN32_WINNT_WIN8) || _WIN32_WINNT < 0x602
#define FileIdInfo 0x12
 
typedef struct {
    unsigned LONG_LONG VolumeSerialNumber;
    FILE_ID_128 FileId;
} FILE_ID_INFO;
#endif
 
static BOOL
get_ino(HANDLE h, FILE_ID_INFO *id)
{
    return GetFileInformationByHandleEx(h, FileIdInfo, id, sizeof(*id));
}
 
/* License: Ruby's */
static DWORD
stati128_handle(HANDLE h, struct stati128 *st)
{
    BY_HANDLE_FILE_INFORMATION info;
    DWORD attr = (DWORD)-1;
 
    if (GetFileInformationByHandle(h, &info)) {
        FILE_ID_INFO fii;
        st->st_size = ((__int64)info.nFileSizeHigh << 32) | info.nFileSizeLow;
        st->st_atime = filetime_to_unixtime(&info.ftLastAccessTime);
        st->st_atimensec = filetime_to_nsec(&info.ftLastAccessTime);
        st->st_mtime = filetime_to_unixtime(&info.ftLastWriteTime);
        st->st_mtimensec = filetime_to_nsec(&info.ftLastWriteTime);
        st->st_ctime = filetime_to_unixtime(&info.ftCreationTime);
        st->st_ctimensec = filetime_to_nsec(&info.ftCreationTime);
        st->st_nlink = info.nNumberOfLinks;
        attr = info.dwFileAttributes;
        if (get_ino(h, &fii)) {
            st->st_ino = *((unsigned __int64 *)&fii.FileId);
            st->st_inohigh = *((__int64 *)&fii.FileId + 1);
        }
        else {
            st->st_ino = ((__int64)info.nFileIndexHigh << 32) | info.nFileIndexLow;
            st->st_inohigh = 0;
        }
    }
    return attr;
}
 
/* License: Ruby's */
static time_t
filetime_to_unixtime(const FILETIME *ft)
{
    long subsec;
    time_t t = filetime_split(ft, &subsec);
 
    if (t < 0) return 0;
    return t;
}
 
/* License: Ruby's */
static long
filetime_to_nsec(const FILETIME *ft)
{
    ULARGE_INTEGER tmp;
    tmp.LowPart = ft->dwLowDateTime;
    tmp.HighPart = ft->dwHighDateTime;
    return (long)(tmp.QuadPart % 10000000) * 100;
}
 
/* License: Ruby's */
static unsigned
fileattr_to_unixmode(DWORD attr, const WCHAR *path, unsigned mode)
{
    if (attr & FILE_ATTRIBUTE_READONLY) {
        mode |= S_IREAD;
    }
    else {
        mode |= S_IREAD | S_IWRITE | S_IWUSR;
    }
 
    if (mode & S_IFMT) {
        /* format is already set */
    }
    else if (attr & FILE_ATTRIBUTE_REPARSE_POINT) {
        /* Only used by stat_by_find in the case the file can not be opened.
         * In this case we can't get more details. */
    }
    else if (attr & FILE_ATTRIBUTE_DIRECTORY) {
        mode |= S_IFDIR | S_IEXEC;
    }
    else {
        mode |= S_IFREG;
    }
 
    if (path && (mode & S_IFREG)) {
        const WCHAR *end = path + lstrlenW(path);
        while (path < end) {
            end = CharPrevW(path, end);
            if (*end == L'.') {
                if ((_wcsicmp(end, L".bat") == 0) ||
                    (_wcsicmp(end, L".cmd") == 0) ||
                    (_wcsicmp(end, L".com") == 0) ||
                    (_wcsicmp(end, L".exe") == 0)) {
                    mode |= S_IEXEC;
                }
                break;
            }
            if (!iswalnum(*end)) break;
        }
    }
 
    mode |= (mode & 0500) >> 3;
    mode |= (mode & 0500) >> 6;
 
    return mode;
}
 
/* License: Ruby's */
static int
check_valid_dir(const WCHAR *path)
{
    WIN32_FIND_DATAW fd;
    HANDLE fh;
    WCHAR full[PATH_MAX];
    WCHAR *p, *q;
 
    /* GetFileAttributes() determines "..." as directory. */
    /* We recheck it by FindFirstFile(). */
    if (!(p = wcsstr(path, L"...")))
        return 0;
    q = p + wcsspn(p, L".");
    if ((p == path || wcschr(L":/\\", *(p - 1))) &&
        (!*q || wcschr(L":/\\", *q))) {
        errno = ENOENT;
        return -1;
    }
 
    /* if the specified path is the root of a drive and the drive is empty, */
    /* FindFirstFile() returns INVALID_HANDLE_VALUE. */
    DWORD len = GetFullPathNameW(path, numberof(full), full, NULL);
    if (len >= numberof(full)) {
        WCHAR *fullpath = malloc(len * sizeof(WCHAR));
        if (!fullpath) return -1;
        len = GetFullPathNameW(path, len, fullpath, NULL);
        if (len == 3) MEMCPY(full, fullpath, WCHAR, len+1);
        free(fullpath);
    }
    if (!len) {
        errno = map_errno(GetLastError());
        return -1;
    }
    if (len == 3 && full[1] == L':' && GetDriveTypeW(full) != DRIVE_NO_ROOT_DIR)
        return 0;               /* x:\ only */
 
    fh = open_dir_handle(path, &fd);
    if (fh == INVALID_HANDLE_VALUE)
        return -1;
    FindClose(fh);
    return 0;
}
 
/* License: Ruby's */
static int
stat_by_find(const WCHAR *path, struct stati128 *st)
{
    HANDLE h;
    WIN32_FIND_DATAW wfd;
 
    /* Fall back to FindFirstFile for ERROR_SHARING_VIOLATION */
    h = FindFirstFileW(path, &wfd);
    if (h == INVALID_HANDLE_VALUE) {
        errno = map_errno(GetLastError());
        return -1;
    }
    FindClose(h);
    st->st_mode  = fileattr_to_unixmode(wfd.dwFileAttributes, path, 0);
    st->st_atime = filetime_to_unixtime(&wfd.ftLastAccessTime);
    st->st_atimensec = filetime_to_nsec(&wfd.ftLastAccessTime);
    st->st_mtime = filetime_to_unixtime(&wfd.ftLastWriteTime);
    st->st_mtimensec = filetime_to_nsec(&wfd.ftLastWriteTime);
    st->st_ctime = filetime_to_unixtime(&wfd.ftCreationTime);
    st->st_ctimensec = filetime_to_nsec(&wfd.ftCreationTime);
    st->st_size = ((__int64)wfd.nFileSizeHigh << 32) | wfd.nFileSizeLow;
    st->st_nlink = 1;
    return 0;
}
 
/* License: Ruby's */
static int
path_drive(const WCHAR *path)
{
    if (path[0] && path[1] == L':') {
        if (iswalpha(path[0])) return towupper(path[0]) - L'A';
        return (int)path[0];
    }
    return _getdrive() - 1;
}
 
#if !defined(NTDDI_WIN11_ZN) || NTDDI_VERSION < NTDDI_WIN11_ZN
/* FileStatBasicByNameInfo in FILE_INFO_BY_NAME_CLASS and
 * FILE_STAT_BASIC_INFORMATION, in SDKs since Windows 11 24H2 */
#define FileStatBasicByNameInfo 3
 
typedef struct {
    LARGE_INTEGER FileId;
    LARGE_INTEGER CreationTime;
    LARGE_INTEGER LastAccessTime;
    LARGE_INTEGER LastWriteTime;
    LARGE_INTEGER ChangeTime;
    LARGE_INTEGER AllocationSize;
    LARGE_INTEGER EndOfFile;
    DWORD FileAttributes;
    DWORD ReparseTag;
    DWORD NumberOfLinks;
    DWORD DeviceType;
    DWORD DeviceCharacteristics;
    DWORD Reserved;
    LARGE_INTEGER VolumeSerialNumber;
    FILE_ID_128 FileId128;
} FILE_STAT_BASIC_INFORMATION;
#endif
 
#ifndef FILE_DEVICE_DISK
#define FILE_DEVICE_DISK 7
#endif
 
typedef BOOL (WINAPI *get_file_information_by_name_func)
    (PCWSTR, int /* FILE_INFO_BY_NAME_CLASS */, PVOID, ULONG);
static get_file_information_by_name_func get_file_information_by_name =
    (get_file_information_by_name_func)-1;
 
/* License: Ruby's */
static time_t
large_integer_to_unixtime(const LARGE_INTEGER *at, long *nsecp)
{
    FILETIME ft;
 
    ft.dwLowDateTime = at->LowPart;
    ft.dwHighDateTime = at->HighPart;
    *nsecp = filetime_to_nsec(&ft);
    return filetime_to_unixtime(&ft);
}
 
/* License: Ruby's */
static LONG_LONG
path_drive_serial(const WCHAR *path)
{
    static LONG_LONG serials[26];
    int drive;
 
    if (path[0] && path[1] == L':') {
        if (!iswalpha(path[0])) return 0;
        drive = towupper(path[0]) - L'A';
    }
    else {
        drive = _getdrive() - 1;
    }
    if (drive < 0 || (int)numberof(serials) <= drive) return 0;
    if (!serials[drive]) {
        FILE_STAT_BASIC_INFORMATION info;
        WCHAR root[] = L"_:\\";
        root[0] = L'A' + drive;
        if (get_file_information_by_name(root, FileStatBasicByNameInfo,
                                         &info, sizeof(info)))
            serials[drive] = info.VolumeSerialNumber.QuadPart;
    }
    return serials[drive];
}
 
/* License: Ruby's */
static int
stat_by_name(const WCHAR *path, struct stati128 *st)
{
    /* Fill the stat result from a single metadata syscall, without
     * opening a file handle.  Returns 1 to fall back to the
     * handle-based path. */
    FILE_STAT_BASIC_INFORMATION info;
    unsigned __int64 ino;
    __int64 inohigh;
 
    if (get_file_information_by_name == (get_file_information_by_name_func)-1) {
        /* Since Windows 11 24H2 */
        get_file_information_by_name = (get_file_information_by_name_func)
            get_proc_address("kernel32", "GetFileInformationByName", NULL);
    }
    if (!get_file_information_by_name) return 1;
    if (!get_file_information_by_name(path, FileStatBasicByNameInfo,
                                      &info, sizeof(info))) {
        DWORD e = GetLastError();
        switch (e) {
          case ERROR_FILE_NOT_FOUND:
          case ERROR_INVALID_NAME:
          case ERROR_PATH_NOT_FOUND:
          case ERROR_BAD_NETPATH:
            errno = map_errno(e);
            return -1;
        }
        return 1;               /* devices, UNC paths, unusual errors */
    }
    if (info.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
        return 1;               /* symlinks, junctions, AF_UNIX sockets */
    if (info.DeviceType != FILE_DEVICE_DISK)
        return 1;
    if (info.VolumeSerialNumber.QuadPart != path_drive_serial(path))
        return 1;               /* reparse point in intermediate components */
    ino = *((unsigned __int64 *)&info.FileId128);
    inohigh = *((__int64 *)&info.FileId128 + 1);
    if (!ino && !inohigh)
        return 1;               /* file ID is not available */
    if (info.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
        if (check_valid_dir(path)) return -1;
    }
    st->st_ino = ino;
    st->st_inohigh = inohigh;
    st->st_size = info.EndOfFile.QuadPart;
    st->st_atime = large_integer_to_unixtime(&info.LastAccessTime, &st->st_atimensec);
    st->st_mtime = large_integer_to_unixtime(&info.LastWriteTime, &st->st_mtimensec);
    st->st_ctime = large_integer_to_unixtime(&info.CreationTime, &st->st_ctimensec);
    st->st_nlink = info.NumberOfLinks;
    st->st_mode = fileattr_to_unixmode(info.FileAttributes, path, 0);
    st->st_dev = st->st_rdev = path_drive(path);
    return 0;
}
 
/* License: Ruby's */
static int
winnt_stat(const WCHAR *path, struct stati128 *st, BOOL lstat)
{
    DWORD flags = lstat ? FILE_FLAG_OPEN_REPARSE_POINT : 0;
    HANDLE f;
    WCHAR *finalname = 0;
    int open_error;
 
    memset(st, 0, sizeof(*st));
    switch (stat_by_name(path, st)) {
      case 0:
        return 0;
      case -1:
        return -1;
    }
    f = open_special(path, 0, flags);
    open_error = GetLastError();
    if (f == INVALID_HANDLE_VALUE && !lstat) {
        /* Support stat (not only lstat) of UNIXSocket */
        FILE_ATTRIBUTE_TAG_INFO attr_info;
        DWORD e;
 
        f = open_special(path, 0, FILE_FLAG_OPEN_REPARSE_POINT);
        e = GetFileInformationByHandleEx(f, FileAttributeTagInfo,
                                         &attr_info, sizeof(attr_info));
        if (!e || attr_info.ReparseTag != IO_REPARSE_TAG_AF_UNIX) {
            CloseHandle(f);
            f = INVALID_HANDLE_VALUE;
        }
    }
    if (f != INVALID_HANDLE_VALUE) {
        DWORD attr = stati128_handle(f, st);
        unsigned mode = 0;
        switch (GetFileType(f)) {
          case FILE_TYPE_CHAR:
            mode = S_IFCHR;
            break;
          case FILE_TYPE_PIPE:
            mode = S_IFIFO;
            break;
          default:
            if (attr & FILE_ATTRIBUTE_DIRECTORY) {
                if (check_valid_dir(path)) return -1;
            }
            if (attr & FILE_ATTRIBUTE_REPARSE_POINT) {
                FILE_ATTRIBUTE_TAG_INFO attr_info;
                DWORD e;
 
                e = GetFileInformationByHandleEx(f, FileAttributeTagInfo,
                                                 &attr_info, sizeof(attr_info));
                if (e && attr_info.ReparseTag == IO_REPARSE_TAG_AF_UNIX) {
                    st->st_size = 0;
                    mode |= S_IFSOCK;
                }
                else if (rb_w32_reparse_symlink_p(path)) {
                    /* TODO: size in which encoding? */
                    st->st_size = 0;
                    mode |= S_IFLNK | S_IEXEC;
                }
                else {
                    mode |= S_IFDIR | S_IEXEC;
                }
            }
        }
        const DWORD len = get_handle_pathname(f, &finalname, 0);
        CloseHandle(f);
        st->st_mode = fileattr_to_unixmode(attr, path, mode);
        if (len) {
            path = finalname;
            if (wcsncmp(path, namespace_prefix, numberof(namespace_prefix)) == 0)
                path += numberof(namespace_prefix);
        }
    }
    else {
        switch (open_error) {
          case ERROR_FILE_NOT_FOUND:
          case ERROR_INVALID_NAME:
          case ERROR_PATH_NOT_FOUND:
          case ERROR_BAD_NETPATH:
          case ERROR_CANT_RESOLVE_FILENAME:
            errno = map_errno(open_error);
            return -1;
        }
 
        if (stat_by_find(path, st)) return -1;
    }
 
    st->st_dev = st->st_rdev = path_drive(path);
    if (finalname) free(finalname);
 
    return 0;
}
 
/* License: Ruby's */
int
rb_w32_stat(const char *path, struct stat *st)
{
    struct stati128 tmp;
 
    if (w32_stati128(path, &tmp, filecp(), FALSE)) return -1;
    COPY_STAT(tmp, *st, (_off_t));
    return 0;
}
 
/* License: Ruby's */
static int
wstati128(const WCHAR *path, struct stati128 *st, BOOL lstat)
{
    WCHAR *buf1;
    int ret, size;
    VALUE v;
 
    if (!path || !st) {
        errno = EFAULT;
        return -1;
    }
    size = lstrlenW(path) + 2;
    buf1 = ALLOCV_N(WCHAR, v, size);
    if (!(path = name_for_stat(buf1, path)))
        return -1;
    ret = winnt_stat(path, st, lstat);
    if (v)
        ALLOCV_END(v);
 
    return ret;
}
 
/* License: Ruby's */
static WCHAR *
name_for_stat(WCHAR *buf1, const WCHAR *path)
{
    const WCHAR *p;
    WCHAR *s, *end;
    int len;
 
    for (p = path, s = buf1; *p; p++, s++) {
        if (*p == L'/')
            *s = L'\\';
        else
            *s = *p;
    }
    *s = '\0';
    len = s - buf1;
    if (!len || L'\"' == *(--s)) {
        errno = ENOENT;
        return NULL;
    }
    end = buf1 + len - 1;
 
    if (isUNCRoot(buf1)) {
        if (*end == L'.')
            *end = L'\0';
        else if (*end != L'\\')
            lstrcatW(buf1, L"\\");
    }
    else if (*end == L'\\' || (buf1 + 1 == end && *end == L':'))
        lstrcatW(buf1, L".");
 
    return buf1;
}
 
/* License: Ruby's */
int
rb_w32_ustati128(const char *path, struct stati128 *st)
{
    return w32_stati128(path, st, CP_UTF8, FALSE);
}
 
/* License: Ruby's */
int
rb_w32_stati128(const char *path, struct stati128 *st)
{
    return w32_stati128(path, st, filecp(), FALSE);
}
 
/* License: Ruby's */
static int
w32_stati128(const char *path, struct stati128 *st, UINT cp, BOOL lstat)
{
    WCHAR *wpath;
    int ret;
 
    if (!(wpath = mbstr_to_wstr(cp, path, -1, NULL)))
        return -1;
    ret = wstati128(wpath, st, lstat);
    free(wpath);
    return ret;
}
 
/* License: Ruby's */
int
rb_w32_ulstati128(const char *path, struct stati128 *st)
{
    return w32_stati128(path, st, CP_UTF8, TRUE);
}
 
/* License: Ruby's */
int
rb_w32_lstati128(const char *path, struct stati128 *st)
{
    return w32_stati128(path, st, filecp(), TRUE);
}
 
/* License: Ruby's */
rb_off_t
rb_w32_lseek(int fd, rb_off_t ofs, int whence)
{
    SOCKET sock = TO_SOCKET(fd);
    if (is_socket(sock) || is_pipe(sock)) {
        errno = ESPIPE;
        return -1;
    }
    return _lseeki64(fd, ofs, whence);
}
 
/* License: Ruby's */
static int
w32_access(const char *path, int mode, UINT cp)
{
    struct stati128 stat;
    if (w32_stati128(path, &stat, cp, FALSE) != 0)
        return -1;
    mode <<= 6;
    if ((stat.st_mode & mode) != mode) {
        errno = EACCES;
        return -1;
    }
    return 0;
}
 
/* License: Ruby's */
int
rb_w32_access(const char *path, int mode)
{
    return w32_access(path, mode, filecp());
}
 
/* License: Ruby's */
int
rb_w32_uaccess(const char *path, int mode)
{
    return w32_access(path, mode, CP_UTF8);
}
 
/* License: Ruby's */
static int
rb_chsize(HANDLE h, rb_off_t size)
{
    long upos, lpos, usize, lsize;
    int ret = -1;
    DWORD e;
 
    if ((lpos = SetFilePointer(h, 0, (upos = 0, &upos), SEEK_CUR)) == -1L &&
        (e = GetLastError())) {
        errno = map_errno(e);
        return -1;
    }
    usize = (long)(size >> 32);
    lsize = (long)size;
    if (SetFilePointer(h, lsize, &usize, SEEK_SET) == (DWORD)-1L &&
        (e = GetLastError())) {
        errno = map_errno(e);
    }
    else if (!SetEndOfFile(h)) {
        errno = map_errno(GetLastError());
    }
    else {
        ret = 0;
    }
    SetFilePointer(h, lpos, &upos, SEEK_SET);
    return ret;
}
 
/* License: Ruby's */
static int
w32_truncate(const char *path, rb_off_t length, UINT cp)
{
    HANDLE h;
    int ret;
    WCHAR *wpath;
 
    if (!(wpath = mbstr_to_wstr(cp, path, -1, NULL)))
        return -1;
    h = CreateFileW(wpath, GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);
    if (h == INVALID_HANDLE_VALUE) {
        errno = map_errno(GetLastError());
        free(wpath);
        return -1;
    }
    free(wpath);
    ret = rb_chsize(h, length);
    CloseHandle(h);
    return ret;
}
 
/* License: Ruby's */
int
rb_w32_utruncate(const char *path, rb_off_t length)
{
    return w32_truncate(path, length, CP_UTF8);
}
 
/* License: Ruby's */
int
rb_w32_truncate(const char *path, rb_off_t length)
{
    return w32_truncate(path, length, filecp());
}
 
/* License: Ruby's */
int
rb_w32_ftruncate(int fd, rb_off_t length)
{
    HANDLE h;
 
    h = (HANDLE)_get_osfhandle(fd);
    if (h == (HANDLE)-1) return -1;
    return rb_chsize(h, length);
}
 
/* License: Ruby's */
static long
filetime_to_clock(FILETIME *ft)
{
    __int64 qw = ft->dwHighDateTime;
    qw <<= 32;
    qw |= ft->dwLowDateTime;
    qw /= 10000;  /* File time ticks at 0.1uS, clock at 1mS */
    return (long) qw;
}
 
/* License: Ruby's */
int
rb_w32_times(struct tms *tmbuf)
{
    FILETIME create, exit, kernel, user;
 
    if (GetProcessTimes(GetCurrentProcess(),&create, &exit, &kernel, &user)) {
        tmbuf->tms_utime = filetime_to_clock(&user);
        tmbuf->tms_stime = filetime_to_clock(&kernel);
        tmbuf->tms_cutime = 0;
        tmbuf->tms_cstime = 0;
    }
    else {
        tmbuf->tms_utime = clock();
        tmbuf->tms_stime = 0;
        tmbuf->tms_cutime = 0;
        tmbuf->tms_cstime = 0;
    }
    return 0;
}
 
 
/* License: Ruby's */
#define yield_once() Sleep(0)
#define yield_until(condition) do yield_once(); while (!(condition))
 
/* License: Ruby's */
struct asynchronous_arg_t {
    /* output field */
    void* stackaddr;
    int errnum;
 
    /* input field */
    uintptr_t (*func)(uintptr_t self, int argc, uintptr_t* argv);
    uintptr_t self;
    int argc;
    uintptr_t* argv;
};
 
/* License: Ruby's */
static DWORD WINAPI
call_asynchronous(PVOID argp)
{
    DWORD ret;
    struct asynchronous_arg_t *arg = argp;
    arg->stackaddr = &argp;
    ret = (DWORD)arg->func(arg->self, arg->argc, arg->argv);
    arg->errnum = errno;
    return ret;
}
 
/* License: Ruby's */
uintptr_t
rb_w32_asynchronize(asynchronous_func_t func, uintptr_t self,
                    int argc, uintptr_t* argv, uintptr_t intrval)
{
    DWORD val;
    BOOL interrupted = FALSE;
    HANDLE thr;
 
    RUBY_CRITICAL {
        struct asynchronous_arg_t arg;
 
        arg.stackaddr = NULL;
        arg.errnum = 0;
        arg.func = func;
        arg.self = self;
        arg.argc = argc;
        arg.argv = argv;
 
        thr = CreateThread(NULL, 0, call_asynchronous, &arg, 0, &val);
 
        if (thr) {
            yield_until(arg.stackaddr);
 
            if (rb_w32_wait_events_blocking(&thr, 1, INFINITE) != WAIT_OBJECT_0) {
                interrupted = TRUE;
 
                if (TerminateThread(thr, intrval)) {
                    yield_once();
                }
            }
 
            GetExitCodeThread(thr, &val);
            CloseHandle(thr);
 
            if (interrupted) {
                /* must release stack of killed thread, why doesn't Windows? */
                MEMORY_BASIC_INFORMATION m;
 
                memset(&m, 0, sizeof(m));
                if (!VirtualQuery(arg.stackaddr, &m, sizeof(m))) {
                    Debug(fprintf(stderr, "couldn't get stack base:%p:%d\n",
                                  arg.stackaddr, GetLastError()));
                }
                else if (!VirtualFree(m.AllocationBase, 0, MEM_RELEASE)) {
                    Debug(fprintf(stderr, "couldn't release stack:%p:%d\n",
                                  m.AllocationBase, GetLastError()));
                }
                errno = EINTR;
            }
            else {
                errno = arg.errnum;
            }
        }
    }
 
    if (!thr) {
        rb_fatal("failed to launch waiter thread:%ld", GetLastError());
    }
 
    return val;
}
 
/* License: Ruby's */
char **
rb_w32_get_environ(void)
{
    WCHAR *envtop, *env;
    char **myenvtop, **myenv;
    int num;
 
    /*
     * We avoid values started with `='. If you want to deal those values,
     * change this function, and some functions in hash.c which recognize
     * `=' as delimiter or rb_w32_getenv() and ruby_setenv().
     * CygWin deals these values by changing first `=' to '!'. But we don't
     * use such trick and follow cmd.exe's way that just doesn't show these
     * values.
     *
     * This function returns UTF-8 strings.
     */
    envtop = GetEnvironmentStringsW();
    for (env = envtop, num = 0; *env; env += lstrlenW(env) + 1)
        if (*env != '=') num++;
 
    myenvtop = (char **)malloc(sizeof(char *) * (num + 1));
    for (env = envtop, myenv = myenvtop; *env; env += lstrlenW(env) + 1) {
        if (*env != '=') {
            if (!(*myenv = wstr_to_utf8(env, NULL))) {
                break;
            }
            myenv++;
        }
    }
    *myenv = NULL;
    FreeEnvironmentStringsW(envtop);
 
    return myenvtop;
}
 
/* License: Ruby's */
void
rb_w32_free_environ(char **env)
{
    char **t = env;
 
    while (*t) free(*t++);
    free(env);
}
 
/* License: Ruby's */
rb_pid_t
rb_w32_getpid(void)
{
    return GetCurrentProcessId();
}
 
 
/* License: Ruby's */
rb_pid_t
rb_w32_getppid(void)
{
    typedef long (WINAPI query_func)(HANDLE, int, void *, ULONG, ULONG *);
    static query_func *pNtQueryInformationProcess = (query_func *)-1;
    rb_pid_t ppid = 0;
 
    if (pNtQueryInformationProcess == (query_func *)-1)
        pNtQueryInformationProcess = (query_func *)get_proc_address("ntdll.dll", "NtQueryInformationProcess", NULL);
    if (pNtQueryInformationProcess) {
        struct {
            long ExitStatus;
            void* PebBaseAddress;
            uintptr_t AffinityMask;
            uintptr_t BasePriority;
            uintptr_t UniqueProcessId;
            uintptr_t ParentProcessId;
        } pbi;
        ULONG len;
        long ret = pNtQueryInformationProcess(GetCurrentProcess(), 0, &pbi, sizeof(pbi), &len);
        if (!ret) {
            ppid = pbi.ParentProcessId;
        }
    }
 
    return ppid;
}
 
STATIC_ASSERT(std_handle, (STD_OUTPUT_HANDLE-STD_INPUT_HANDLE)==(STD_ERROR_HANDLE-STD_OUTPUT_HANDLE));
 
/* License: Ruby's */
#define set_new_std_handle(newfd, handle) do { \
        if ((unsigned)(newfd) > 2) break; \
        SetStdHandle(STD_INPUT_HANDLE+(STD_OUTPUT_HANDLE-STD_INPUT_HANDLE)*(newfd), \
                     (handle)); \
    } while (0)
#define set_new_std_fd(newfd) set_new_std_handle(newfd, (HANDLE)rb_w32_get_osfhandle(newfd))
 
/* License: Ruby's */
int
rb_w32_dup2(int oldfd, int newfd)
{
    int ret;
 
    if (oldfd == newfd) return newfd;
    ret = dup2(oldfd, newfd);
    if (ret < 0) return ret;
    set_new_std_fd(newfd);
    return newfd;
}
 
/* License: Ruby's */
int
rb_w32_uopen(const char *file, int oflag, ...)
{
    WCHAR *wfile;
    int ret;
    int pmode;
 
    va_list arg;
    va_start(arg, oflag);
    pmode = va_arg(arg, int);
    va_end(arg);
 
    if (!(wfile = utf8_to_wstr(file, NULL)))
        return -1;
    ret = w32_wopen(wfile, oflag, pmode);
    free(wfile);
    return ret;
}
 
/* License: Ruby's */
static int
check_if_wdir(const WCHAR *wfile)
{
    DWORD attr = GetFileAttributesW(wfile);
    if (attr == (DWORD)-1L ||
        !(attr & FILE_ATTRIBUTE_DIRECTORY) ||
        check_valid_dir(wfile)) {
        return FALSE;
    }
    errno = EISDIR;
    return TRUE;
}
 
/* License: Ruby's */
int
rb_w32_open(const char *file, int oflag, ...)
{
    WCHAR *wfile;
    int ret;
    int pmode;
 
    va_list arg;
    va_start(arg, oflag);
    pmode = va_arg(arg, int);
    va_end(arg);
 
    if (!(wfile = filecp_to_wstr(file, NULL)))
        return -1;
    ret = w32_wopen(wfile, oflag, pmode);
    free(wfile);
    return ret;
}
 
/* License: Ruby's */
int
rb_w32_wopen(const WCHAR *file, int oflag, ...)
{
    int pmode = 0;
 
    if (oflag & O_CREAT) {
        va_list arg;
        va_start(arg, oflag);
        pmode = va_arg(arg, int);
        va_end(arg);
    }
 
    return w32_wopen(file, oflag, pmode);
}
 
static int
w32_wopen(const WCHAR *file, int oflag, int pmode)
{
    char flags = 0;
    int fd;
    DWORD access;
    DWORD create;
    DWORD attr = FILE_ATTRIBUTE_NORMAL;
    SECURITY_ATTRIBUTES sec;
    HANDLE h;
    int share_delete;
 
    share_delete = oflag & O_SHARE_DELETE ? FILE_SHARE_DELETE : 0;
    oflag &= ~O_SHARE_DELETE;
    if ((oflag & O_TEXT) || !(oflag & O_BINARY)) {
        fd = _wopen(file, oflag, pmode);
        if (fd == -1) {
            switch (errno) {
              case EACCES:
                check_if_wdir(file);
                break;
              case EINVAL:
                errno = map_errno(GetLastError());
                break;
            }
        }
        return fd;
    }
 
    sec.nLength = sizeof(sec);
    sec.lpSecurityDescriptor = NULL;
    if (oflag & O_NOINHERIT) {
        sec.bInheritHandle = FALSE;
        flags |= FNOINHERIT;
    }
    else {
        sec.bInheritHandle = TRUE;
    }
    oflag &= ~O_NOINHERIT;
 
    /* always open with binary mode */
    oflag &= ~(O_BINARY | O_TEXT);
 
    switch (oflag & (O_RDWR | O_RDONLY | O_WRONLY)) {
      case O_RDWR:
        access = GENERIC_READ | GENERIC_WRITE;
        break;
      case O_RDONLY:
        access = GENERIC_READ;
        break;
      case O_WRONLY:
        access = GENERIC_WRITE;
        break;
      default:
        errno = EINVAL;
        return -1;
    }
    oflag &= ~(O_RDWR | O_RDONLY | O_WRONLY);
 
    switch (oflag & (O_CREAT | O_EXCL | O_TRUNC)) {
      case O_CREAT:
        create = OPEN_ALWAYS;
        break;
      case 0:
      case O_EXCL:
        create = OPEN_EXISTING;
        break;
      case O_CREAT | O_EXCL:
      case O_CREAT | O_EXCL | O_TRUNC:
        create = CREATE_NEW;
        break;
      case O_TRUNC:
      case O_TRUNC | O_EXCL:
        create = TRUNCATE_EXISTING;
        break;
      case O_CREAT | O_TRUNC:
        create = CREATE_ALWAYS;
        break;
      default:
        errno = EINVAL;
        return -1;
    }
    if (oflag & O_CREAT) {
        /* TODO: we need to check umask here, but it's not exported... */
        if (!(pmode & S_IWRITE))
            attr = FILE_ATTRIBUTE_READONLY;
    }
    oflag &= ~(O_CREAT | O_EXCL | O_TRUNC);
 
    if (oflag & O_TEMPORARY) {
        attr |= FILE_FLAG_DELETE_ON_CLOSE;
        access |= DELETE;
    }
    oflag &= ~O_TEMPORARY;
 
    if (oflag & _O_SHORT_LIVED)
        attr |= FILE_ATTRIBUTE_TEMPORARY;
    oflag &= ~_O_SHORT_LIVED;
 
    switch (oflag & (O_SEQUENTIAL | O_RANDOM)) {
      case 0:
        break;
      case O_SEQUENTIAL:
        attr |= FILE_FLAG_SEQUENTIAL_SCAN;
        break;
      case O_RANDOM:
        attr |= FILE_FLAG_RANDOM_ACCESS;
        break;
      default:
        errno = EINVAL;
        return -1;
    }
    oflag &= ~(O_SEQUENTIAL | O_RANDOM);
 
    if (oflag & ~O_APPEND) {
        errno = EINVAL;
        return -1;
    }
 
    /* allocate a C Runtime file handle */
    RUBY_CRITICAL {
        h = CreateFile("NUL", 0, 0, NULL, OPEN_ALWAYS, 0, NULL);
        fd = _open_osfhandle((intptr_t)h, 0);
        CloseHandle(h);
    }
    if (fd == -1) {
        errno = EMFILE;
        return -1;
    }
    RUBY_CRITICAL {
        rb_acrt_lowio_lock_fh(fd);
        _set_osfhnd(fd, (intptr_t)INVALID_HANDLE_VALUE);
        _set_osflags(fd, 0);
 
        h = CreateFileW(file, access, FILE_SHARE_READ | FILE_SHARE_WRITE | share_delete, &sec, create, attr, NULL);
        if (h == INVALID_HANDLE_VALUE) {
            DWORD e = GetLastError();
            if (e != ERROR_ACCESS_DENIED || !check_if_wdir(file))
                errno = map_errno(e);
            rb_acrt_lowio_unlock_fh(fd);
            fd = -1;
            goto quit;
        }
 
        switch (GetFileType(h)) {
          case FILE_TYPE_CHAR:
            flags |= FDEV;
            break;
          case FILE_TYPE_PIPE:
            flags |= FPIPE;
            break;
          case FILE_TYPE_UNKNOWN:
            errno = map_errno(GetLastError());
            CloseHandle(h);
            rb_acrt_lowio_unlock_fh(fd);
            fd = -1;
            goto quit;
        }
        if (!(flags & (FDEV | FPIPE)) && (oflag & O_APPEND))
            flags |= FAPPEND;
 
        _set_osfhnd(fd, (intptr_t)h);
        _set_osflags(fd, flags | FOPEN);
 
        rb_acrt_lowio_unlock_fh(fd);
      quit:
        ;
    }
 
    return fd;
}
 
/* License: Ruby's */
int
rb_w32_fclose(FILE *fp)
{
    int fd = fileno(fp);
    SOCKET sock = TO_SOCKET(fd);
    int save_errno = errno;
 
    if (fflush(fp)) return -1;
    if (!is_socket(sock)) {
        UnlockFile((HANDLE)sock, 0, 0, LK_LEN, LK_LEN);
        return fclose(fp);
    }
    _set_osfhnd(fd, (SOCKET)INVALID_HANDLE_VALUE);
    fclose(fp);
    errno = save_errno;
    if (closesocket(sock) == SOCKET_ERROR) {
        errno = map_errno(WSAGetLastError());
        return -1;
    }
    return 0;
}
 
/* License: Ruby's */
int
rb_w32_pipe(int fds[2])
{
    static long serial = 0;
    static const char prefix[] = "\\\\.\\pipe\\ruby";
    enum {
        width_of_prefix = (int)sizeof(prefix) - 1,
        width_of_pid = (int)sizeof(rb_pid_t) * 2,
        width_of_serial = (int)sizeof(serial) * 2,
        width_of_ids = width_of_pid + 1 + width_of_serial + 1
    };
    char name[sizeof(prefix) + width_of_ids];
    SECURITY_ATTRIBUTES sec;
    HANDLE hRead, hWrite, h;
    int fdRead, fdWrite;
    int ret;
 
    memcpy(name, prefix, width_of_prefix);
    snprintf(name + width_of_prefix, width_of_ids, "%.*"PRI_PIDT_PREFIX"x-%.*lx",
             width_of_pid, rb_w32_getpid(), width_of_serial, (unsigned long)(InterlockedIncrement(&serial)-1));
 
    sec.nLength = sizeof(sec);
    sec.lpSecurityDescriptor = NULL;
    sec.bInheritHandle = FALSE;
 
    RUBY_CRITICAL {
        hRead = CreateNamedPipe(name, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
                                0, 2, 65536, 65536, 0, &sec);
    }
    if (hRead == INVALID_HANDLE_VALUE) {
        DWORD err = GetLastError();
        if (err == ERROR_PIPE_BUSY)
            errno = EMFILE;
        else
            errno = map_errno(GetLastError());
        return -1;
    }
 
    RUBY_CRITICAL {
        hWrite = CreateFile(name, GENERIC_READ | GENERIC_WRITE, 0, &sec,
                            OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
    }
    if (hWrite == INVALID_HANDLE_VALUE) {
        errno = map_errno(GetLastError());
        CloseHandle(hRead);
        return -1;
    }
 
    RUBY_CRITICAL do {
        ret = 0;
        h = CreateFile("NUL", 0, 0, NULL, OPEN_ALWAYS, 0, NULL);
        fdRead = _open_osfhandle((intptr_t)h, 0);
        CloseHandle(h);
        if (fdRead == -1) {
            errno = EMFILE;
            CloseHandle(hWrite);
            CloseHandle(hRead);
            ret = -1;
            break;
        }
 
        rb_acrt_lowio_lock_fh(fdRead);
        _set_osfhnd(fdRead, (intptr_t)hRead);
        _set_osflags(fdRead, FOPEN | FPIPE | FNOINHERIT);
        rb_acrt_lowio_unlock_fh(fdRead);
    } while (0);
    if (ret)
        return ret;
 
    RUBY_CRITICAL do {
        h = CreateFile("NUL", 0, 0, NULL, OPEN_ALWAYS, 0, NULL);
        fdWrite = _open_osfhandle((intptr_t)h, 0);
        CloseHandle(h);
        if (fdWrite == -1) {
            errno = EMFILE;
            CloseHandle(hWrite);
            ret = -1;
            break;
        }
        rb_acrt_lowio_lock_fh(fdWrite);
        _set_osfhnd(fdWrite, (intptr_t)hWrite);
        _set_osflags(fdWrite, FOPEN | FPIPE | FNOINHERIT);
        rb_acrt_lowio_unlock_fh(fdWrite);
    } while (0);
    if (ret) {
        rb_w32_close(fdRead);
        return ret;
    }
 
    fds[0] = fdRead;
    fds[1] = fdWrite;
 
    return 0;
}
 
/* License: Ruby's */
static int
console_emulator_p(void)
{
    const void *const func = WriteConsoleW;
    HMODULE k;
    MEMORY_BASIC_INFORMATION m;
 
    memset(&m, 0, sizeof(m));
    if (!VirtualQuery(func, &m, sizeof(m))) {
        return FALSE;
    }
    k = GetModuleHandle("kernel32.dll");
    if (!k) return FALSE;
    return (HMODULE)m.AllocationBase != k;
}
 
/* License: Ruby's */
static struct constat *
constat_handle(HANDLE h)
{
    st_data_t data;
    struct constat *p = NULL;
    thread_exclusive(conlist) {
        if (!conlist) {
            if (console_emulator_p()) {
                conlist = conlist_disabled;
                continue;
            }
            conlist = st_init_numtable();
            install_vm_exit_handler();
        }
        else if (conlist == conlist_disabled) {
            continue;
        }
        if (st_lookup(conlist, (st_data_t)h, &data)) {
            p = (struct constat *)data;
        }
        else {
            CONSOLE_SCREEN_BUFFER_INFO csbi;
            p = ALLOC(struct constat);
            p->vt100.state = constat_init;
            p->vt100.attr = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED;
            p->vt100.reverse = 0;
            p->vt100.saved.X = p->vt100.saved.Y = 0;
            if (GetConsoleScreenBufferInfo(h, &csbi)) {
                p->vt100.attr = csbi.wAttributes;
            }
            st_insert(conlist, (st_data_t)h, (st_data_t)p);
        }
    }
    return p;
}
 
#define FOREGROUND_MASK (FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY)
#define BACKGROUND_MASK (BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_INTENSITY)
 
#define constat_attr_color_reverse(attr) \
    ((attr) & ~(FOREGROUND_MASK | BACKGROUND_MASK)) | \
           (((attr) & FOREGROUND_MASK) << 4) | \
           (((attr) & BACKGROUND_MASK) >> 4)
 
/* License: Ruby's */
static WORD
constat_attr(int count, const int *seq, WORD attr, WORD default_attr, int *reverse)
{
    int rev = *reverse;
    WORD bold;
 
    if (!count) return attr;
    if (rev) attr = constat_attr_color_reverse(attr);
    bold = attr & FOREGROUND_INTENSITY;
    attr &= ~(FOREGROUND_INTENSITY | BACKGROUND_INTENSITY);
 
    while (count-- > 0) {
        switch (*seq++) {
          case 0:
            attr = default_attr;
            rev = 0;
            bold = 0;
            break;
          case 1:
            bold = FOREGROUND_INTENSITY;
            break;
          case 22:
            bold = 0;
            break;
          case 4:
#ifndef COMMON_LVB_UNDERSCORE
#define COMMON_LVB_UNDERSCORE 0x8000
#endif
            attr |= COMMON_LVB_UNDERSCORE;
            break;
          case 24:
            attr &= ~COMMON_LVB_UNDERSCORE;
            break;
          case 7:
            rev = 1;
            break;
          case 27:
            rev = 0;
            break;
 
          case 30:
            attr &= ~(FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED);
            break;
          case 31:
            attr = (attr & ~(FOREGROUND_BLUE | FOREGROUND_GREEN)) | FOREGROUND_RED;
            break;
          case 32:
            attr = (attr & ~(FOREGROUND_BLUE | FOREGROUND_RED)) | FOREGROUND_GREEN;
            break;
          case 33:
            attr = (attr & ~FOREGROUND_BLUE) | FOREGROUND_GREEN | FOREGROUND_RED;
            break;
          case 34:
            attr = (attr & ~(FOREGROUND_GREEN | FOREGROUND_RED)) | FOREGROUND_BLUE;
            break;
          case 35:
            attr = (attr & ~FOREGROUND_GREEN) | FOREGROUND_BLUE | FOREGROUND_RED;
            break;
          case 36:
            attr = (attr & ~FOREGROUND_RED) | FOREGROUND_BLUE | FOREGROUND_GREEN;
            break;
          case 37:
            attr |= FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED;
            break;
          case 38: /* 256-color or true color; N/A on old Command Prompt */
            break;
          case 39:
            attr = (attr & ~FOREGROUND_MASK) | (default_attr & FOREGROUND_MASK);
            break;
 
          case 40:
            attr &= ~(BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_RED);
            break;
          case 41:
            attr = (attr & ~(BACKGROUND_BLUE | BACKGROUND_GREEN)) | BACKGROUND_RED;
            break;
          case 42:
            attr = (attr & ~(BACKGROUND_BLUE | BACKGROUND_RED)) | BACKGROUND_GREEN;
            break;
          case 43:
            attr = (attr & ~BACKGROUND_BLUE) | BACKGROUND_GREEN | BACKGROUND_RED;
            break;
          case 44:
            attr = (attr & ~(BACKGROUND_GREEN | BACKGROUND_RED)) | BACKGROUND_BLUE;
            break;
          case 45:
            attr = (attr & ~BACKGROUND_GREEN) | BACKGROUND_BLUE | BACKGROUND_RED;
            break;
          case 46:
            attr = (attr & ~BACKGROUND_RED) | BACKGROUND_BLUE | BACKGROUND_GREEN;
            break;
          case 47:
            attr |= BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_RED;
            break;
          case 48: /* 256-color or true color; N/A on old Command Prompt */
            break;
          case 49:
            attr = (attr & ~BACKGROUND_MASK) | (default_attr & BACKGROUND_MASK);
            break;
        }
    }
    attr |= bold;
    if (rev) attr = constat_attr_color_reverse(attr);
    *reverse = rev;
    return attr;
}
 
/* License: Ruby's */
static void
constat_clear(HANDLE handle, WORD attr, DWORD len, COORD pos)
{
    DWORD written;
 
    FillConsoleOutputAttribute(handle, attr, len, pos, &written);
    FillConsoleOutputCharacterW(handle, L' ', len, pos, &written);
}
 
/* License: Ruby's */
static void
constat_apply(HANDLE handle, struct constat *s, WCHAR w)
{
    CONSOLE_SCREEN_BUFFER_INFO csbi;
    const int *seq = s->vt100.seq;
    int count = s->vt100.state;
    int arg0, arg1 = 1;
    COORD pos;
 
    if (!GetConsoleScreenBufferInfo(handle, &csbi)) return;
    arg0 = (count > 0 && seq[0] > 0);
    if (arg0) arg1 = seq[0];
    switch (w) {
      case L'm':
        SetConsoleTextAttribute(handle, constat_attr(count, seq, csbi.wAttributes, s->vt100.attr, &s->vt100.reverse));
        break;
      case L'F':
        csbi.dwCursorPosition.X = 0;
      case L'A':
        csbi.dwCursorPosition.Y -= arg1;
        if (csbi.dwCursorPosition.Y < csbi.srWindow.Top)
            csbi.dwCursorPosition.Y = csbi.srWindow.Top;
        SetConsoleCursorPosition(handle, csbi.dwCursorPosition);
        break;
      case L'E':
        csbi.dwCursorPosition.X = 0;
      case L'B':
      case L'e':
        csbi.dwCursorPosition.Y += arg1;
        if (csbi.dwCursorPosition.Y > csbi.srWindow.Bottom)
            csbi.dwCursorPosition.Y = csbi.srWindow.Bottom;
        SetConsoleCursorPosition(handle, csbi.dwCursorPosition);
        break;
      case L'C':
        csbi.dwCursorPosition.X += arg1;
        if (csbi.dwCursorPosition.X >= csbi.srWindow.Right)
            csbi.dwCursorPosition.X = csbi.srWindow.Right;
        SetConsoleCursorPosition(handle, csbi.dwCursorPosition);
        break;
      case L'D':
        csbi.dwCursorPosition.X -= arg1;
        if (csbi.dwCursorPosition.X < csbi.srWindow.Left)
            csbi.dwCursorPosition.X = csbi.srWindow.Left;
        SetConsoleCursorPosition(handle, csbi.dwCursorPosition);
        break;
      case L'G':
      case L'`':
        arg1 += csbi.srWindow.Left;
        if (arg1 > csbi.srWindow.Right)
            arg1 = csbi.srWindow.Right;
        csbi.dwCursorPosition.X = arg1;
        SetConsoleCursorPosition(handle, csbi.dwCursorPosition);
        break;
      case L'd':
        arg1 += csbi.srWindow.Top;
        if (arg1 > csbi.srWindow.Bottom)
            arg1 = csbi.srWindow.Bottom;
        csbi.dwCursorPosition.Y = arg1;
        SetConsoleCursorPosition(handle, csbi.dwCursorPosition);
        break;
      case L'H':
      case L'f':
        pos.Y = arg1 + csbi.srWindow.Top - 1;
        if (pos.Y > csbi.srWindow.Bottom) pos.Y = csbi.srWindow.Bottom;
        if (count < 2 || (arg1 = seq[1]) <= 0) arg1 = 1;
        pos.X = arg1 + csbi.srWindow.Left - 1;
        if (pos.X > csbi.srWindow.Right) pos.X = csbi.srWindow.Right;
        SetConsoleCursorPosition(handle, pos);
        break;
      case L'J':
        switch (arg0 ? arg1 : 0) {
          case 0:       /* erase after cursor */
            constat_clear(handle, csbi.wAttributes,
                          (csbi.dwSize.X * (csbi.srWindow.Bottom - csbi.dwCursorPosition.Y + 1)
                           - csbi.dwCursorPosition.X),
                          csbi.dwCursorPosition);
            break;
          case 1:       /* erase before *and* cursor */
            pos.X = 0;
            pos.Y = csbi.srWindow.Top;
            constat_clear(handle, csbi.wAttributes,
                          (csbi.dwSize.X * (csbi.dwCursorPosition.Y - csbi.srWindow.Top)
                           + csbi.dwCursorPosition.X + 1),
                          pos);
            break;
          case 2:       /* erase entire screen */
            pos.X = 0;
            pos.Y = csbi.srWindow.Top;
            constat_clear(handle, csbi.wAttributes,
                          (csbi.dwSize.X * (csbi.srWindow.Bottom - csbi.srWindow.Top + 1)),
                          pos);
            break;
          case 3:       /* erase entire screen */
            pos.X = 0;
            pos.Y = 0;
            constat_clear(handle, csbi.wAttributes,
                          (csbi.dwSize.X * csbi.dwSize.Y),
                          pos);
            break;
        }
        break;
      case L'K':
        switch (arg0 ? arg1 : 0) {
          case 0:       /* erase after cursor */
            constat_clear(handle, csbi.wAttributes,
                          (csbi.dwSize.X - csbi.dwCursorPosition.X),
                          csbi.dwCursorPosition);
            break;
          case 1:       /* erase before *and* cursor */
            pos.X = 0;
            pos.Y = csbi.dwCursorPosition.Y;
            constat_clear(handle, csbi.wAttributes,
                          csbi.dwCursorPosition.X + 1, pos);
            break;
          case 2:       /* erase entire line */
            pos.X = 0;
            pos.Y = csbi.dwCursorPosition.Y;
            constat_clear(handle, csbi.wAttributes,
                          csbi.dwSize.X, pos);
            break;
        }
        break;
      case L's':
        s->vt100.saved = csbi.dwCursorPosition;
        break;
      case L'u':
        SetConsoleCursorPosition(handle, s->vt100.saved);
        break;
      case L'h':
        if (count >= 2 && seq[0] == -1 && seq[1] == 25) {
            CONSOLE_CURSOR_INFO cci;
            GetConsoleCursorInfo(handle, &cci);
            cci.bVisible = TRUE;
            SetConsoleCursorInfo(handle, &cci);
        }
        break;
      case L'l':
        if (count >= 2 && seq[0] == -1 && seq[1] == 25) {
            CONSOLE_CURSOR_INFO cci;
            GetConsoleCursorInfo(handle, &cci);
            cci.bVisible = FALSE;
            SetConsoleCursorInfo(handle, &cci);
        }
        break;
    }
}
 
/* get rid of console writing bug; assume WriteConsole and WriteFile
 * on a console share the same limit. */
static const long MAXSIZE_CONSOLE_WRITING = 31366;
 
/* License: Ruby's */
static long
constat_parse(HANDLE h, struct constat *s, const WCHAR **ptrp, long *lenp)
{
    const WCHAR *ptr = *ptrp;
    long rest, len = *lenp;
    while (len-- > 0) {
        WCHAR wc = *ptr++;
        if (wc == 0x1b) {
            rest = *lenp - len - 1;
            if (s->vt100.state == constat_esc) {
                rest++;         /* reuse this ESC */
            }
            s->vt100.state = constat_init;
            if (len > 0 && *ptr != L'[') continue;
            s->vt100.state = constat_esc;
        }
        else if (s->vt100.state == constat_esc) {
            if (wc != L'[') {
                /* TODO: supply dropped ESC at beginning */
                s->vt100.state = constat_init;
                continue;
            }
            rest = *lenp - len - 1;
            if (rest > 0) --rest;
            s->vt100.state = constat_seq;
            s->vt100.seq[0] = 0;
        }
        else if (s->vt100.state >= constat_seq) {
            if (wc >= L'0' && wc <= L'9') {
                if (s->vt100.state < (int)numberof(s->vt100.seq)) {
                    int *seq = &s->vt100.seq[s->vt100.state];
                    *seq = (*seq * 10) + (wc - L'0');
                }
            }
            else if (s->vt100.state == constat_seq && s->vt100.seq[0] == 0 && wc == L'?') {
                s->vt100.seq[s->vt100.state++] = -1;
            }
            else {
                do {
                    if (++s->vt100.state < (int)numberof(s->vt100.seq)) {
                        s->vt100.seq[s->vt100.state] = 0;
                    }
                    else {
                        s->vt100.state = (int)numberof(s->vt100.seq);
                    }
                } while (0);
                if (wc != L';') {
                    constat_apply(h, s, wc);
                    s->vt100.state = constat_init;
                }
            }
            rest = 0;
        }
        else if ((rest = *lenp - len) < MAXSIZE_CONSOLE_WRITING) {
            continue;
        }
        *ptrp = ptr;
        *lenp = len;
        return rest;
    }
    len = *lenp;
    *ptrp = ptr;
    *lenp = 0;
    return len;
}
 
 
/* License: Ruby's */
int
rb_w32_close(int fd)
{
    SOCKET sock = TO_SOCKET(fd);
    int save_errno = errno;
 
    if (!is_socket(sock)) {
        UnlockFile((HANDLE)sock, 0, 0, LK_LEN, LK_LEN);
        constat_delete((HANDLE)sock);
        return _close(fd);
    }
    _set_osfhnd(fd, (SOCKET)INVALID_HANDLE_VALUE);
    socklist_delete(&sock, NULL);
    _close(fd);
    errno = save_errno;
    if (closesocket(sock) == SOCKET_ERROR) {
        errno = map_errno(WSAGetLastError());
        return -1;
    }
    return 0;
}
 
#ifndef INVALID_SET_FILE_POINTER
#define INVALID_SET_FILE_POINTER ((DWORD)-1)
#endif
 
static int
setup_overlapped(OVERLAPPED *ol, int fd, int iswrite, rb_off_t *_offset)
{
    memset(ol, 0, sizeof(*ol));
 
    // On mode:a, it can write only FILE_END.
    // On mode:a+, though it can write only FILE_END,
    // it can read from everywhere.
    DWORD seek_method = ((_osfile(fd) & FAPPEND) && iswrite) ? FILE_END : FILE_CURRENT;
 
    if (_offset) {
        // Explicit offset was provided (pread/pwrite) - use it:
        uint64_t offset = *_offset;
        ol->Offset = (uint32_t)(offset & 0xFFFFFFFFLL);
        ol->OffsetHigh = (uint32_t)((offset & 0xFFFFFFFF00000000LL) >> 32);
 
        // Update _offset with the current offset:
        LARGE_INTEGER seek_offset = {0}, current_offset = {0};
        if (!SetFilePointerEx((HANDLE)_osfhnd(fd), seek_offset, &current_offset, seek_method)) {
            DWORD last_error = GetLastError();
            if (last_error != NO_ERROR) {
                errno = map_errno(last_error);
                return -1;
            }
        }
 
        // As we need to restore the current offset later, we save it here:
        *_offset = current_offset.QuadPart;
    }
    else if (!(_osfile(fd) & (FDEV | FPIPE))) {
        LONG high = 0;
        DWORD low = SetFilePointer((HANDLE)_osfhnd(fd), 0, &high, seek_method);
 
        if (low == INVALID_SET_FILE_POINTER) {
            DWORD err = GetLastError();
            if (err != NO_ERROR) {
                errno = map_errno(err);
                return -1;
            }
        }
 
        ol->Offset = low;
        ol->OffsetHigh = high;
    }
 
    ol->hEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
    if (!ol->hEvent) {
        errno = map_errno(GetLastError());
        return -1;
    }
    return 0;
}
 
static void
finish_overlapped(OVERLAPPED *ol, int fd, DWORD size, rb_off_t *_offset)
{
    CloseHandle(ol->hEvent);
 
    if (_offset) {
        // If we were doing a `pread`/`pwrite`, we need to restore the current that was saved in setup_overlapped:
        DWORD seek_method = (_osfile(fd) & FAPPEND) ? FILE_END : FILE_BEGIN;
 
        LARGE_INTEGER seek_offset = {0};
        if (seek_method == FILE_BEGIN) {
            seek_offset.QuadPart = *_offset;
        }
 
        SetFilePointerEx((HANDLE)_osfhnd(fd), seek_offset, NULL, seek_method);
    }
    else if (!(_osfile(fd) & (FDEV | FPIPE))) {
        LONG high = ol->OffsetHigh;
        DWORD low = ol->Offset + size;
        if (low < ol->Offset)
            ++high;
        SetFilePointer((HANDLE)_osfhnd(fd), low, &high, FILE_BEGIN);
    }
}
 
#undef read
/* License: Ruby's */
static ssize_t
rb_w32_read_internal(int fd, void *buf, size_t size, rb_off_t *offset)
{
    SOCKET sock = TO_SOCKET(fd);
    DWORD read;
    DWORD wait;
    DWORD err;
    size_t len;
    size_t ret;
    OVERLAPPED ol;
 
    if (is_socket(sock))
        return rb_w32_recv(fd, buf, size, 0);
 
    // validate fd by using _get_osfhandle() because we cannot access _nhandle
    if (_get_osfhandle(fd) == -1) {
        return -1;
    }
 
    if (!offset && _osfile(fd) & FTEXT) {
        return _read(fd, buf, size);
    }
 
    rb_acrt_lowio_lock_fh(fd);
 
    if (!size || _osfile(fd) & FEOFLAG) {
        _set_osflags(fd, _osfile(fd) & ~FEOFLAG);
        rb_acrt_lowio_unlock_fh(fd);
        return 0;
    }
 
    ret = 0;
  retry:
    len = size;
    size -= len;
 
    if (setup_overlapped(&ol, fd, FALSE, offset)) {
        rb_acrt_lowio_unlock_fh(fd);
        return -1;
    }
 
    if (!ReadFile((HANDLE)_osfhnd(fd), buf, len, &read, &ol)) {
        err = GetLastError();
        if (err == ERROR_NO_DATA && (_osfile(fd) & FPIPE)) {
            DWORD state;
            if (GetNamedPipeHandleState((HANDLE)_osfhnd(fd), &state, NULL, NULL, NULL, NULL, 0) && (state & PIPE_NOWAIT)) {
                errno = EWOULDBLOCK;
            }
            else {
                errno = map_errno(err);
            }
            rb_acrt_lowio_unlock_fh(fd);
            return -1;
        }
        else if (err != ERROR_IO_PENDING) {
            CloseHandle(ol.hEvent);
            if (err == ERROR_ACCESS_DENIED)
                errno = EBADF;
            else if (err == ERROR_BROKEN_PIPE || err == ERROR_HANDLE_EOF) {
                rb_acrt_lowio_unlock_fh(fd);
                return 0;
            }
            else
                errno = map_errno(err);
 
            rb_acrt_lowio_unlock_fh(fd);
            return -1;
        }
 
        wait = rb_w32_wait_events_blocking(&ol.hEvent, 1, INFINITE);
        if (wait != WAIT_OBJECT_0) {
            if (wait == WAIT_OBJECT_0 + 1)
                errno = EINTR;
            else
                errno = map_errno(GetLastError());
            CloseHandle(ol.hEvent);
            CancelIo((HANDLE)_osfhnd(fd));
            rb_acrt_lowio_unlock_fh(fd);
            return -1;
        }
 
        if (!GetOverlappedResult((HANDLE)_osfhnd(fd), &ol, &read, TRUE) &&
            (err = GetLastError()) != ERROR_HANDLE_EOF) {
            int ret = 0;
            if (err != ERROR_BROKEN_PIPE) {
                errno = map_errno(err);
                ret = -1;
            }
            CloseHandle(ol.hEvent);
            CancelIo((HANDLE)_osfhnd(fd));
            rb_acrt_lowio_unlock_fh(fd);
            return ret;
        }
    }
    else {
        err = GetLastError();
        errno = map_errno(err);
    }
 
    finish_overlapped(&ol, fd, read, offset);
 
    ret += read;
    if (read >= len) {
        buf = (char *)buf + read;
        if (err != ERROR_OPERATION_ABORTED && size > 0)
            goto retry;
    }
    if (read == 0)
        _set_osflags(fd, _osfile(fd) | FEOFLAG);
 
 
    rb_acrt_lowio_unlock_fh(fd);
 
    return ret;
}
 
#undef write
/* License: Ruby's */
static ssize_t
rb_w32_write_internal(int fd, const void *buf, size_t size, rb_off_t *offset)
{
    SOCKET sock = TO_SOCKET(fd);
    DWORD written;
    DWORD wait;
    DWORD err;
    size_t len;
    size_t ret;
    OVERLAPPED ol;
 
    if (is_socket(sock))
        return rb_w32_send(fd, buf, size, 0);
 
    // validate fd by using _get_osfhandle() because we cannot access _nhandle
    if (_get_osfhandle(fd) == -1) {
        return -1;
    }
 
    // If an offset is given, we can't use `_write`.
    if (!offset && (_osfile(fd) & FTEXT) &&
        (!(_osfile(fd) & FPIPE) || fd == fileno(stdout) || fd == fileno(stderr))) {
        ssize_t w = _write(fd, buf, size);
        if (w == (ssize_t)-1 && errno == EINVAL) {
            errno = map_errno(GetLastError());
        }
        return w;
    }
 
    rb_acrt_lowio_lock_fh(fd);
 
    if (!size || _osfile(fd) & FEOFLAG) {
        rb_acrt_lowio_unlock_fh(fd);
        return 0;
    }
 
    ret = 0;
  retry:
    len = (_osfile(fd) & FDEV) ? min(MAXSIZE_CONSOLE_WRITING, size) : size;
    size -= len;
  retry2:
 
    // Provide the requested offset.
    if (setup_overlapped(&ol, fd, TRUE, offset)) {
        rb_acrt_lowio_unlock_fh(fd);
        return -1;
    }
 
    if (!WriteFile((HANDLE)_osfhnd(fd), buf, len, &written, &ol)) {
        err = GetLastError();
        if (err != ERROR_IO_PENDING) {
            CloseHandle(ol.hEvent);
            if (err == ERROR_ACCESS_DENIED)
                errno = EBADF;
            else
                errno = map_errno(err);
 
            rb_acrt_lowio_unlock_fh(fd);
            return -1;
        }
 
        wait = rb_w32_wait_events_blocking(&ol.hEvent, 1, INFINITE);
        if (wait != WAIT_OBJECT_0) {
            if (wait == WAIT_OBJECT_0 + 1)
                errno = EINTR;
            else
                errno = map_errno(GetLastError());
            CloseHandle(ol.hEvent);
            CancelIo((HANDLE)_osfhnd(fd));
            rb_acrt_lowio_unlock_fh(fd);
            return -1;
        }
 
        if (!GetOverlappedResult((HANDLE)_osfhnd(fd), &ol, &written, TRUE)) {
            errno = map_errno(GetLastError());
            CloseHandle(ol.hEvent);
            CancelIo((HANDLE)_osfhnd(fd));
            rb_acrt_lowio_unlock_fh(fd);
            return -1;
        }
    }
 
    finish_overlapped(&ol, fd, written, offset);
 
    ret += written;
    if (written == len) {
        buf = (const char *)buf + len;
        if (size > 0)
            goto retry;
    }
    if (ret == 0) {
        size_t newlen = len / 2;
        if (newlen > 0) {
            size += len - newlen;
            len = newlen;
            goto retry2;
        }
        ret = -1;
        errno = EWOULDBLOCK;
    }
 
    rb_acrt_lowio_unlock_fh(fd);
 
    return ret;
}
 
ssize_t
rb_w32_read(int fd, void *buf, size_t size)
{
    return rb_w32_read_internal(fd, buf, size, NULL);
}
 
ssize_t
rb_w32_write(int fd, const void *buf, size_t size)
{
    return rb_w32_write_internal(fd, buf, size, NULL);
}
 
ssize_t
rb_w32_pread(int descriptor, void *base, size_t size, rb_off_t offset)
{
    return rb_w32_read_internal(descriptor, base, size, &offset);
}
 
ssize_t
rb_w32_pwrite(int descriptor, const void *base, size_t size, rb_off_t offset)
{
    return rb_w32_write_internal(descriptor, base, size, &offset);
}
 
/* License: Ruby's */
long
rb_w32_write_console(uintptr_t strarg, int fd)
{
    HANDLE handle;
    DWORD dwMode, reslen;
    VALUE str = strarg;
    int encindex;
    WCHAR *wbuffer = 0;
    const WCHAR *ptr, *next;
    struct constat *s;
    long len;
 
    handle = (HANDLE)_osfhnd(fd);
    if (!GetConsoleMode(handle, &dwMode))
        return -1L;
 
    s = constat_handle(handle);
    if (!s) return -1L;
    encindex = ENCODING_GET(str);
    switch (encindex) {
      default:
        if (!rb_econv_has_convpath_p(rb_enc_name(rb_enc_from_index(encindex)), "UTF-8"))
            return -1L;
        str = rb_str_conv_enc_opts(str, NULL, rb_enc_from_index(ENCINDEX_UTF_8),
                                   ECONV_INVALID_REPLACE|ECONV_UNDEF_REPLACE, Qnil);
        /* fall through */
      case ENCINDEX_US_ASCII:
      case ENCINDEX_ASCII_8BIT:
        /* assume UTF-8 */
      case ENCINDEX_UTF_8:
        ptr = wbuffer = mbstr_to_wstr(CP_UTF8, RSTRING_PTR(str), RSTRING_LEN(str), &len);
        if (!ptr) return -1L;
        break;
      case ENCINDEX_UTF_16LE:
        ptr = (const WCHAR *)RSTRING_PTR(str);
        len = RSTRING_LEN(str) / sizeof(WCHAR);
        break;
    }
    reslen = 0;
    if (dwMode & ENABLE_VIRTUAL_TERMINAL_PROCESSING) {
        if (!WriteConsoleW(handle, ptr, len, &reslen, NULL))
            reslen = (DWORD)-1L;
    }
    else {
        while (len > 0) {
            long curlen = constat_parse(handle, s, (next = ptr, &next), &len);
            reslen += next - ptr;
            if (curlen > 0) {
                DWORD written;
                if (!WriteConsoleW(handle, ptr, curlen, &written, NULL)) {
                    reslen = (DWORD)-1L;
                    break;
                }
            }
            ptr = next;
        }
    }
    RB_GC_GUARD(str);
    free(wbuffer);
    return (long)reslen;
}
 
/* License: Ruby's */
static int
timespec_to_filetime(const struct timespec *ts, FILETIME *ft)
{
    ULARGE_INTEGER tmp;
 
    tmp.QuadPart = unix_to_filetime((ULONGLONG)ts->tv_sec);
    tmp.QuadPart += ts->tv_nsec / 100;
    ft->dwLowDateTime = tmp.LowPart;
    ft->dwHighDateTime = tmp.HighPart;
    return 0;
}
 
/* License: Ruby's */
static int
wutimensat(int dirfd, const WCHAR *path, const struct timespec *times, int flags)
{
    HANDLE hFile;
    FILETIME atime, mtime;
    struct stati128 stat;
    int ret = 0;
 
    /* TODO: When path is absolute, dirfd should be ignored. */
    if (dirfd != AT_FDCWD) {
        errno = ENOSYS;
        return -1;
    }
 
    if (flags != 0) {
        errno = EINVAL; /* AT_SYMLINK_NOFOLLOW isn't supported. */
        return -1;
    }
 
    if (wstati128(path, &stat, FALSE)) {
        return -1;
    }
 
    if (times) {
        if (timespec_to_filetime(&times[0], &atime)) {
            return -1;
        }
        if (timespec_to_filetime(&times[1], &mtime)) {
            return -1;
        }
    }
    else {
        GetSystemTimePreciseAsFileTime(&atime);
        mtime = atime;
    }
 
    RUBY_CRITICAL {
        const DWORD attr = GetFileAttributesW(path);
        if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY))
            SetFileAttributesW(path, attr & ~FILE_ATTRIBUTE_READONLY);
        hFile = open_special(path, GENERIC_WRITE, 0);
        if (hFile == INVALID_HANDLE_VALUE) {
            errno = map_errno(GetLastError());
            ret = -1;
        }
        else {
            if (!SetFileTime(hFile, NULL, &atime, &mtime)) {
                errno = map_errno(GetLastError());
                ret = -1;
            }
            CloseHandle(hFile);
        }
        if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY))
            SetFileAttributesW(path, attr);
    }
 
    return ret;
}
 
/* License: Ruby's */
static int
w32_utimensat(int dirfd, const char *path, const struct timespec *times, int flags, UINT cp)
{
    WCHAR *wpath = mbstr_to_wstr(cp, path, -1, NULL);
    int ret = -1;
 
    if (wpath) {
        ret = wutimensat(dirfd, wpath, times, flags);
        free(wpath);
    }
    return ret;
}
 
/* License: Ruby's */
int
rb_w32_uutime(const char *path, const struct utimbuf *times)
{
    struct timespec ts[2];
 
    ts[0].tv_sec = times->actime;
    ts[0].tv_nsec = 0;
    ts[1].tv_sec = times->modtime;
    ts[1].tv_nsec = 0;
    return w32_utimensat(AT_FDCWD, path, ts, 0, CP_UTF8);
}
 
/* License: Ruby's */
int
rb_w32_utime(const char *path, const struct utimbuf *times)
{
    struct timespec ts[2];
 
    ts[0].tv_sec = times->actime;
    ts[0].tv_nsec = 0;
    ts[1].tv_sec = times->modtime;
    ts[1].tv_nsec = 0;
    return w32_utimensat(AT_FDCWD, path, ts, 0, filecp());
}
 
/* License: Ruby's */
int
rb_w32_uutimes(const char *path, const struct timeval *times)
{
    struct timespec ts[2];
 
    ts[0].tv_sec = times[0].tv_sec;
    ts[0].tv_nsec = times[0].tv_usec * 1000;
    ts[1].tv_sec = times[1].tv_sec;
    ts[1].tv_nsec = times[1].tv_usec * 1000;
    return w32_utimensat(AT_FDCWD, path, ts, 0, CP_UTF8);
}
 
/* License: Ruby's */
int
rb_w32_utimes(const char *path, const struct timeval *times)
{
    struct timespec ts[2];
 
    ts[0].tv_sec = times[0].tv_sec;
    ts[0].tv_nsec = times[0].tv_usec * 1000;
    ts[1].tv_sec = times[1].tv_sec;
    ts[1].tv_nsec = times[1].tv_usec * 1000;
    return w32_utimensat(AT_FDCWD, path, ts, 0, filecp());
}
 
/* License: Ruby's */
int
rb_w32_uutimensat(int dirfd, const char *path, const struct timespec *times, int flags)
{
    return w32_utimensat(dirfd, path, times, flags, CP_UTF8);
}
 
/* License: Ruby's */
int
rb_w32_utimensat(int dirfd, const char *path, const struct timespec *times, int flags)
{
    return w32_utimensat(dirfd, path, times, flags, filecp());
}
 
/* License: Ruby's */
int
rb_w32_uchdir(const char *path)
{
    WCHAR *wpath;
    int ret;
 
    if (!(wpath = utf8_to_wstr(path, NULL)))
        return -1;
    ret = _wchdir(wpath);
    free(wpath);
    return ret;
}
 
/* License: Ruby's */
static int
wmkdir(const WCHAR *wpath, int mode)
{
    int ret = -1;
 
    RUBY_CRITICAL do {
        if (CreateDirectoryW(wpath, NULL) == FALSE) {
            errno = map_errno(GetLastError());
            break;
        }
        if (_wchmod(wpath, mode) == -1) {
            RemoveDirectoryW(wpath);
            break;
        }
        ret = 0;
    } while (0);
    return ret;
}
 
/* License: Ruby's */
int
rb_w32_umkdir(const char *path, int mode)
{
    WCHAR *wpath;
    int ret;
 
    if (!(wpath = utf8_to_wstr(path, NULL)))
        return -1;
    ret = wmkdir(wpath, mode);
    free(wpath);
    return ret;
}
 
/* License: Ruby's */
int
rb_w32_mkdir(const char *path, int mode)
{
    WCHAR *wpath;
    int ret;
 
    if (!(wpath = filecp_to_wstr(path, NULL)))
        return -1;
    ret = wmkdir(wpath, mode);
    free(wpath);
    return ret;
}
 
/* License: Ruby's */
static int
wrmdir(const WCHAR *wpath)
{
    int ret = 0;
    RUBY_CRITICAL {
        const DWORD attr = GetFileAttributesW(wpath);
        if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY)) {
            SetFileAttributesW(wpath, attr & ~FILE_ATTRIBUTE_READONLY);
        }
        if (RemoveDirectoryW(wpath) == FALSE) {
            errno = map_errno(GetLastError());
            ret = -1;
            if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY)) {
                SetFileAttributesW(wpath, attr);
            }
        }
    }
    return ret;
}
 
/* License: Ruby's */
int
rb_w32_rmdir(const char *path)
{
    WCHAR *wpath;
    int ret;
 
    if (!(wpath = filecp_to_wstr(path, NULL)))
        return -1;
    ret = wrmdir(wpath);
    free(wpath);
    return ret;
}
 
/* License: Ruby's */
int
rb_w32_urmdir(const char *path)
{
    WCHAR *wpath;
    int ret;
 
    if (!(wpath = utf8_to_wstr(path, NULL)))
        return -1;
    ret = wrmdir(wpath);
    free(wpath);
    return ret;
}
 
/* License: Ruby's */
static int
wunlink(const WCHAR *path)
{
    int ret = 0;
    const DWORD SYMLINKD = FILE_ATTRIBUTE_REPARSE_POINT|FILE_ATTRIBUTE_DIRECTORY;
    RUBY_CRITICAL {
        const DWORD attr = GetFileAttributesW(path);
        if (attr == (DWORD)-1) {
        }
        else if ((attr & SYMLINKD) == SYMLINKD) {
            ret = RemoveDirectoryW(path);
        }
        else {
            if (attr & FILE_ATTRIBUTE_READONLY) {
                SetFileAttributesW(path, attr & ~FILE_ATTRIBUTE_READONLY);
            }
            ret = DeleteFileW(path);
        }
        if (!ret) {
            errno = map_errno(GetLastError());
            ret = -1;
            if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY)) {
                SetFileAttributesW(path, attr);
            }
        }
    }
    return ret;
}
 
/* License: Ruby's */
int
rb_w32_uunlink(const char *path)
{
    WCHAR *wpath;
    int ret;
 
    if (!(wpath = utf8_to_wstr(path, NULL)))
        return -1;
    ret = wunlink(wpath);
    free(wpath);
    return ret;
}
 
/* License: Ruby's */
int
rb_w32_unlink(const char *path)
{
    WCHAR *wpath;
    int ret;
 
    if (!(wpath = filecp_to_wstr(path, NULL)))
        return -1;
    ret = wunlink(wpath);
    free(wpath);
    return ret;
}
 
/* License: Ruby's */
int
rb_w32_uchmod(const char *path, int mode)
{
    WCHAR *wpath;
    int ret;
 
    if (!(wpath = utf8_to_wstr(path, NULL)))
        return -1;
    ret = _wchmod(wpath, mode);
    free(wpath);
    return ret;
}
 
/* License: Ruby's */
int
fchmod(int fd, int mode)
{
    /* from winbase.h of the mingw-w64 runtime package. */
    struct {
        LARGE_INTEGER CreationTime;
        LARGE_INTEGER LastAccessTime;
        LARGE_INTEGER LastWriteTime;
        LARGE_INTEGER ChangeTime;
        DWORD         FileAttributes;
    } info = {{{0}}, {{0}}, {{0}},}; /* fields with 0 are unchanged */
    HANDLE h = (HANDLE)_get_osfhandle(fd);
 
    info.FileAttributes = FILE_ATTRIBUTE_NORMAL;
    if (!(mode & 0200)) info.FileAttributes |= FILE_ATTRIBUTE_READONLY;
    if (!SetFileInformationByHandle(h, 0, &info, sizeof(info))) {
        errno = map_errno(GetLastError());
        return -1;
    }
    return 0;
}
 
/* License: Ruby's */
int
rb_w32_isatty(int fd)
{
    DWORD mode;
 
    // validate fd by using _get_osfhandle() because we cannot access _nhandle
    if (_get_osfhandle(fd) == -1) {
        return 0;
    }
    if (!GetConsoleMode((HANDLE)_osfhnd(fd), &mode)) {
        errno = ENOTTY;
        return 0;
    }
    return 1;
}
 
#ifndef signbit
/* License: Ruby's */
int
signbit(double x)
{
    int *ip = (int *)(&x + 1) - 1;
    return *ip < 0;
}
#endif
 
/* License: Ruby's */
const char * WSAAPI
rb_w32_inet_ntop(int af, const void *addr, char *numaddr, size_t numaddr_len)
{
    return (inet_ntop)(af, (void *)addr, numaddr, numaddr_len);
}
 
/* License: Ruby's */
int WSAAPI
rb_w32_inet_pton(int af, const char *src, void *dst)
{
    return (inet_pton)(af, src, dst);
}
 
/* License: Ruby's */
char
rb_w32_fd_is_text(int fd)
{
    return _osfile(fd) & FTEXT;
}
 
#ifdef HAVE__GMTIME64_S
# ifndef HAVE__LOCALTIME64_S
/* assume same as _gmtime64_s() */
#  define HAVE__LOCALTIME64_S 1
# endif
# ifndef MINGW_HAS_SECURE_API
   _CRTIMP errno_t __cdecl _gmtime64_s(struct tm* tm, const __time64_t *time);
   _CRTIMP errno_t __cdecl _localtime64_s(struct tm* tm, const __time64_t *time);
# endif
# define gmtime_s _gmtime64_s
# define localtime_s _localtime64_s
#endif
 
/* License: Ruby's */
struct tm *
gmtime_r(const time_t *tp, struct tm *rp)
{
    int e = EINVAL;
    if (!tp || !rp) {
      error:
        errno = e;
        return NULL;
    }
    e = gmtime_s(rp, tp);
    if (e != 0) goto error;
    return rp;
}
 
/* License: Ruby's */
struct tm *
localtime_r(const time_t *tp, struct tm *rp)
{
    int e = EINVAL;
    if (!tp || !rp) {
      error:
        errno = e;
        return NULL;
    }
    e = localtime_s(rp, tp);
    if (e) goto error;
    return rp;
}
 
/* License: Ruby's */
int
rb_w32_wrap_io_handle(HANDLE h, int flags)
{
    BOOL tmp;
    int len = sizeof(tmp);
    int r = getsockopt((SOCKET)h, SOL_SOCKET, SO_DEBUG, (char *)&tmp, &len);
    if (r != SOCKET_ERROR || WSAGetLastError() != WSAENOTSOCK) {
        int f = 0;
        if (flags & O_NONBLOCK) {
            flags &= ~O_NONBLOCK;
            f = O_NONBLOCK;
        }
        socklist_insert((SOCKET)h, f);
    }
    else if (flags & O_NONBLOCK) {
        errno = EINVAL;
        return -1;
    }
    return rb_w32_open_osfhandle((intptr_t)h, flags);
}
 
/* License: Ruby's */
int
rb_w32_unwrap_io_handle(int fd)
{
    SOCKET sock = TO_SOCKET(fd);
    _set_osfhnd(fd, (SOCKET)INVALID_HANDLE_VALUE);
    if (!is_socket(sock)) {
        UnlockFile((HANDLE)sock, 0, 0, LK_LEN, LK_LEN);
        constat_delete((HANDLE)sock);
    }
    else {
        socklist_delete(&sock, NULL);
    }
    return _close(fd);
}
 
#if !defined(__MINGW64__) && defined(__MINGW64_VERSION_MAJOR)
/*
 * Set floating point precision for pow() of mingw-w64 x86.
 * With default precision the result is not proper on WinXP.
 */
double
rb_w32_pow(double x, double y)
{
#undef pow
    double r;
    unsigned int default_control = _controlfp(0, 0);
    _controlfp(_PC_64, _MCW_PC);
    r = pow(x, y);
    /* Restore setting */
    _controlfp(default_control, _MCW_PC);
    return r;
}
#endif
 
typedef struct {
    BOOL file_id_p;
    union {
        BY_HANDLE_FILE_INFORMATION bhfi;
        FILE_ID_INFO fii;
    } info;
} w32_io_info_t;
 
static HANDLE
w32_io_info(VALUE *file, w32_io_info_t *st)
{
    VALUE tmp;
    HANDLE f, ret = 0;
 
    tmp = rb_check_convert_type_with_id(*file, T_FILE, "IO", idTo_io);
    if (!NIL_P(tmp)) {
        f = (HANDLE)rb_w32_get_osfhandle(rb_io_descriptor(tmp));
        if (f == (HANDLE)-1) return INVALID_HANDLE_VALUE;
    }
    else {
        VALUE tmp;
        WCHAR *ptr;
        int len;
        VALUE v;
 
        FilePathValue(*file);
        tmp = rb_str_encode_ospath(*file);
        len = MultiByteToWideChar(CP_UTF8, 0, RSTRING_PTR(tmp), -1, NULL, 0);
        ptr = ALLOCV_N(WCHAR, v, len);
        MultiByteToWideChar(CP_UTF8, 0, RSTRING_PTR(tmp), -1, ptr, len);
        f = CreateFileW(ptr, 0,
                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
                        FILE_FLAG_BACKUP_SEMANTICS, NULL);
        ALLOCV_END(v);
        if (f == INVALID_HANDLE_VALUE) return f;
        ret = f;
    }
    if (GetFileType(f) == FILE_TYPE_DISK) {
        ZeroMemory(st, sizeof(*st));
        if (get_ino(f, &st->info.fii)) {
            st->file_id_p = TRUE;
            return ret;
        }
        else if (GetLastError() != ERROR_INVALID_PARAMETER) {
            CloseHandle(f);
            return INVALID_HANDLE_VALUE;
        }
        /* this API may not work at files on non Microsoft SMB
         * server, fallback to old API then. */
        if (GetFileInformationByHandle(f, &st->info.bhfi)) {
            st->file_id_p = FALSE;
            return ret;
        }
    }
    if (ret) CloseHandle(ret);
    return INVALID_HANDLE_VALUE;
}
 
static VALUE
close_handle(VALUE h)
{
    CloseHandle((HANDLE)h);
    return Qfalse;
}
 
struct w32_io_info_args {
    VALUE *fname;
    w32_io_info_t *st;
};
 
static VALUE
call_w32_io_info(VALUE arg)
{
    struct w32_io_info_args *p = (void *)arg;
    return (VALUE)w32_io_info(p->fname, p->st);
}
 
VALUE
rb_w32_file_identical_p(VALUE fname1, VALUE fname2)
{
    w32_io_info_t st1, st2;
    HANDLE f1 = 0, f2 = 0;
 
    f1 = w32_io_info(&fname1, &st1);
    if (f1 == INVALID_HANDLE_VALUE) return Qfalse;
    if (f1) {
        struct w32_io_info_args arg;
        arg.fname = &fname2;
        arg.st = &st2;
        f2 = (HANDLE)rb_ensure(call_w32_io_info, (VALUE)&arg, close_handle, (VALUE)f1);
    }
    else {
        f2 = w32_io_info(&fname2, &st2);
    }
    if (f2 == INVALID_HANDLE_VALUE) return Qfalse;
    if (f2) CloseHandle(f2);
 
    if (st1.file_id_p != st2.file_id_p) return Qfalse;
    if (!st1.file_id_p) {
        if (st1.info.bhfi.dwVolumeSerialNumber == st2.info.bhfi.dwVolumeSerialNumber &&
            st1.info.bhfi.nFileIndexHigh == st2.info.bhfi.nFileIndexHigh &&
            st1.info.bhfi.nFileIndexLow == st2.info.bhfi.nFileIndexLow)
            return Qtrue;
    }
    else {
        if (st1.info.fii.VolumeSerialNumber == st2.info.fii.VolumeSerialNumber &&
            memcmp(&st1.info.fii.FileId, &st2.info.fii.FileId, sizeof(FILE_ID_128)) == 0)
            return Qtrue;
    }
    return Qfalse;
}
 
int
rb_w32_set_thread_description(HANDLE th, const WCHAR *name)
{
    int result = FALSE;
    typedef HRESULT (WINAPI *set_thread_description_func)(HANDLE, PCWSTR);
    static set_thread_description_func set_thread_description =
        (set_thread_description_func)-1;
    if (set_thread_description == (set_thread_description_func)-1) {
        /* Since Windows 10, version 1607 and Windows Server 2016 */
        set_thread_description = (set_thread_description_func)
            get_proc_address("kernel32", "SetThreadDescription", NULL);
    }
    if (set_thread_description) {
        result = set_thread_description(th, name);
    }
    return result;
}
 
int
rb_w32_set_thread_description_str(HANDLE th, VALUE name)
{
    int idx, result = FALSE;
    WCHAR *s;
 
    if (NIL_P(name)) {
        return rb_w32_set_thread_description(th, L"");
    }
    s = (WCHAR *)StringValueCStr(name);
    idx = rb_enc_get_index(name);
    if (idx == ENCINDEX_UTF_16LE) {
        result = rb_w32_set_thread_description(th, s);
    }
    else {
        name = rb_str_conv_enc(name, rb_enc_from_index(idx), rb_utf8_encoding());
        s = mbstr_to_wstr(CP_UTF8, RSTRING_PTR(name), RSTRING_LEN(name)+1, NULL);
        result = rb_w32_set_thread_description(th, s);
        free(s);
    }
    RB_GC_GUARD(name);
    return result;
}
 
VALUE (*const rb_f_notimplement_)(int, const VALUE *, VALUE, VALUE) = rb_f_notimplement;
 
void *
rb_w32_mmap(void *addr, size_t len, int prot, int flags, int fd, rb_off_t offset)
{
    void *ptr;
    //DWORD protect = 0;
    DWORD protect = PAGE_EXECUTE_READWRITE;
 
    if (fd > 0 || offset) {
        /* not supported */
        errno = EINVAL;
        return MAP_FAILED;
    }
 
/*
    if (prot & PROT_EXEC) {
        if (prot & PROT_WRITE) protect = PAGE_EXECUTE_READWRITE;
        else if (prot & PROT_READ) protect = PAGE_EXECUTE_READ;
        else protect = PAGE_EXECUTE;
    }
    else if (prot & PROT_WRITE) protect = PAGE_READWRITE;
    else if (prot & PROT_READ) protect = PAGE_READONLY;
*/
    ptr = VirtualAlloc(addr, len, MEM_RESERVE | MEM_COMMIT, protect);
    if (!ptr) {
        errno = rb_w32_map_errno(GetLastError());
        return MAP_FAILED;
    }
 
    return ptr;
}
 
int
rb_w32_munmap(void *addr, size_t len)
{
    if (!VirtualFree(addr, 0, MEM_RELEASE)) {
        errno = rb_w32_map_errno(GetLastError());
        return -1;
    }
 
    return 0;
}
 
inline int
rb_w32_mprotect(void *addr, size_t len, int prot)
{
/*
    DWORD protect = 0;
    if (prot & PROT_EXEC) {
        if (prot & PROT_WRITE) protect = PAGE_EXECUTE_READWRITE;
        else if (prot & PROT_READ) protect = PAGE_EXECUTE_READ;
        else protect = PAGE_EXECUTE;
    }
    else if (prot & PROT_WRITE) protect = PAGE_READWRITE;
    else if (prot & PROT_READ) protect = PAGE_READONLY;
    if (!VirtualProtect(addr, len, protect, NULL)) {
        errno = rb_w32_map_errno(GetLastError());
        return -1;
    }
*/
    if (prot & PROT_EXEC) {
        if (!FlushInstructionCache(GetCurrentProcess(), addr, len)) {
            errno = rb_w32_map_errno(GetLastError());
            return -1;
        }
    }
    return 0;
}