kotovalexarian-likes-github/ruby--ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
Code Releases Activity
ruby--ruby/win32/win32.c
usa a898f0fb4b * io.c (sysopen_func, rb_sysopen_internal, rb_sysopen): open file 
by UTF-16'ed filename on Windows.

	* io.c (rb_file_open_generic, rb_io_s_sysopen, rb_io_reopen,
	  argf_next_argv): follow above change.

	* io.c (rb_scan_open_args): no longer need to convert filepath here on
	  Windows.

	* win32/wio32.c (rb_w32_wopen): new function to open file by UTF-16'ed
	  filename.

	* win32/win32.c (rb_w32_open): call rb_w32_open().



git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@22626 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2009-02-25 08:36:45 +00:00

4930 lines
104 KiB
C
Raw Blame History

/*
* 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.
*
*/
#include "ruby/ruby.h"
#include "ruby/encoding.h"
#include "dln.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>
#if _MSC_VER >= 1400
#include <crtdbg.h>
#endif
#ifdef __MINGW32__
#include <mswsock.h>
#endif
#include "ruby/win32.h"
#include "win32/dir.h"
#define isdirsep(x) ((x) == '/' || (x) == '\\')
#undef stat
#undef fclose
#undef close
#undef setsockopt
#if defined __BORLANDC__
# define _filbuf _fgetc
# define _flsbuf _fputc
# define enough_to_get(n) (--(n) >= 0)
# define enough_to_put(n) (++(n) < 0)
#else
# define enough_to_get(n) (--(n) >= 0)
# define enough_to_put(n) (--(n) >= 0)
#endif
#ifdef WIN32_DEBUG
#define Debug(something) something
#else
#define Debug(something) /* nothing */
#endif
#define TO_SOCKET(x) _get_osfhandle(x)
static struct ChildRecord *CreateChild(const char *, const char *, SECURITY_ATTRIBUTES *, HANDLE, HANDLE, HANDLE);
static int has_redirection(const char *);
int rb_w32_wait_events(HANDLE *events, int num, DWORD timeout);
static int rb_w32_open_osfhandle(intptr_t osfhandle, int flags);
#define RUBY_CRITICAL(expr) do { expr; } while (0)
/* errno mapping */
static 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 },
{ WSAENAMETOOLONG, ENAMETOOLONG },
{ WSAENOTEMPTY, ENOTEMPTY },
{ WSAEINTR, EINTR },
{ WSAEBADF, EBADF },
{ WSAEACCES, EACCES },
{ WSAEFAULT, EFAULT },
{ WSAEINVAL, EINVAL },
{ WSAEMFILE, EMFILE },
};
int
rb_w32_map_errno(DWORD winerr)
{
int i;
if (winerr == 0) {
return 0;
}
for (i = 0; i < 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;
#ifdef WIN95
static DWORD Win32System = (DWORD)-1;
DWORD
rb_w32_osid(void)
{
if (osver.dwPlatformId != Win32System) {
memset(&osver, 0, sizeof(OSVERSIONINFO));
osver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx(&osver);
Win32System = osver.dwPlatformId;
}
return (Win32System);
}
#endif
static DWORD Win32Version = (DWORD)-1;
static DWORD
rb_w32_osver(void)
{
if (osver.dwMajorVersion != Win32Version) {
memset(&osver, 0, sizeof(OSVERSIONINFO));
osver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx(&osver);
Win32Version = osver.dwMajorVersion;
}
return (Win32Version);
}
#define IsWinNT() rb_w32_iswinnt()
#define IsWin95() rb_w32_iswin95()
HANDLE
GetCurrentThreadHandle(void)
{
static HANDLE current_process_handle = NULL;
HANDLE h;
if (!current_process_handle)
current_process_handle = GetCurrentProcess();
if (!DuplicateHandle(current_process_handle, GetCurrentThread(),
current_process_handle, &h,
0, FALSE, DUPLICATE_SAME_ACCESS))
return NULL;
return h;
}
/* simulate flock by locking a range on the file */
#define LK_ERR(f,i) \
do { \
if (f) \
i = 0; \
else { \
DWORD err = GetLastError(); \
if (err == ERROR_LOCK_VIOLATION) \
errno = EWOULDBLOCK; \
else if (err == ERROR_NOT_LOCKED) \
i = 0; \
else \
errno = map_errno(err); \
} \
} while (0)
#define LK_LEN ULONG_MAX
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;
}
#ifdef WIN95
static uintptr_t
flock_win95(uintptr_t self, int argc, uintptr_t* argv)
{
int i = -1;
const HANDLE fh = (HANDLE)self;
const int oper = argc;
switch(oper) {
case LOCK_EX:
do {
LK_ERR(LockFile(fh, 0, 0, LK_LEN, LK_LEN), i);
} while (i && errno == EWOULDBLOCK);
break;
case LOCK_EX|LOCK_NB:
LK_ERR(LockFile(fh, 0, 0, LK_LEN, LK_LEN), i);
break;
case LOCK_UN:
case LOCK_UN|LOCK_NB:
LK_ERR(UnlockFile(fh, 0, 0, LK_LEN, LK_LEN), i);
break;
default:
errno = EINVAL;
break;
}
return i;
}
#endif
#undef LK_ERR
int
flock(int fd, int oper)
{
#ifdef WIN95
static asynchronous_func_t locker = NULL;
if (!locker) {
if (IsWinNT())
locker = flock_winnt;
else
locker = flock_win95;
}
#else
const asynchronous_func_t locker = flock_winnt;
#endif
return rb_w32_asynchronize(locker,
(VALUE)_get_osfhandle(fd), oper, NULL,
(DWORD)-1);
}
static inline char *
translate_char(char *p, int from, int to)
{
while (*p) {
if ((unsigned char)*p == from)
*p = to;
p = CharNext(p);
}
return p;
}
#ifndef CSIDL_PROFILE
#define CSIDL_PROFILE 40
#endif
static BOOL
get_special_folder(int n, char *env)
{
LPITEMIDLIST pidl;
LPMALLOC alloc;
BOOL f = FALSE;
if (SHGetSpecialFolderLocation(NULL, n, &pidl) == 0) {
f = SHGetPathFromIDList(pidl, env);
SHGetMalloc(&alloc);
alloc->lpVtbl->Free(alloc, pidl);
alloc->lpVtbl->Release(alloc);
}
return f;
}
static void
init_env(void)
{
char env[_MAX_PATH];
DWORD len;
BOOL f;
if (!GetEnvironmentVariable("HOME", env, sizeof(env))) {
f = FALSE;
if (GetEnvironmentVariable("HOMEDRIVE", env, sizeof(env)))
len = strlen(env);
else
len = 0;
if (GetEnvironmentVariable("HOMEPATH", env + len, sizeof(env) - len) || len) {
f = TRUE;
}
else if (GetEnvironmentVariable("USERPROFILE", env, sizeof(env))) {
f = TRUE;
}
else if (get_special_folder(CSIDL_PROFILE, env)) {
f = TRUE;
}
else if (get_special_folder(CSIDL_PERSONAL, env)) {
f = TRUE;
}
if (f) {
char *p = translate_char(env, '\\', '/');
if (p - env == 2 && env[1] == ':') {
*p++ = '/';
*p = 0;
}
SetEnvironmentVariable("HOME", env);
}
}
if (!GetEnvironmentVariable("USER", env, sizeof env)) {
if (GetEnvironmentVariable("USERNAME", env, sizeof env)) {
SetEnvironmentVariable("USER", env);
}
else if (!GetUserName(env, (len = sizeof env, &len))) {
NTLoginName = "<Unknown>";
return;
}
}
NTLoginName = strdup(env);
}
typedef BOOL (WINAPI *cancel_io_t)(HANDLE);
static cancel_io_t cancel_io = NULL;
static void
init_func(void)
{
if (!cancel_io)
cancel_io = (cancel_io_t)GetProcAddress(GetModuleHandle("kernel32"),
"CancelIo");
}
static void init_stdhandle(void);
#if _MSC_VER >= 1400
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;
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 int NtSocketsInitialized = 0;
static st_table *socklist = NULL;
static char *envarea;
static void
exit_handler(void)
{
if (NtSocketsInitialized) {
WSACleanup();
st_free_table(socklist);
socklist = NULL;
NtSocketsInitialized = 0;
}
if (envarea) {
FreeEnvironmentStrings(envarea);
envarea = NULL;
}
DeleteCriticalSection(&select_mutex);
}
static void
StartSockets(void)
{
WORD version;
WSADATA retdata;
//
// initalize 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!\n");
if (LOBYTE(retdata.wVersion) != 2)
rb_fatal("could not find version 2 of winsock dll\n");
socklist = st_init_numtable();
NtSocketsInitialized = 1;
}
//
// Initialization stuff
//
void
rb_w32_sysinit(int *argc, char ***argv)
{
#if _MSC_VER >= 1400
static void set_pioinfo_extra(void);
_CrtSetReportMode(_CRT_ASSERT, 0);
_set_invalid_parameter_handler(invalid_parameter);
_RTC_SetErrorFunc(rtc_error_handler);
set_pioinfo_extra();
#endif
//
// subvert cmd.exe's feeble attempt at command line parsing
//
*argc = rb_w32_cmdvector(GetCommandLine(), argv);
//
// Now set up the correct time stuff
//
tzset();
init_env();
init_func();
init_stdhandle();
InitializeCriticalSection(&select_mutex);
atexit(exit_handler);
// Initialize Winsock
StartSockets();
}
char *
getlogin(void)
{
return (char *)NTLoginName;
}
#define MAXCHILDNUM 256 /* max num of child processes */
static struct ChildRecord {
HANDLE hProcess; /* process handle */
rb_pid_t pid; /* process id */
} ChildRecord[MAXCHILDNUM];
#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)
static struct ChildRecord *
FindChildSlot(rb_pid_t pid)
{
FOREACH_CHILD(child) {
if (child->pid == pid) {
return child;
}
} END_FOREACH_CHILD;
return NULL;
}
static struct ChildRecord *
FindChildSlotByHandle(HANDLE h)
{
FOREACH_CHILD(child) {
if (child->hProcess == h) {
return child;
}
} END_FOREACH_CHILD;
return NULL;
}
static void
CloseChildHandle(struct ChildRecord *child)
{
HANDLE h = child->hProcess;
child->hProcess = NULL;
child->pid = 0;
CloseHandle(h);
}
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;
}
/*
ruby -lne 'BEGIN{$cmds = Hash.new(0); $mask = 1}'
-e '$cmds[$_.downcase] |= $mask' -e '$mask <<= 1 if ARGF.eof'
-e 'END{$cmds.sort.each{|n,f|puts " \"\\#{f.to_s(8)}\" #{n.dump} + 1,"}}'
98cmd ntcmd
*/
static const char *const szInternalCmds[] = {
"\2" "assoc" + 1,
"\3" "break" + 1,
"\3" "call" + 1,
"\3" "cd" + 1,
"\1" "chcp" + 1,
"\3" "chdir" + 1,
"\3" "cls" + 1,
"\2" "color" + 1,
"\3" "copy" + 1,
"\1" "ctty" + 1,
"\3" "date" + 1,
"\3" "del" + 1,
"\3" "dir" + 1,
"\3" "echo" + 1,
"\2" "endlocal" + 1,
"\3" "erase" + 1,
"\3" "exit" + 1,
"\3" "for" + 1,
"\2" "ftype" + 1,
"\3" "goto" + 1,
"\3" "if" + 1,
"\1" "lfnfor" + 1,
"\1" "lh" + 1,
"\1" "lock" + 1,
"\3" "md" + 1,
"\3" "mkdir" + 1,
"\2" "move" + 1,
"\3" "path" + 1,
"\3" "pause" + 1,
"\2" "popd" + 1,
"\3" "prompt" + 1,
"\2" "pushd" + 1,
"\3" "rd" + 1,
"\3" "rem" + 1,
"\3" "ren" + 1,
"\3" "rename" + 1,
"\3" "rmdir" + 1,
"\3" "set" + 1,
"\2" "setlocal" + 1,
"\3" "shift" + 1,
"\2" "start" + 1,
"\3" "time" + 1,
"\2" "title" + 1,
"\1" "truename" + 1,
"\3" "type" + 1,
"\1" "unlock" + 1,
"\3" "ver" + 1,
"\3" "verify" + 1,
"\3" "vol" + 1,
};
static int
internal_match(const void *key, const void *elem)
{
return strcmp(key, *(const char *const *)elem);
}
static int
is_command_com(const char *interp)
{
int i = strlen(interp) - 11;
if ((i == 0 || i > 0 && isdirsep(interp[i-1])) &&
strcasecmp(interp+i, "command.com") == 0) {
return 1;
}
return 0;
}
static int internal_cmd_match(const char *cmdname, int nt);
static int
is_internal_cmd(const char *cmd, int nt)
{
char cmdname[9], *b = cmdname, c;
do {
if (!(c = *cmd++)) return 0;
} while (isspace(c));
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, nt);
}
static int
internal_cmd_match(const char *cmdname, int nt)
{
char **nm;
nm = bsearch(cmdname, szInternalCmds,
sizeof(szInternalCmds) / sizeof(*szInternalCmds),
sizeof(*szInternalCmds),
internal_match);
if (!nm || !(nm[0][-1] & (nt ? 2 : 1)))
return 0;
return 1;
}
SOCKET
rb_w32_get_osfhandle(int fh)
{
return _get_osfhandle(fh);
}
static int
argv_size(char *const *argv, BOOL escape)
{
const char *p;
char *const *t;
int len, n, bs, quote;
for (t = argv, len = 0; *t; t++) {
for (p = *t, n = quote = bs = 0; *p; ++p) {
switch (*p) {
case '\\':
++bs;
break;
case '<': case '>': case '|': case '^':
bs = 0;
if (escape && !quote) n++;
break;
case '"':
n += bs + 1; bs = 0;
quote = 1;
break;
case ' ': case '\t':
quote = 1;
default:
bs = 0;
p = CharNext(p) - 1;
break;
}
}
len += p - *t + n + 1;
if (p - *t == 0 || quote) len += 2;
}
return len;
}
static char *
join_argv(char *cmd, char *const *argv, BOOL escape)
{
const char *p, *s;
char *q, *const *t;
int n, bs, quote;
for (t = argv, q = cmd; p = *t; t++) {
quote = 0;
s = p;
if (!*p || strpbrk(p, " \t\"")) {
quote = 1;
*q++ = '"';
}
for (bs = 0; *p; ++p) {
switch (*p) {
case '\\':
++bs;
break;
case '"':
memcpy(q, s, n = p - s); q += n; s = p;
memset(q, '\\', ++bs); q += bs; bs = 0;
break;
case '<': case '>': case '|': case '^':
if (escape && !quote) {
memcpy(q, s, n = p - s); q += n; s = p;
*q++ = '^';
break;
}
default:
bs = 0;
p = CharNext(p) - 1;
break;
}
}
memcpy(q, s, n = p - s);
q += n;
if (quote) *q++ = '"';
*q++ = ' ';
}
if (q > cmd) --q;
*q = '\0';
return cmd;
}
#ifdef HAVE_SYS_PARAM_H
# include <sys/param.h>
#else
# define MAXPATHLEN 512
#endif
#define STRNDUPA(ptr, src, len) \
(((char *)memcpy(((ptr) = ALLOCA_N(char, (len) + 1)), (src), (len)))[len] = 0)
static int
check_spawn_mode(int mode)
{
switch (mode) {
case P_NOWAIT:
case P_OVERLAY:
return 0;
default:
errno = EINVAL;
return -1;
}
}
static rb_pid_t
child_result(struct ChildRecord *child, int mode)
{
DWORD exitcode;
if (!child) {
return -1;
}
switch (mode) {
case P_NOWAIT:
return child->pid;
case P_OVERLAY:
WaitForSingleObject(child->hProcess, INFINITE);
GetExitCodeProcess(child->hProcess, &exitcode);
CloseChildHandle(child);
_exit(exitcode);
default:
return -1; /* not reached */
}
}
static struct ChildRecord *
CreateChild(const char *cmd, const char *prog, SECURITY_ATTRIBUTES *psa,
HANDLE hInput, HANDLE hOutput, HANDLE hError)
{
BOOL fRet;
DWORD dwCreationFlags;
STARTUPINFO aStartupInfo;
PROCESS_INFORMATION aProcessInformation;
SECURITY_ATTRIBUTES sa;
struct ChildRecord *child;
if (!cmd && !prog) {
errno = EFAULT;
return NULL;
}
child = FindFreeChildSlot();
if (!child) {
errno = EAGAIN;
return NULL;
}
if (!psa) {
sa.nLength = sizeof (SECURITY_ATTRIBUTES);
sa.lpSecurityDescriptor = NULL;
sa.bInheritHandle = TRUE;
psa = &sa;
}
memset(&aStartupInfo, 0, sizeof (STARTUPINFO));
memset(&aProcessInformation, 0, sizeof (PROCESS_INFORMATION));
aStartupInfo.cb = sizeof (STARTUPINFO);
if (hInput || hOutput || hError) {
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);
RUBY_CRITICAL({
fRet = CreateProcess(prog, (char *)cmd, psa, psa,
psa->bInheritHandle, dwCreationFlags, NULL, NULL,
&aStartupInfo, &aProcessInformation);
errno = map_errno(GetLastError());
});
if (!fRet) {
child->pid = 0; /* release the slot */
return NULL;
}
CloseHandle(aProcessInformation.hThread);
child->hProcess = aProcessInformation.hProcess;
child->pid = (rb_pid_t)aProcessInformation.dwProcessId;
if (!IsWinNT()) {
/* On Win9x, make pid positive similarly to cygwin and perl */
child->pid = -child->pid;
}
return child;
}
rb_pid_t
rb_w32_spawn(int mode, const char *cmd, const char *prog)
{
char fbuf[MAXPATHLEN];
char *p = NULL;
const char *shell = NULL;
if (check_spawn_mode(mode)) return -1;
if (prog) {
if (!(p = dln_find_exe_r(prog, NULL, fbuf, sizeof(fbuf)))) {
shell = prog;
}
}
else {
int redir = -1;
int nt;
while (ISSPACE(*cmd)) cmd++;
if ((shell = getenv("RUBYSHELL")) && (redir = has_redirection(cmd))) {
char *tmp = ALLOCA_N(char, strlen(shell) + strlen(cmd) + sizeof(" -c ") + 2);
sprintf(tmp, "%s -c \"%s\"", shell, cmd);
cmd = tmp;
}
else if ((shell = getenv("COMSPEC")) &&
(nt = !is_command_com(shell),
(redir < 0 ? has_redirection(cmd) : redir) ||
is_internal_cmd(cmd, nt))) {
char *tmp = ALLOCA_N(char, strlen(shell) + strlen(cmd) + sizeof(" /c ")
+ (nt ? 2 : 0));
sprintf(tmp, nt ? "%s /c \"%s\"" : "%s /c %s", shell, cmd);
cmd = tmp;
}
else {
int len = 0;
if (*cmd == '"') {
for (prog = cmd + 1; *prog && *prog != '"'; prog = CharNext(prog));
len = prog - cmd - 1;
STRNDUPA(p, cmd + 1, len);
p = dln_find_exe_r(p, NULL, fbuf, sizeof(fbuf));
if (p) goto command_found;
}
for (prog = cmd; *prog; prog = CharNext(prog)) {
if (ISSPACE(*prog)) {
len = prog - cmd;
do ++prog; while (ISSPACE(*prog));
break;
}
else {
len = 0;
}
}
if (!len) len = strlen(cmd);
shell = NULL;
prog = cmd;
for (;;) {
if (!*prog) {
p = dln_find_exe_r(cmd, NULL, fbuf, sizeof(fbuf));
break;
}
if (strchr(":*?\"/\\", *prog)) {
if (cmd[len]) {
STRNDUPA(p, cmd, len);
}
p = dln_find_exe_r(p ? p : cmd, NULL, fbuf, sizeof(fbuf));
break;
}
if (ISSPACE(*prog) || strchr("<>|", *prog)) {
len = prog - cmd;
STRNDUPA(p, cmd, len);
p = dln_find_exe_r(p, NULL, fbuf, sizeof(fbuf));
break;
}
prog++;
}
}
}
if (p) {
command_found:
shell = p;
translate_char(p, '/', '\\');
}
return child_result(CreateChild(cmd, shell, NULL, NULL, NULL, NULL), mode);
}
rb_pid_t
rb_w32_aspawn(int mode, const char *prog, char *const *argv)
{
int len, differ = 0, c_switch = 0;
BOOL ntcmd = FALSE, tmpnt;
const char *shell;
char *cmd, fbuf[MAXPATHLEN];
if (check_spawn_mode(mode)) return -1;
if (!prog) prog = argv[0];
if ((shell = getenv("COMSPEC")) &&
internal_cmd_match(prog, tmpnt = !is_command_com(shell))) {
ntcmd = tmpnt;
prog = shell;
c_switch = 1;
differ = 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, '/', '\\');
prog = cmd;
argv++;
differ = 1;
}
else if (strchr(prog, '/')) {
strlcpy(fbuf, prog, sizeof(fbuf));
translate_char(fbuf, '/', '\\');
prog = fbuf;
argv++;
differ = 1;
}
if (differ) {
char *progs[2];
progs[0] = (char *)prog;
progs[1] = NULL;
len = argv_size(progs, ntcmd);
if (c_switch) len += 3;
if (argv[0]) len += argv_size(argv, ntcmd);
cmd = ALLOCA_N(char, len);
join_argv(cmd, progs, ntcmd);
if (c_switch) strlcat(cmd, " /c", len);
if (argv[0]) join_argv(cmd + strlcat(cmd, " ", len), argv, ntcmd);
}
else {
len = argv_size(argv, FALSE);
cmd = ALLOCA_N(char, len);
join_argv(cmd, argv, FALSE);
}
return child_result(CreateChild(cmd, prog, NULL, NULL, NULL, NULL), mode);
}
typedef struct _NtCmdLineElement {
struct _NtCmdLineElement *next;
char *str;
int 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
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;
}
static NtCmdLineElement **
cmdglob(NtCmdLineElement *patt, NtCmdLineElement **tail)
{
char buffer[MAXPATHLEN], *buf = buffer;
char *p;
NtCmdLineElement **last = tail;
int status;
if (patt->len >= MAXPATHLEN)
if (!(buf = malloc(patt->len + 1))) return 0;
strlcpy(buf, patt->str, patt->len + 1);
buf[patt->len] = '\0';
for (p = buf; *p; p = CharNext(p))
if (*p == '\\')
*p = '/';
status = ruby_brace_glob(buf, 0, insert, (VALUE)&tail);
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
//
static int
has_redirection(const char *cmd)
{
char quote = '\0';
const char *ptr;
//
// Scan the string, looking for redirection (< or >) or pipe
// characters (|) 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 '|':
if (!quote)
return TRUE;
ptr++;
break;
case '%':
if (*++ptr != '_' && !ISALPHA(*ptr)) break;
while (*++ptr == '_' || ISALNUM(*ptr));
if (*ptr++ == '%') return TRUE;
break;
case '\\':
ptr++;
default:
ptr = CharNext(ptr);
break;
}
}
return FALSE;
}
static inline char *
skipspace(char *ptr)
{
while (ISSPACE(*ptr))
ptr++;
return ptr;
}
int
rb_w32_cmdvector(const char *cmd, char ***vec)
{
int globbing, len;
int elements, strsz, done;
int slashes, escape;
char *ptr, *base, *buffer, *cmdline;
char **vptr;
char 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 = strdup(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 interation for each element seen.
// The inner loop does one interation 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 '\\':
if (quote != '\'') slashes++;
break;
case ' ':
case '\t':
case '\n':
//
// if we're not in a string, then we're finished with this
// element
//
if (!quote) {
*ptr = 0;
done = 1;
}
break;
case '*':
case '?':
case '[':
case '{':
//
// record the fact that this element has a wildcard character
// N.B. Don't glob if inside a single quoted string
//
if (quote != '\'')
globbing++;
slashes = 0;
break;
case '\'':
case '\"':
//
// 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 neccessarily 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 == '"' && quote == ptr[1])
ptr++;
quote = '\0';
}
}
escape++;
slashes = 0;
break;
default:
ptr = CharNext(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) {
char *p = base, c;
slashes = quote = 0;
while (p < base + len) {
switch (c = *p) {
case '\\':
p++;
if (quote != '\'') slashes++;
break;
case '\'':
case '"':
if (!(slashes & 1) && quote && quote != c) {
p++;
slashes = 0;
break;
}
memcpy(p - ((slashes + 1) >> 1), p + (~slashes & 1),
base + len - p);
len -= ((slashes + 1) >> 1) + (~slashes & 1);
p -= (slashes + 1) >> 1;
if (!(slashes & 1)) {
if (quote) {
if (quote == '"' && quote == *p)
p++;
quote = '\0';
}
else
quote = c;
}
else
p++;
slashes = 0;
break;
default:
p = CharNext(p);
slashes = 0;
break;
}
}
}
curr = (NtCmdLineElement *)calloc(sizeof(NtCmdLineElement), 1);
if (!curr) goto do_nothing;
curr->str = base;
curr->len = len;
if (globbing && (tail = cmdglob(curr, cmdtail))) {
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) {
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 ptr 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;
ptr = buffer + (elements+1) * sizeof(char *);
while (curr = cmdhead) {
strlcpy(ptr, curr->str, curr->len + 1);
*vptr++ = ptr;
ptr += 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
//
#define PATHLEN 1024
//
// 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.
//
#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 HANDLE
open_dir_handle(const char *filename, WIN32_FIND_DATAW *fd)
{
HANDLE fh;
static const WCHAR wildcard[] = L"\\*";
UINT cp = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
WCHAR *scanname;
WCHAR *p;
int len;
//
// Create the search pattern
//
len = MultiByteToWideChar(cp, 0, filename, -1, NULL, 0);
if (len <= 0) {
errno = map_errno(GetLastError());
return INVALID_HANDLE_VALUE;
}
scanname = ALLOCA_N(WCHAR, len + sizeof(wildcard) / sizeof(WCHAR));
len = MultiByteToWideChar(cp, 0, filename, -1, scanname, len + 2);
if (len <= 0) {
errno = map_errno(GetLastError());
return INVALID_HANDLE_VALUE;
}
p = CharPrevW(scanname, scanname + len);
if (*p == L'/' || *p == L'\\' || *p == L':')
lstrcatW(scanname, wildcard + 1);
else
lstrcatW(scanname, wildcard);
//
// do the FindFirstFile call
//
fh = FindFirstFileW(scanname, fd);
if (fh == INVALID_HANDLE_VALUE) {
errno = map_errno(GetLastError());
}
return fh;
}
static DIR *
opendir_internal(HANDLE fh, WIN32_FIND_DATAW *fd)
{
DIR *p;
long len;
long idx;
WCHAR *tmpW;
char *tmp;
if (fh == INVALID_HANDLE_VALUE) {
return NULL;
}
//
// Get us a DIR structure
//
p = calloc(sizeof(DIR), 1);
if (p == NULL)
return NULL;
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;
//
// bump the string table size by enough for the
// new name and it's null terminator
//
tmpW = realloc(p->start, (idx + len) * 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));
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)
SetBit(p->bits, BitOfIsRep(p->nfiles));
p->nfiles++;
idx += len;
} while (FindNextFileW(fh, fd));
FindClose(fh);
p->size = idx;
p->curr = p->start;
return p;
}
DIR *
rb_w32_opendir(const char *filename)
{
struct stati64 sbuf;
WIN32_FIND_DATAW fd;
HANDLE fh;
//
// check to see if we've got a directory
//
if (rb_w32_stati64(filename, &sbuf) < 0)
return NULL;
if (!(sbuf.st_mode & S_IFDIR) &&
(!ISALPHA(filename[0]) || filename[1] != ':' || filename[2] != '\0' ||
((1 << (filename[0] & 0x5f) - 'A') & GetLogicalDrives()) == 0)) {
errno = ENOTDIR;
return NULL;
}
fh = open_dir_handle(filename, &fd);
return opendir_internal(fh, &fd);
}
//
// Move to next entry
//
static void
move_to_next_entry(DIR *dirp)
{
if (dirp->curr) {
dirp->loc++;
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.
//
static BOOL
win32_direct_conv(const WCHAR *file, struct direct *entry, rb_encoding *dummy)
{
UINT cp = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
entry->d_namlen =
WideCharToMultiByte(cp, 0, file, -1, NULL, 0, NULL, NULL) - 1;
if (!(entry->d_name = malloc(entry->d_namlen + 1)))
return FALSE;
WideCharToMultiByte(cp, 0, file, -1, entry->d_name, entry->d_namlen + 1,
NULL, NULL);
return TRUE;
}
static BOOL
ruby_direct_conv(const WCHAR *file, struct direct *entry, rb_encoding *enc)
{
static rb_encoding *utf16 = (rb_encoding *)-1;
VALUE src;
VALUE dst;
VALUE opthash;
int ecflags;
VALUE ecopts;
if (utf16 == (rb_encoding *)-1) {
utf16 = rb_enc_find("UTF-16LE");
if (utf16 == rb_ascii8bit_encoding())
utf16 = NULL;
}
if (!utf16)
/* maybe miniruby */
return win32_direct_conv(file, entry, NULL);
src = rb_enc_str_new((char *)file, lstrlenW(file) * sizeof(WCHAR), utf16);
opthash = rb_hash_new();
rb_hash_aset(opthash, ID2SYM(rb_intern("undef")),
ID2SYM(rb_intern("replace")));
ecflags = rb_econv_prepare_opts(opthash, &ecopts);
dst = rb_str_encode(src, rb_enc_from_encoding(enc), ecflags, ecopts);
entry->d_namlen = RSTRING_LEN(dst);
if (!(entry->d_name = malloc(entry->d_namlen + 1)))
return FALSE;
memcpy(entry->d_name, RSTRING_PTR(dst), entry->d_namlen);
entry->d_name[entry->d_namlen] = '\0';
return TRUE;
}
static struct direct *
readdir_internal(DIR *dirp, BOOL (*conv)(const WCHAR *, struct direct *, rb_encoding *), rb_encoding *enc)
{
static int dummy = 0;
if (dirp->curr) {
//
// first set up the structure to return
//
conv(dirp->curr, &dirp->dirstr, enc);
//
// Fake inode
//
dirp->dirstr.d_ino = dummy++;
//
// Attributes
//
dirp->dirstr.d_isdir = GetBit(dirp->bits, BitOfIsDir(dirp->loc));
dirp->dirstr.d_isrep = GetBit(dirp->bits, BitOfIsRep(dirp->loc));
//
// Now set up for the next call to readdir
//
move_to_next_entry(dirp);
return &(dirp->dirstr);
} else
return NULL;
}
struct direct *
rb_w32_readdir(DIR *dirp)
{
return readdir_internal(dirp, win32_direct_conv, NULL);
}
struct direct *
rb_w32_readdir_with_enc(DIR *dirp, rb_encoding *enc)
{
if (enc == rb_ascii8bit_encoding())
return readdir_internal(dirp, win32_direct_conv, NULL);
else
return readdir_internal(dirp, ruby_direct_conv, enc);
}
//
// Telldir returns the current string pointer position
//
off_t
rb_w32_telldir(DIR *dirp)
{
return dirp->loc;
}
//
// Seekdir moves the string pointer to a previously saved position
// (Saved by telldir).
void
rb_w32_seekdir(DIR *dirp, off_t 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
//
void
rb_w32_rewinddir(DIR *dirp)
{
dirp->curr = dirp->start;
dirp->loc = 0;
}
//
// This just free's the memory allocated by opendir
//
void
rb_w32_closedir(DIR *dirp)
{
if (dirp) {
if (dirp->dirstr.d_name)
free(dirp->dirstr.d_name);
if (dirp->start)
free(dirp->start);
if (dirp->bits)
free(dirp->bits);
free(dirp);
}
}
#if (defined _MT || defined __MSVCRT__) && !defined __BORLANDC__
#define MSVCRT_THREADS
#endif
#ifdef MSVCRT_THREADS
# define MTHREAD_ONLY(x) x
# define STHREAD_ONLY(x)
#elif defined(__BORLANDC__)
# define MTHREAD_ONLY(x)
# define STHREAD_ONLY(x)
#else
# define MTHREAD_ONLY(x)
# define STHREAD_ONLY(x) x
#endif
typedef struct {
intptr_t osfhnd; /* underlying OS file HANDLE */
char osfile; /* attributes of file (e.g., open in text mode?) */
char pipech; /* one char buffer for handles opened on pipes */
#ifdef MSVCRT_THREADS
int lockinitflag;
CRITICAL_SECTION lock;
#endif
#if _MSC_VER >= 1400
char textmode;
char pipech2[2];
#endif
} ioinfo;
#if !defined _CRTIMP || defined __MINGW32__
#undef _CRTIMP
#define _CRTIMP __declspec(dllimport)
#endif
#if !defined(__BORLANDC__)
EXTERN_C _CRTIMP ioinfo * __pioinfo[];
#define IOINFO_L2E 5
#define IOINFO_ARRAY_ELTS (1 << IOINFO_L2E)
#define _pioinfo(i) ((ioinfo*)((char*)(__pioinfo[i >> IOINFO_L2E]) + (i & (IOINFO_ARRAY_ELTS - 1)) * (sizeof(ioinfo) + pioinfo_extra)))
#define _osfhnd(i) (_pioinfo(i)->osfhnd)
#define _osfile(i) (_pioinfo(i)->osfile)
#define _pipech(i) (_pioinfo(i)->pipech)
#if _MSC_VER >= 1400
static size_t pioinfo_extra = 0; /* workaround for VC++8 SP1 */
static void
set_pioinfo_extra(void)
{
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;
}
}
#else
#define pioinfo_extra 0
#endif
#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
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((long)hF, 0);
CloseHandle(hF);
if (fh == -1) {
errno = EMFILE; /* too many open files */
_doserrno = 0L; /* not an OS error */
}
else {
MTHREAD_ONLY(EnterCriticalSection(&(_pioinfo(fh)->lock)));
/* 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 */
MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fh)->lock));
}
return fh; /* return handle */
}
static void
init_stdhandle(void)
{
int nullfd = -1;
int keep = 0;
#define open_null(fd) \
(((nullfd < 0) ? \
(nullfd = open("NUL", O_RDWR|O_BINARY)) : 0), \
((nullfd == (fd)) ? (keep = 1) : dup2(nullfd, fd)), \
(fd))
if (fileno(stdin) < 0) {
stdin->_file = open_null(0);
}
else {
setmode(fileno(stdin), O_BINARY);
}
if (fileno(stdout) < 0) {
stdout->_file = open_null(1);
}
else {
setmode(fileno(stdout), O_BINARY);
}
if (fileno(stderr) < 0) {
stderr->_file = open_null(2);
}
else {
setmode(fileno(stderr), O_BINARY);
}
if (nullfd >= 0 && !keep) close(nullfd);
setvbuf(stderr, NULL, _IONBF, 0);
}
#else
#define _set_osfhnd(fh, osfh) (void)((fh), (osfh))
#define _set_osflags(fh, flags) (void)((fh), (flags))
static void
init_stdhandle(void)
{
}
#endif
#ifdef __BORLANDC__
static int
rb_w32_open_osfhandle(intptr_t osfhandle, int flags)
{
int fd = _open_osfhandle(osfhandle, flags);
if (fd == -1) {
errno = EMFILE; /* too many open files */
_doserrno = 0L; /* not an OS error */
}
return fd;
}
#endif
#undef getsockopt
static int
is_socket(SOCKET sock)
{
if (st_lookup(socklist, (st_data_t)sock, NULL))
return TRUE;
else
return FALSE;
}
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
char *
rb_w32_strerror(int e)
{
static char buffer[512];
#if !defined __MINGW32__
extern int sys_nerr;
#endif
DWORD source = 0;
char *p;
#if defined __BORLANDC__ && defined ENOTEMPTY // _sys_errlist is broken
switch (e) {
case ENAMETOOLONG:
return "Filename too long";
case ENOTEMPTY:
return "Directory not empty";
}
#endif
if (e < 0 || e > sys_nerr) {
if (e < 0)
e = GetLastError();
if (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
rb_uid_t
getuid(void)
{
return ROOT_UID;
}
rb_uid_t
geteuid(void)
{
return ROOT_UID;
}
rb_gid_t
getgid(void)
{
return ROOT_GID;
}
rb_gid_t
getegid(void)
{
return ROOT_GID;
}
int
setuid(rb_uid_t uid)
{
return (uid == ROOT_UID ? 0 : -1);
}
int
setgid(rb_gid_t gid)
{
return (gid == ROOT_GID ? 0 : -1);
}
//
// File system stuff
//
int
ioctl(int i, int u, ...)
{
errno = EINVAL;
return -1;
}
#undef FD_SET
void
rb_w32_fdset(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) {
return;
}
}
if (i == set->fd_count) {
if (set->fd_count < FD_SETSIZE) {
set->fd_array[i] = s;
set->fd_count++;
}
}
}
#undef FD_CLR
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
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;
}
//
// Networking trampolines
// These are used to avoid socket startup/shutdown overhead in case
// the socket routines aren't used.
//
#undef select
static int
extract_fd(rb_fdset_t *dst, fd_set *src, int (*func)(SOCKET))
{
int s = 0;
if (!src || !dst) return 0;
while (s < src->fd_count) {
SOCKET fd = src->fd_array[s];
if (!func || (*func)(fd)) { /* move it to dst */
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 (dst->fdset->fd_count >= dst->capa) {
dst->capa = (dst->fdset->fd_count / FD_SETSIZE + 1) * FD_SETSIZE;
dst->fdset = xrealloc(dst->fdset, sizeof(unsigned int) + 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 s++;
}
return dst->fdset->fd_count;
}
static int
copy_fd(fd_set *dst, fd_set *src)
{
int s;
if (!src || !dst) return 0;
for (s = 0; s < src->fd_count; ++s) {
SOCKET fd = src->fd_array[s];
int d;
for (d = 0; d < dst->fd_count; ++d) {
if (dst->fd_array[d] == fd)
break;
}
if (d == dst->fd_count && d < FD_SETSIZE) {
dst->fd_array[dst->fd_count++] = fd;
}
}
return dst->fd_count;
}
static int
is_not_socket(SOCKET sock)
{
return !is_socket(sock);
}
static int
is_pipe(SOCKET sock) /* DONT call this for SOCKET! it clains it is PIPE. */
{
int ret;
RUBY_CRITICAL({
ret = (GetFileType((HANDLE)sock) == FILE_TYPE_PIPE);
});
return ret;
}
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;
}
static int
is_console(SOCKET sock) /* DONT call this for SOCKET! */
{
int ret;
DWORD n = 0;
INPUT_RECORD ir;
RUBY_CRITICAL(
ret = (PeekConsoleInput((HANDLE)sock, &ir, 1, &n))
);
return ret;
}
static int
is_readable_console(SOCKET sock) /* call this for console only */
{
int ret = 0;
DWORD n = 0;
INPUT_RECORD ir;
RUBY_CRITICAL(
if (PeekConsoleInput((HANDLE)sock, &ir, 1, &n) && n > 0) {
if (ir.EventType == KEY_EVENT && ir.Event.KeyEvent.bKeyDown &&
ir.Event.KeyEvent.uChar.AsciiChar) {
ret = 1;
}
else {
ReadConsoleInput((HANDLE)sock, &ir, 1, &n);
}
}
);
return ret;
}
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(
EnterCriticalSection(&select_mutex);
r = select(nfds, rd, wr, ex, timeout);
LeaveCriticalSection(&select_mutex);
if (r == SOCKET_ERROR) {
errno = map_errno(WSAGetLastError());
r = -1;
}
);
}
return r;
}
static inline int
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 1;
}
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 WSAAPI
rb_w32_select(int nfds, fd_set *rd, fd_set *wr, fd_set *ex,
struct timeval *timeout)
{
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;
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++;
}
}
if (!NtSocketsInitialized) {
StartSockets();
}
// 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(&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(&else_wr);
nonsock += extract_fd(&else_wr, wr, is_not_socket);
rb_fd_init(&except);
extract_fd(&except, ex, is_not_socket); // drop only
r = 0;
if (rd && rd->fd_count > r) r = rd->fd_count;
if (wr && wr->fd_count > r) r = wr->fd_count;
if (ex && ex->fd_count > r) r = ex->fd_count;
if (nfds > r) nfds = r;
{
struct timeval rest;
struct timeval wait;
struct timeval zero;
wait.tv_sec = 0; wait.tv_usec = 10 * 1000; // 10ms
zero.tv_sec = 0; zero.tv_usec = 0; // 0ms
for (;;) {
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?
r = copy_fd(rd, else_rd.fdset);
r += copy_fd(wr, else_wr.fdset);
if (ex)
r += ex->fd_count;
break;
}
else {
struct timeval *dowait = &wait;
fd_set orig_rd;
fd_set orig_wr;
fd_set orig_ex;
if (rd) orig_rd = *rd;
if (wr) orig_wr = *wr;
if (ex) orig_ex = *ex;
r = do_select(nfds, rd, wr, ex, &zero); // polling
if (r != 0) break; // signaled or error
if (rd) *rd = orig_rd;
if (wr) *wr = orig_wr;
if (ex) *ex = orig_ex;
if (timeout) {
struct timeval now;
gettimeofday(&now, NULL);
rest = limit;
if (!subtract(&rest, &now)) break;
if (compare(&rest, &wait) < 0) dowait = &rest;
}
Sleep(dowait->tv_sec * 1000 + dowait->tv_usec / 1000);
}
}
}
rb_fd_term(&except);
rb_fd_term(&else_wr);
rb_fd_term(&cons_rd);
rb_fd_term(&pipe_rd);
rb_fd_term(&else_rd);
return r;
}
#undef accept
int WSAAPI
rb_w32_accept(int s, struct sockaddr *addr, int *addrlen)
{
SOCKET r;
int fd;
if (!NtSocketsInitialized) {
StartSockets();
}
RUBY_CRITICAL({
HANDLE h = CreateFile("NUL", 0, 0, NULL, OPEN_ALWAYS, 0, NULL);
fd = rb_w32_open_osfhandle((intptr_t)h, O_RDWR|O_BINARY|O_NOINHERIT);
if (fd != -1) {
r = accept(TO_SOCKET(s), addr, addrlen);
if (r != INVALID_SOCKET) {
MTHREAD_ONLY(EnterCriticalSection(&(_pioinfo(fd)->lock)));
_set_osfhnd(fd, r);
MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
CloseHandle(h);
st_insert(socklist, (st_data_t)r, (st_data_t)0);
}
else {
errno = map_errno(WSAGetLastError());
close(fd);
fd = -1;
}
}
else
CloseHandle(h);
});
return fd;
}
#undef bind
int WSAAPI
rb_w32_bind(int s, const struct sockaddr *addr, int addrlen)
{
int r;
if (!NtSocketsInitialized) {
StartSockets();
}
RUBY_CRITICAL({
r = bind(TO_SOCKET(s), addr, addrlen);
if (r == SOCKET_ERROR)
errno = map_errno(WSAGetLastError());
});
return r;
}
#undef connect
int WSAAPI
rb_w32_connect(int s, const struct sockaddr *addr, int addrlen)
{
int r;
if (!NtSocketsInitialized) {
StartSockets();
}
RUBY_CRITICAL({
r = connect(TO_SOCKET(s), addr, addrlen);
if (r == SOCKET_ERROR) {
r = WSAGetLastError();
if (r != WSAEWOULDBLOCK) {
errno = map_errno(r);
}
else {
errno = EINPROGRESS;
r = -1;
}
}
});
return r;
}
#undef getpeername
int WSAAPI
rb_w32_getpeername(int s, struct sockaddr *addr, int *addrlen)
{
int r;
if (!NtSocketsInitialized) {
StartSockets();
}
RUBY_CRITICAL({
r = getpeername(TO_SOCKET(s), addr, addrlen);
if (r == SOCKET_ERROR)
errno = map_errno(WSAGetLastError());
});
return r;
}
#undef getsockname
int WSAAPI
rb_w32_getsockname(int s, struct sockaddr *addr, int *addrlen)
{
int r;
if (!NtSocketsInitialized) {
StartSockets();
}
RUBY_CRITICAL({
r = getsockname(TO_SOCKET(s), addr, addrlen);
if (r == SOCKET_ERROR)
errno = map_errno(WSAGetLastError());
});
return r;
}
int WSAAPI
rb_w32_getsockopt(int s, int level, int optname, char *optval, int *optlen)
{
int r;
if (!NtSocketsInitialized) {
StartSockets();
}
RUBY_CRITICAL({
r = getsockopt(TO_SOCKET(s), level, optname, optval, optlen);
if (r == SOCKET_ERROR)
errno = map_errno(WSAGetLastError());
});
return r;
}
#undef ioctlsocket
int WSAAPI
rb_w32_ioctlsocket(int s, long cmd, u_long *argp)
{
int r;
if (!NtSocketsInitialized) {
StartSockets();
}
RUBY_CRITICAL({
r = ioctlsocket(TO_SOCKET(s), cmd, argp);
if (r == SOCKET_ERROR)
errno = map_errno(WSAGetLastError());
});
return r;
}
#undef listen
int WSAAPI
rb_w32_listen(int s, int backlog)
{
int r;
if (!NtSocketsInitialized) {
StartSockets();
}
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
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;
st_data_t data;
DWORD flg;
WSAOVERLAPPED wol;
WSABUF wbuf;
int err;
SOCKET s;
if (!NtSocketsInitialized)
StartSockets();
s = TO_SOCKET(fd);
st_lookup(socklist, (st_data_t)s, &data);
mode = (int)data;
if (!cancel_io || (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);
}
else {
if (addr && addrlen)
r = sendto(s, buf, len, flags, addr, *addrlen);
else
r = send(s, buf, len, flags);
}
if (r == SOCKET_ERROR)
errno = map_errno(WSAGetLastError());
});
}
else {
DWORD size;
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);
}
});
if (ret != SOCKET_ERROR) {
r = size;
}
else if ((err = WSAGetLastError()) == WSA_IO_PENDING) {
switch (rb_w32_wait_events_blocking(&wol.hEvent, 1, INFINITE)) {
case WAIT_OBJECT_0:
RUBY_CRITICAL(
ret = WSAGetOverlappedResult(s, &wol, &size, TRUE, &flg)
);
if (ret) {
r = size;
break;
}
/* thru */
default:
errno = map_errno(err);
/* thru */
case WAIT_OBJECT_0 + 1:
/* interrupted */
r = -1;
cancel_io((HANDLE)s);
break;
}
}
else {
errno = map_errno(err);
r = -1;
}
CloseHandle(&wol.hEvent);
}
return r;
}
int WSAAPI
rb_w32_recv(int fd, char *buf, int len, int flags)
{
return overlapped_socket_io(TRUE, fd, buf, len, flags, NULL, NULL);
}
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);
}
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);
}
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);
}
#undef setsockopt
int WSAAPI
rb_w32_setsockopt(int s, int level, int optname, const char *optval, int optlen)
{
int r;
if (!NtSocketsInitialized) {
StartSockets();
}
RUBY_CRITICAL({
r = setsockopt(TO_SOCKET(s), level, optname, optval, optlen);
if (r == SOCKET_ERROR)
errno = map_errno(WSAGetLastError());
});
return r;
}
#undef shutdown
int WSAAPI
rb_w32_shutdown(int s, int how)
{
int r;
if (!NtSocketsInitialized) {
StartSockets();
}
RUBY_CRITICAL({
r = shutdown(TO_SOCKET(s), how);
if (r == SOCKET_ERROR)
errno = map_errno(WSAGetLastError());
});
return r;
}
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);
}
free(proto_buffers);
}
}
return out;
}
#undef socket
int WSAAPI
rb_w32_socket(int af, int type, int protocol)
{
SOCKET s;
int fd;
if (!NtSocketsInitialized) {
StartSockets();
}
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)
st_insert(socklist, (st_data_t)s, (st_data_t)0);
else
closesocket(s);
}
});
return fd;
}
#undef gethostbyaddr
struct hostent * WSAAPI
rb_w32_gethostbyaddr(const char *addr, int len, int type)
{
struct hostent *r;
if (!NtSocketsInitialized) {
StartSockets();
}
RUBY_CRITICAL({
r = gethostbyaddr(addr, len, type);
if (r == NULL)
errno = map_errno(WSAGetLastError());
});
return r;
}
#undef gethostbyname
struct hostent * WSAAPI
rb_w32_gethostbyname(const char *name)
{
struct hostent *r;
if (!NtSocketsInitialized) {
StartSockets();
}
RUBY_CRITICAL({
r = gethostbyname(name);
if (r == NULL)
errno = map_errno(WSAGetLastError());
});
return r;
}
#undef gethostname
int WSAAPI
rb_w32_gethostname(char *name, int len)
{
int r;
if (!NtSocketsInitialized) {
StartSockets();
}
RUBY_CRITICAL({
r = gethostname(name, len);
if (r == SOCKET_ERROR)
errno = map_errno(WSAGetLastError());
});
return r;
}
#undef getprotobyname
struct protoent * WSAAPI
rb_w32_getprotobyname(const char *name)
{
struct protoent *r;
if (!NtSocketsInitialized) {
StartSockets();
}
RUBY_CRITICAL({
r = getprotobyname(name);
if (r == NULL)
errno = map_errno(WSAGetLastError());
});
return r;
}
#undef getprotobynumber
struct protoent * WSAAPI
rb_w32_getprotobynumber(int num)
{
struct protoent *r;
if (!NtSocketsInitialized) {
StartSockets();
}
RUBY_CRITICAL({
r = getprotobynumber(num);
if (r == NULL)
errno = map_errno(WSAGetLastError());
});
return r;
}
#undef getservbyname
struct servent * WSAAPI
rb_w32_getservbyname(const char *name, const char *proto)
{
struct servent *r;
if (!NtSocketsInitialized) {
StartSockets();
}
RUBY_CRITICAL({
r = getservbyname(name, proto);
if (r == NULL)
errno = map_errno(WSAGetLastError());
});
return r;
}
#undef getservbyport
struct servent * WSAAPI
rb_w32_getservbyport(int port, const char *proto)
{
struct servent *r;
if (!NtSocketsInitialized) {
StartSockets();
}
RUBY_CRITICAL({
r = getservbyport(port, proto);
if (r == NULL)
errno = map_errno(WSAGetLastError());
});
return r;
}
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
struct sockaddr *addr;
int ret = -1;
int len;
if (!NtSocketsInitialized) {
StartSockets();
}
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
default:
errno = EAFNOSUPPORT;
return -1;
}
if (type != SOCK_STREAM) {
errno = EPROTOTYPE;
return -1;
}
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;
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);
});
return ret;
}
int
rb_w32_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;
}
st_insert(socklist, (st_data_t)pair[0], (st_data_t)0);
st_insert(socklist, (st_data_t)pair[1], (st_data_t)0);
return 0;
}
//
// 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) {}
int
fcntl(int fd, int cmd, ...)
{
SOCKET sock = TO_SOCKET(fd);
va_list va;
int arg;
int ret;
int flag = 0;
st_data_t data;
u_long ioctlArg;
if (!is_socket(sock)) {
errno = EBADF;
return -1;
}
if (cmd != F_SETFL) {
errno = EINVAL;
return -1;
}
va_start(va, cmd);
arg = va_arg(va, int);
va_end(va);
st_lookup(socklist, (st_data_t)sock, &data);
flag = (int)data;
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)
st_insert(socklist, (st_data_t)sock, (st_data_t)flag);
else
errno = map_errno(WSAGetLastError());
});
return ret;
}
#ifndef WNOHANG
#define WNOHANG -1
#endif
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 occured, return immediatly. */
err = GetLastError();
if (err == ERROR_INVALID_PARAMETER)
errno = ECHILD;
else {
if (GetLastError() == ERROR_INVALID_HANDLE)
errno = EINVAL;
else
errno = map_errno(GetLastError());
}
CloseChildHandle(child);
return -1;
}
if (exitcode != STILL_ACTIVE) {
/* If already died, return immediatly. */
rb_pid_t pid = child->pid;
CloseChildHandle(child);
if (stat_loc) *stat_loc = exitcode << 8;
return pid;
}
return 0;
}
rb_pid_t
waitpid(rb_pid_t pid, int *stat_loc, int options)
{
DWORD timeout;
if (options == WNOHANG) {
timeout = 0;
} else {
timeout = INFINITE;
}
if (pid == -1) {
int count = 0;
DWORD ret;
HANDLE events[MAXCHILDNUM];
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;
}
return poll_child_status(FindChildSlotByHandle(events[ret]), stat_loc);
}
else {
struct ChildRecord* child = FindChildSlot(pid);
if (!child) {
errno = ECHILD;
return -1;
}
while (!(pid = poll_child_status(child, stat_loc))) {
/* wait... */
if (rb_w32_wait_events_blocking(&child->hProcess, 1, timeout) != WAIT_OBJECT_0) {
/* still active */
pid = 0;
break;
}
}
}
return pid;
}
#include <sys/timeb.h>
static int
filetime_to_timeval(const FILETIME* ft, struct timeval *tv)
{
ULARGE_INTEGER tmp;
unsigned LONG_LONG lt;
tmp.LowPart = ft->dwLowDateTime;
tmp.HighPart = ft->dwHighDateTime;
lt = tmp.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 /= 10; /* to usec */
lt -= (LONG_LONG)((1970-1601)*365.2425) * 24 * 60 * 60 * 1000 * 1000;
tv->tv_sec = lt / (1000 * 1000);
tv->tv_usec = lt % (1000 * 1000);
return tv->tv_sec > 0 ? 0 : -1;
}
int _cdecl
gettimeofday(struct timeval *tv, struct timezone *tz)
{
FILETIME ft;
GetSystemTimeAsFileTime(&ft);
filetime_to_timeval(&ft, tv);
return 0;
}
char *
rb_w32_getcwd(char *buffer, int size)
{
char *p = buffer;
char *bp;
int len;
len = GetCurrentDirectory(0, NULL);
if (!len) {
errno = map_errno(GetLastError());
return NULL;
}
if (p) {
if (size < len) {
errno = ERANGE;
return NULL;
}
}
else {
p = malloc(len);
size = len;
if (!p) {
errno = ENOMEM;
return NULL;
}
}
if (!GetCurrentDirectory(size, p)) {
errno = map_errno(GetLastError());
if (!buffer)
free(p);
return NULL;
}
for (bp = p; *bp != '\0'; bp = CharNext(bp)) {
if (*bp == '\\') {
*bp = '/';
}
}
return p;
}
int
chown(const char *path, int owner, int group)
{
return 0;
}
int
kill(int pid, int sig)
{
int ret = 0;
DWORD err;
if (pid <= 0) {
errno = EINVAL;
return -1;
}
if (IsWin95()) pid = -pid;
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({
if (!GenerateConsoleCtrlEvent(CTRL_C_EVENT, (DWORD)pid)) {
if ((err = GetLastError()) == 0)
errno = EPERM;
else
errno = map_errno(GetLastError());
ret = -1;
}
});
break;
case SIGKILL:
RUBY_CRITICAL({
HANDLE hProc = OpenProcess(PROCESS_TERMINATE, FALSE, (DWORD)pid);
if (hProc == NULL || hProc == INVALID_HANDLE_VALUE) {
if (GetLastError() == ERROR_INVALID_PARAMETER) {
errno = ESRCH;
}
else {
errno = EPERM;
}
ret = -1;
}
else {
if (!TerminateProcess(hProc, 0)) {
errno = EPERM;
ret = -1;
}
CloseHandle(hProc);
}
});
break;
default:
errno = EINVAL;
ret = -1;
break;
}
return ret;
}
int
link(const char *from, const char *to)
{
static BOOL (WINAPI *pCreateHardLink)(LPCTSTR, LPCTSTR, LPSECURITY_ATTRIBUTES) = NULL;
static int myerrno = 0;
if (!pCreateHardLink && !myerrno) {
HANDLE hKernel;
hKernel = GetModuleHandle("kernel32.dll");
if (hKernel) {
pCreateHardLink = (BOOL (WINAPI *)(LPCTSTR, LPCTSTR, LPSECURITY_ATTRIBUTES))GetProcAddress(hKernel, "CreateHardLinkA");
if (!pCreateHardLink) {
rb_notimplement();
}
}
else {
myerrno = map_errno(GetLastError());
}
}
if (!pCreateHardLink) {
errno = myerrno;
return -1;
}
if (!pCreateHardLink(to, from, NULL)) {
errno = map_errno(GetLastError());
return -1;
}
return 0;
}
int
wait(int *status)
{
return waitpid(-1, status, 0);
}
char *
rb_w32_getenv(const char *name)
{
int len = strlen(name);
char *env;
if (envarea)
FreeEnvironmentStrings(envarea);
envarea = GetEnvironmentStrings();
if (!envarea) {
map_errno(GetLastError());
return NULL;
}
for (env = envarea; *env; env += strlen(env) + 1)
if (strncasecmp(env, name, len) == 0 && *(env + len) == '=')
return env + len + 1;
return NULL;
}
int
rb_w32_rename(const char *oldpath, const char *newpath)
{
int res = 0;
int oldatts;
int newatts;
oldatts = GetFileAttributes(oldpath);
newatts = GetFileAttributes(newpath);
if (oldatts == -1) {
errno = map_errno(GetLastError());
return -1;
}
RUBY_CRITICAL({
if (newatts != -1 && newatts & FILE_ATTRIBUTE_READONLY)
SetFileAttributesA(newpath, newatts & ~ FILE_ATTRIBUTE_READONLY);
if (!MoveFile(oldpath, newpath))
res = -1;
if (res) {
switch (GetLastError()) {
case ERROR_ALREADY_EXISTS:
case ERROR_FILE_EXISTS:
if (IsWinNT()) {
if (MoveFileEx(oldpath, newpath, MOVEFILE_REPLACE_EXISTING))
res = 0;
} else {
for (;;) {
if (!DeleteFile(newpath) && GetLastError() != ERROR_FILE_NOT_FOUND)
break;
else if (MoveFile(oldpath, newpath)) {
res = 0;
break;
}
}
}
}
}
if (res)
errno = map_errno(GetLastError());
else
SetFileAttributes(newpath, oldatts);
});
return res;
}
static int
isUNCRoot(const char *path)
{
if (path[0] == '\\' && path[1] == '\\') {
const char *p;
for (p = path + 2; *p; p = CharNext(p)) {
if (*p == '\\')
break;
}
if (p[0] && p[1]) {
for (p++; *p; p = CharNext(p)) {
if (*p == '\\')
break;
}
if (!p[0] || !p[1] || (p[1] == '.' && !p[2]))
return 1;
}
}
return 0;
}
#define COPY_STAT(src, dest) 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 = (src).st_size; \
(dest).st_atime = (src).st_atime; \
(dest).st_mtime = (src).st_mtime; \
(dest).st_ctime = (src).st_ctime; \
} while (0)
#ifdef __BORLANDC__
#undef fstat
int
rb_w32_fstat(int fd, struct stat *st)
{
BY_HANDLE_FILE_INFORMATION info;
int ret = fstat(fd, st);
if (ret) return ret;
st->st_mode &= ~(S_IWGRP | S_IWOTH);
if (GetFileInformationByHandle((HANDLE)_get_osfhandle(fd), &info) &&
!(info.dwFileAttributes & FILE_ATTRIBUTE_READONLY)) {
st->st_mode |= S_IWUSR;
}
return ret;
}
int
rb_w32_fstati64(int fd, struct stati64 *st)
{
BY_HANDLE_FILE_INFORMATION info;
struct stat tmp;
int ret = fstat(fd, &tmp);
if (ret) return ret;
tmp.st_mode &= ~(S_IWGRP | S_IWOTH);
COPY_STAT(tmp, *st);
if (GetFileInformationByHandle((HANDLE)_get_osfhandle(fd), &info)) {
if (!(info.dwFileAttributes & FILE_ATTRIBUTE_READONLY)) {
st->st_mode |= S_IWUSR;
}
st->st_size = ((__int64)info.nFileSizeHigh << 32) | info.nFileSizeLow;
}
return ret;
}
#endif
static time_t
filetime_to_unixtime(const FILETIME *ft)
{
struct timeval tv;
if (filetime_to_timeval(ft, &tv) == (time_t)-1)
return 0;
else
return tv.tv_sec;
}
static unsigned
fileattr_to_unixmode(DWORD attr, const char *path)
{
unsigned mode = 0;
if (attr & FILE_ATTRIBUTE_READONLY) {
mode |= S_IREAD;
}
else {
mode |= S_IREAD | S_IWRITE | S_IWUSR;
}
if (attr & FILE_ATTRIBUTE_DIRECTORY) {
mode |= S_IFDIR | S_IEXEC;
}
else {
mode |= S_IFREG;
}
if (path && (mode & S_IFREG)) {
const char *end = path + strlen(path);
while (path < end) {
end = CharPrev(path, end);
if (*end == '.') {
if ((strcmpi(end, ".bat") == 0) ||
(strcmpi(end, ".cmd") == 0) ||
(strcmpi(end, ".com") == 0) ||
(strcmpi(end, ".exe") == 0)) {
mode |= S_IEXEC;
}
break;
}
}
}
mode |= (mode & 0700) >> 3;
mode |= (mode & 0700) >> 6;
return mode;
}
static int
check_valid_dir(const char *path)
{
WIN32_FIND_DATAW fd;
HANDLE fh = open_dir_handle(path, &fd);
if (fh == INVALID_HANDLE_VALUE)
return -1;
FindClose(fh);
return 0;
}
static int
winnt_stat(const char *path, struct stati64 *st)
{
HANDLE h;
WIN32_FIND_DATA wfd;
memset(st, 0, sizeof(*st));
st->st_nlink = 1;
if (_mbspbrk(path, "?*")) {
errno = ENOENT;
return -1;
}
h = FindFirstFile(path, &wfd);
if (h != INVALID_HANDLE_VALUE) {
FindClose(h);
st->st_mode = fileattr_to_unixmode(wfd.dwFileAttributes, path);
st->st_atime = filetime_to_unixtime(&wfd.ftLastAccessTime);
st->st_mtime = filetime_to_unixtime(&wfd.ftLastWriteTime);
st->st_ctime = filetime_to_unixtime(&wfd.ftCreationTime);
st->st_size = ((__int64)wfd.nFileSizeHigh << 32) | wfd.nFileSizeLow;
}
else {
// If runtime stat(2) is called for network shares, it fails on WinNT.
// Because GetDriveType returns 1 for network shares. (Win98 returns 4)
DWORD attr = GetFileAttributes(path);
if (attr == -1) {
errno = map_errno(GetLastError());
return -1;
}
if (attr & FILE_ATTRIBUTE_DIRECTORY) {
if (check_valid_dir(path)) return -1;
}
st->st_mode = fileattr_to_unixmode(attr, path);
}
st->st_dev = st->st_rdev = (isalpha(path[0]) && path[1] == ':') ?
toupper(path[0]) - 'A' : _getdrive() - 1;
return 0;
}
#ifdef WIN95
static int
win95_stat(const char *path, struct stati64 *st)
{
int ret = stati64(path, st);
if (ret) return ret;
if (st->st_mode & S_IFDIR) {
return check_valid_dir(path);
}
return 0;
}
#else
#define win95_stat(path, st) -1
#endif
int
rb_w32_stat(const char *path, struct stat *st)
{
struct stati64 tmp;
if (rb_w32_stati64(path, &tmp)) return -1;
COPY_STAT(tmp, *st);
return 0;
}
int
rb_w32_stati64(const char *path, struct stati64 *st)
{
const char *p;
char *buf1, *s, *end;
int len, size;
int ret;
if (!path || !st) {
errno = EFAULT;
return -1;
}
size = strlen(path) + 2;
buf1 = ALLOCA_N(char, size);
for (p = path, s = buf1; *p; p++, s++) {
if (*p == '/')
*s = '\\';
else
*s = *p;
}
*s = '\0';
len = s - buf1;
if (!len || '\"' == *(--s)) {
errno = ENOENT;
return -1;
}
end = CharPrev(buf1, buf1 + len);
if (isUNCRoot(buf1)) {
if (*end == '.')
*end = '\0';
else if (*end != '\\')
strlcat(buf1, "\\", size);
}
else if (*end == '\\' || (buf1 + 1 == end && *end == ':'))
strlcat(buf1, ".", size);
ret = IsWinNT() ? winnt_stat(buf1, st) : win95_stat(buf1, st);
if (ret == 0) {
st->st_mode &= ~(S_IWGRP | S_IWOTH);
}
return ret;
}
static int
rb_chsize(HANDLE h, off_t size)
{
long upos, lpos, usize, lsize, uend, lend;
off_t end;
int ret = -1;
DWORD e;
if (((lpos = SetFilePointer(h, 0, (upos = 0, &upos), SEEK_CUR)) == -1L &&
(e = GetLastError())) ||
((lend = GetFileSize(h, (DWORD *)&uend)) == -1L && (e = GetLastError()))) {
errno = map_errno(e);
return -1;
}
end = ((off_t)uend << 32) | (unsigned long)lend;
usize = (long)(size >> 32);
lsize = (long)size;
if (SetFilePointer(h, lsize, &usize, SEEK_SET) == -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;
}
int
truncate(const char *path, off_t length)
{
HANDLE h;
int ret;
if (IsWin95()) {
int fd = open(path, O_WRONLY), e = 0;
if (fd == -1) return -1;
ret = chsize(fd, (unsigned long)length);
if (ret == -1) e = errno;
close(fd);
if (ret == -1) errno = e;
return ret;
}
h = CreateFile(path, GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);
if (h == INVALID_HANDLE_VALUE) {
errno = map_errno(GetLastError());
return -1;
}
ret = rb_chsize(h, length);
CloseHandle(h);
return ret;
}
int
ftruncate(int fd, off_t length)
{
long h;
if (IsWin95()) {
return chsize(fd, (unsigned long)length);
}
h = _get_osfhandle(fd);
if (h == -1) return -1;
return rb_chsize((HANDLE)h, length);
}
#ifdef __BORLANDC__
off_t
_filelengthi64(int fd)
{
DWORD u, l;
int e;
l = GetFileSize((HANDLE)_get_osfhandle(fd), &u);
if (l == (DWORD)-1L && (e = GetLastError())) {
errno = map_errno(e);
return (off_t)-1;
}
return ((off_t)u << 32) | l;
}
off_t
_lseeki64(int fd, off_t offset, int whence)
{
long u, l;
int e;
HANDLE h = (HANDLE)_get_osfhandle(fd);
if (!h) {
errno = EBADF;
return -1;
}
u = (long)(offset >> 32);
if ((l = SetFilePointer(h, (long)offset, &u, whence)) == -1L &&
(e = GetLastError())) {
errno = map_errno(e);
return -1;
}
return ((off_t)u << 32) | l;
}
#endif
int
fseeko(FILE *stream, off_t offset, int whence)
{
off_t pos;
switch (whence) {
case SEEK_CUR:
if (fgetpos(stream, (fpos_t *)&pos))
return -1;
pos += offset;
break;
case SEEK_END:
if ((pos = _filelengthi64(fileno(stream))) == (off_t)-1)
return -1;
pos += offset;
break;
default:
pos = offset;
break;
}
return fsetpos(stream, (fpos_t *)&pos);
}
off_t
ftello(FILE *stream)
{
off_t pos;
if (fgetpos(stream, (fpos_t *)&pos)) return (off_t)-1;
return pos;
}
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;
}
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;
}
#define yield_once() Sleep(0)
#define yield_until(condition) do yield_once(); while (!(condition))
static void
catch_interrupt(void)
{
yield_once();
RUBY_CRITICAL(rb_w32_wait_events(NULL, 0, 0));
}
#if defined __BORLANDC__
#undef read
int
read(int fd, void *buf, size_t size)
{
int ret = _read(fd, buf, size);
if ((ret < 0) && (errno == EPIPE)) {
errno = 0;
ret = 0;
}
catch_interrupt();
return ret;
}
#endif
#undef fgetc
int
rb_w32_getc(FILE* stream)
{
int c;
if (enough_to_get(stream->FILE_COUNT)) {
c = (unsigned char)*stream->FILE_READPTR++;
}
else
{
c = _filbuf(stream);
#if defined __BORLANDC__
if ((c == EOF) && (errno == EPIPE)) {
clearerr(stream);
}
#endif
catch_interrupt();
}
return c;
}
#undef fputc
int
rb_w32_putc(int c, FILE* stream)
{
if (enough_to_put(stream->FILE_COUNT)) {
c = (unsigned char)(*stream->FILE_READPTR++ = (char)c);
}
else
{
c = _flsbuf(c, stream);
catch_interrupt();
}
return c;
}
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;
};
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;
}
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;
}
char **
rb_w32_get_environ(void)
{
char *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.
* (U.N. 2001-11-15)
*/
envtop = GetEnvironmentStrings();
for (env = envtop, num = 0; *env; env += strlen(env) + 1)
if (*env != '=') num++;
myenvtop = (char **)malloc(sizeof(char *) * (num + 1));
for (env = envtop, myenv = myenvtop; *env; env += strlen(env) + 1) {
if (*env != '=') {
if (!(*myenv = strdup(env))) {
break;
}
myenv++;
}
}
*myenv = NULL;
FreeEnvironmentStrings(envtop);
return myenvtop;
}
void
rb_w32_free_environ(char **env)
{
char **t = env;
while (*t) free(*t++);
free(env);
}
#undef getpid
rb_pid_t
rb_w32_getpid(void)
{
rb_pid_t pid;
pid = getpid();
if (IsWin95()) pid = -pid;
return pid;
}
rb_pid_t
rb_w32_getppid(void)
{
static long (WINAPI *pNtQueryInformationProcess)(HANDLE, int, void *, ULONG, ULONG *) = NULL;
rb_pid_t ppid = 0;
if (!IsWin95() && rb_w32_osver() >= 5) {
if (!pNtQueryInformationProcess) {
HANDLE hNtDll = GetModuleHandle("ntdll.dll");
if (hNtDll) {
pNtQueryInformationProcess = (long (WINAPI *)(HANDLE, int, void *, ULONG, ULONG *))GetProcAddress(hNtDll, "NtQueryInformationProcess");
}
}
if (pNtQueryInformationProcess) {
struct {
long ExitStatus;
void* PebBaseAddress;
ULONG AffinityMask;
ULONG BasePriority;
ULONG UniqueProcessId;
ULONG ParentProcessId;
} pbi;
ULONG len;
long ret = pNtQueryInformationProcess(GetCurrentProcess(), 0, &pbi, sizeof(pbi), &len);
if (!ret) {
ppid = pbi.ParentProcessId;
}
}
}
return ppid;
}
int
rb_w32_open(const char *file, int oflag, ...)
{
UINT cp = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
int len;
WCHAR *wfile;
int pmode;
va_list arg;
va_start(arg, oflag);
pmode = va_arg(arg, int);
va_end(arg);
if ((oflag & O_TEXT) || !(oflag & ~O_BINARY)) {
return _open(file, oflag, pmode);
}
len = MultiByteToWideChar(cp, 0, file, -1, NULL, 0);
if (len <= 0) {
errno = map_errno(GetLastError());
return -1;
}
wfile = ALLOCA_N(WCHAR, len);
MultiByteToWideChar(cp, 0, file, -1, wfile, len);
if (len <= 0) {
errno = map_errno(GetLastError());
return -1;
}
return rb_w32_wopen(wfile, oflag, pmode);
}
int
rb_w32_wopen(const WCHAR *file, int oflag, ...)
{
char flags = 0;
int fd;
DWORD access;
DWORD create;
DWORD attr = FILE_ATTRIBUTE_NORMAL;
SECURITY_ATTRIBUTES sec;
HANDLE h;
if ((oflag & O_TEXT) || !(oflag & ~O_BINARY)) {
va_list arg;
int pmode;
va_start(arg, oflag);
pmode = va_arg(arg, int);
va_end(arg);
return _wopen(file, oflag, pmode);
}
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) {
va_list arg;
int pmode;
va_start(arg, oflag);
pmode = va_arg(arg, int);
va_end(arg);
/* 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((long)h, 0);
CloseHandle(h);
});
if (fd == -1) {
errno = EMFILE;
return -1;
}
RUBY_CRITICAL({
MTHREAD_ONLY(EnterCriticalSection(&(_pioinfo(fd)->lock)));
_set_osfhnd(fd, (long)INVALID_HANDLE_VALUE);
_set_osflags(fd, 0);
/* open with FILE_FLAG_OVERLAPPED if have CancelIo */
if (cancel_io)
attr |= FILE_FLAG_OVERLAPPED;
h = CreateFileW(file, access, FILE_SHARE_READ | FILE_SHARE_WRITE, &sec,
create, attr, NULL);
if (h == INVALID_HANDLE_VALUE) {
errno = map_errno(GetLastError());
MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
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);
MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
fd = -1;
goto quit;
}
if (!(flags & (FDEV | FPIPE)) && (oflag & O_APPEND))
flags |= FAPPEND;
_set_osfhnd(fd, (long)h);
_osfile(fd) = flags | FOPEN;
MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
quit:
;
});
return fd;
}
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;
}
int
rb_w32_pipe(int fds[2])
{
static DWORD serial = 0;
char name[] = "\\\\.\\pipe\\ruby0000000000000000-0000000000000000";
char *p;
SECURITY_ATTRIBUTES sec;
HANDLE hRead, hWrite, h;
int fdRead, fdWrite;
int ret;
/* if doesn't have CancelIo, use default pipe function */
if (!cancel_io)
return _pipe(fds, 65536L, _O_NOINHERIT);
p = strchr(name, '0');
snprintf(p, strlen(p) + 1, "%x-%lx", rb_w32_getpid(), serial++);
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((long)h, 0);
CloseHandle(h);
if (fdRead == -1) {
errno = EMFILE;
CloseHandle(hWrite);
CloseHandle(hRead);
ret = -1;
break;
}
MTHREAD_ONLY(EnterCriticalSection(&(_pioinfo(fdRead)->lock)));
_set_osfhnd(fdRead, (long)hRead);
_set_osflags(fdRead, FOPEN | FPIPE | FNOINHERIT);
MTHREAD_ONLY(LeaveCriticalSection(&(_pioinfo(fdRead)->lock)));
} while (0));
if (ret)
return ret;
RUBY_CRITICAL(do {
h = CreateFile("NUL", 0, 0, NULL, OPEN_ALWAYS, 0, NULL);
fdWrite = _open_osfhandle((long)h, 0);
CloseHandle(h);
if (fdWrite == -1) {
errno = EMFILE;
CloseHandle(hWrite);
ret = -1;
break;
}
MTHREAD_ONLY(EnterCriticalSection(&(_pioinfo(fdWrite)->lock)));
_set_osfhnd(fdWrite, (long)hWrite);
_set_osflags(fdWrite, FOPEN | FPIPE | FNOINHERIT);
MTHREAD_ONLY(LeaveCriticalSection(&(_pioinfo(fdWrite)->lock)));
} while (0));
if (ret) {
rb_w32_close(fdRead);
return ret;
}
fds[0] = fdRead;
fds[1] = fdWrite;
return 0;
}
int
rb_w32_close(int fd)
{
SOCKET sock = TO_SOCKET(fd);
int save_errno = errno;
st_data_t key;
if (!is_socket(sock)) {
UnlockFile((HANDLE)sock, 0, 0, LK_LEN, LK_LEN);
return _close(fd);
}
_set_osfhnd(fd, (SOCKET)INVALID_HANDLE_VALUE);
key = (st_data_t)sock;
st_delete(socklist, &key, NULL);
sock = (SOCKET)key;
_close(fd);
errno = save_errno;
if (closesocket(sock) == SOCKET_ERROR) {
errno = map_errno(WSAGetLastError());
return -1;
}
return 0;
}
#undef read
size_t
rb_w32_read(int fd, void *buf, size_t size)
{
SOCKET sock = TO_SOCKET(fd);
DWORD read;
DWORD wait;
DWORD err;
OVERLAPPED ol, *pol = NULL;
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 (_osfile(fd) & FTEXT) {
return _read(fd, buf, size);
}
MTHREAD_ONLY(EnterCriticalSection(&(_pioinfo(fd)->lock)));
if (!size || _osfile(fd) & FEOFLAG) {
MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
return 0;
}
/* if have cancel_io, use Overlapped I/O */
if (cancel_io) {
memset(&ol, 0, sizeof(ol));
if (!(_osfile(fd) & (FDEV | FPIPE))) {
LONG high = 0;
DWORD low = SetFilePointer((HANDLE)_osfhnd(fd), 0, &high,
FILE_CURRENT);
#ifndef INVALID_SET_FILE_POINTER
#define INVALID_SET_FILE_POINTER ((DWORD)-1)
#endif
if (low == INVALID_SET_FILE_POINTER) {
errno = map_errno(GetLastError());
MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
return -1;
}
ol.Offset = low;
ol.OffsetHigh = high;
}
ol.hEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
if (!ol.hEvent) {
errno = map_errno(GetLastError());
MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
return -1;
}
pol = &ol;
}
if (!ReadFile((HANDLE)_osfhnd(fd), buf, size, &read, pol)) {
err = GetLastError();
if (err != ERROR_IO_PENDING) {
if (err == ERROR_ACCESS_DENIED)
errno = EBADF;
else if (err == ERROR_BROKEN_PIPE || err == ERROR_HANDLE_EOF) {
MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
return 0;
}
else
errno = map_errno(err);
MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
return -1;
}
if (pol) {
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);
cancel_io((HANDLE)_osfhnd(fd));
MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
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);
cancel_io((HANDLE)_osfhnd(fd));
MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
return ret;
}
}
}
if (pol) {
CloseHandle(ol.hEvent);
if (!(_osfile(fd) & (FDEV | FPIPE))) {
LONG high = ol.OffsetHigh;
LONG low = ol.Offset + read;
if (low < ol.Offset)
++high;
SetFilePointer((HANDLE)_osfhnd(fd), low, &high, FILE_BEGIN);
}
}
MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
return read;
}
#undef write
size_t
rb_w32_write(int fd, const void *buf, size_t size)
{
SOCKET sock = TO_SOCKET(fd);
DWORD written;
DWORD wait;
DWORD err;
size_t len;
size_t ret;
OVERLAPPED ol, *pol = NULL;
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 (_osfile(fd) & FTEXT) {
return _write(fd, buf, size);
}
MTHREAD_ONLY(EnterCriticalSection(&(_pioinfo(fd)->lock)));
if (!size || _osfile(fd) & FEOFLAG) {
MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
return 0;
}
ret = 0;
retry:
/* get rid of console writing bug */
len = (_osfile(fd) & FDEV) ? min(32 * 1024, size) : size;
size -= len;
/* if have cancel_io, use Overlapped I/O */
if (cancel_io) {
memset(&ol, 0, sizeof(ol));
if (!(_osfile(fd) & (FDEV | FPIPE))) {
LONG high = 0;
DWORD method = _osfile(fd) & FAPPEND ? FILE_END : FILE_CURRENT;
DWORD low = SetFilePointer((HANDLE)_osfhnd(fd), 0, &high, method);
#ifndef INVALID_SET_FILE_POINTER
#define INVALID_SET_FILE_POINTER ((DWORD)-1)
#endif
if (low == INVALID_SET_FILE_POINTER) {
errno = map_errno(GetLastError());
MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
return -1;
}
ol.Offset = low;
ol.OffsetHigh = high;
}
ol.hEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
if (!ol.hEvent) {
errno = map_errno(GetLastError());
MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
return -1;
}
pol = &ol;
}
if (!WriteFile((HANDLE)_osfhnd(fd), buf, len, &written, pol)) {
err = GetLastError();
if (err != ERROR_IO_PENDING) {
if (err == ERROR_ACCESS_DENIED)
errno = EBADF;
else
errno = map_errno(err);
MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
return -1;
}
if (pol) {
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);
cancel_io((HANDLE)_osfhnd(fd));
MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
return -1;
}
if (!GetOverlappedResult((HANDLE)_osfhnd(fd), &ol, &written,
TRUE)) {
errno = map_errno(err);
CloseHandle(ol.hEvent);
cancel_io((HANDLE)_osfhnd(fd));
MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
return -1;
}
}
}
if (pol) {
CloseHandle(ol.hEvent);
if (!(_osfile(fd) & (FDEV | FPIPE))) {
LONG high = ol.OffsetHigh;
LONG low = ol.Offset + written;
if (low < ol.Offset)
++high;
SetFilePointer((HANDLE)_osfhnd(fd), low, &high, FILE_BEGIN);
}
}
ret += written;
if (written == len) {
buf = (const char *)buf + len;
if (size > 0)
goto retry;
}
MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
return ret;
}
static int
unixtime_to_filetime(time_t time, FILETIME *ft)
{
struct tm *tm;
SYSTEMTIME st;
FILETIME lt;
tm = localtime(&time);
st.wYear = tm->tm_year + 1900;
st.wMonth = tm->tm_mon + 1;
st.wDayOfWeek = tm->tm_wday;
st.wDay = tm->tm_mday;
st.wHour = tm->tm_hour;
st.wMinute = tm->tm_min;
st.wSecond = tm->tm_sec;
st.wMilliseconds = 0;
if (!SystemTimeToFileTime(&st, &lt) ||
!LocalFileTimeToFileTime(&lt, ft)) {
errno = map_errno(GetLastError());
return -1;
}
return 0;
}
int
rb_w32_utime(const char *path, const struct utimbuf *times)
{
HANDLE hFile;
FILETIME atime, mtime;
struct stati64 stat;
int ret = 0;
if (rb_w32_stati64(path, &stat)) {
return -1;
}
if (times) {
if (unixtime_to_filetime(times->actime, &atime)) {
return -1;
}
if (unixtime_to_filetime(times->modtime, &mtime)) {
return -1;
}
}
else {
GetSystemTimeAsFileTime(&atime);
mtime = atime;
}
RUBY_CRITICAL({
const DWORD attr = GetFileAttributes(path);
if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY))
SetFileAttributes(path, attr & ~FILE_ATTRIBUTE_READONLY);
hFile = CreateFile(path, GENERIC_WRITE, 0, 0, OPEN_EXISTING,
IsWin95() ? 0 : FILE_FLAG_BACKUP_SEMANTICS, 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))
SetFileAttributes(path, attr);
});
return ret;
}
int
rb_w32_mkdir(const char *path, int mode)
{
int ret = -1;
RUBY_CRITICAL(do {
if (CreateDirectory(path, NULL) == FALSE) {
errno = map_errno(GetLastError());
break;
}
if (chmod(path, mode) == -1) {
RemoveDirectory(path);
break;
}
ret = 0;
} while (0));
return ret;
}
int
rb_w32_rmdir(const char *path)
{
int ret = 0;
RUBY_CRITICAL({
const DWORD attr = GetFileAttributes(path);
if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY)) {
SetFileAttributes(path, attr & ~FILE_ATTRIBUTE_READONLY);
}
if (RemoveDirectory(path) == FALSE) {
errno = map_errno(GetLastError());
ret = -1;
if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY)) {
SetFileAttributes(path, attr);
}
}
});
return ret;
}
int
rb_w32_unlink(const char *path)
{
int ret = 0;
RUBY_CRITICAL({
const DWORD attr = GetFileAttributes(path);
if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY)) {
SetFileAttributes(path, attr & ~FILE_ATTRIBUTE_READONLY);
}
if (DeleteFile(path) == FALSE) {
errno = map_errno(GetLastError());
ret = -1;
if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY)) {
SetFileAttributes(path, attr);
}
}
});
return ret;
}
#if !defined(__BORLANDC__)
int
rb_w32_isatty(int fd)
{
// validate fd by using _get_osfhandle() because we cannot access _nhandle
if (_get_osfhandle(fd) == -1) {
return 0;
}
if (!(_osfile(fd) & FDEV)) {
errno = ENOTTY;
return 0;
}
return 1;
}
#endif
//
// Fix bcc32's stdio bug
//
#ifdef __BORLANDC__
static int
too_many_files(void)
{
FILE *f;
for (f = _streams; f < _streams + _nfile; f++) {
if (f->fd < 0) return 0;
}
return 1;
}
#undef fopen
FILE *
rb_w32_fopen(const char *path, const char *mode)
{
FILE *f = (errno = 0, fopen(path, mode));
if (f == NULL && errno == 0) {
if (too_many_files())
errno = EMFILE;
}
return f;
}
FILE *
rb_w32_fdopen(int handle, const char *type)
{
FILE *f = (errno = 0, _fdopen(handle, (char *)type));
if (f == NULL && errno == 0) {
if (handle < 0)
errno = EBADF;
else if (too_many_files())
errno = EMFILE;
}
return f;
}
FILE *
rb_w32_fsopen(const char *path, const char *mode, int shflags)
{
FILE *f = (errno = 0, _fsopen(path, mode, shflags));
if (f == NULL && errno == 0) {
if (too_many_files())
errno = EMFILE;
}
return f;
}
#endif
View git blame Copy permalink