From fcbf63e62c627deae76c1b8cb8c0876c536ed811 Mon Sep 17 00:00:00 2001 From: Jari Vetoniemi Date: Mon, 16 Mar 2020 18:49:26 +0900 Subject: Fresh start --- jni/ruby/win32/Makefile.sub | 1174 +++++++ jni/ruby/win32/README.win32 | 141 + jni/ruby/win32/configure.bat | 216 ++ jni/ruby/win32/dir.h | 45 + jni/ruby/win32/enc-setup.mak | 10 + jni/ruby/win32/file.c | 682 ++++ jni/ruby/win32/ifchange.bat | 95 + jni/ruby/win32/makedirs.bat | 3 + jni/ruby/win32/mkexports.rb | 172 + jni/ruby/win32/resource.rb | 97 + jni/ruby/win32/rm.bat | 18 + jni/ruby/win32/rmdirs.bat | 29 + jni/ruby/win32/rtname.cmd | 18 + jni/ruby/win32/setup.mak | 213 ++ jni/ruby/win32/stub.c | 42 + jni/ruby/win32/win32.c | 7274 ++++++++++++++++++++++++++++++++++++++++++ jni/ruby/win32/winmain.c | 10 + 17 files changed, 10239 insertions(+) create mode 100644 jni/ruby/win32/Makefile.sub create mode 100644 jni/ruby/win32/README.win32 create mode 100755 jni/ruby/win32/configure.bat create mode 100644 jni/ruby/win32/dir.h create mode 100644 jni/ruby/win32/enc-setup.mak create mode 100644 jni/ruby/win32/file.c create mode 100755 jni/ruby/win32/ifchange.bat create mode 100755 jni/ruby/win32/makedirs.bat create mode 100755 jni/ruby/win32/mkexports.rb create mode 100755 jni/ruby/win32/resource.rb create mode 100755 jni/ruby/win32/rm.bat create mode 100755 jni/ruby/win32/rmdirs.bat create mode 100644 jni/ruby/win32/rtname.cmd create mode 100644 jni/ruby/win32/setup.mak create mode 100644 jni/ruby/win32/stub.c create mode 100644 jni/ruby/win32/win32.c create mode 100644 jni/ruby/win32/winmain.c (limited to 'jni/ruby/win32') diff --git a/jni/ruby/win32/Makefile.sub b/jni/ruby/win32/Makefile.sub new file mode 100644 index 0000000..668f9e1 --- /dev/null +++ b/jni/ruby/win32/Makefile.sub @@ -0,0 +1,1174 @@ +# -*- makefile -*- + +SHELL = $(COMSPEC) +ECHO1 = $(V:1=@:) +RUNCMD = $(COMSPEC) /c +MKFILES = Makefile verconf.mk +NULL = nul +CHDIR = cd +PATH_SEPARATOR = ; +TZ = # skip timezone tests +PWD = $(MAKEDIR) + +!ifndef MFLAGS +MFLAGS=-l +!endif + +!ifndef CROSS_COMPILING +CROSS_COMPILING = no +!endif +!ifndef LARGEFILE_SUPPORT +LARGEFILE_SUPPORT = 1 +!endif +!ifndef win_srcdir +win_srcdir = $(srcdir)/win32 +!endif + +#### Start of system configuration section. #### + +!if defined(pathlist) +PATH = $(pathlist:;=/bin;)$(PATH) +INCLUDE = $(pathlist:;=/include;) +LIB = $(pathlist:;=/lib;) +!endif + +## variables may be overridden by $(compile_dir)/Makefile +!ifndef srcdir +srcdir = .. +!endif +!ifndef RUBY_BASE_NAME +RUBY_BASE_NAME = ruby +!endif +!ifndef RUBY_INSTALL_NAME +RUBY_INSTALL_NAME = $(PROGRAM_PREFIX)$(RUBY_BASE_NAME)$(PROGRAM_SUFFIX) +!endif +!if !defined(RUBYW_INSTALL_NAME) || "$(RUBYW_INSTALL_NAME)" == "$(RUBY_INSTALL_NAME)" +RUBYW_INSTALL_NAME = $(RUBY_INSTALL_NAME:ruby=rubyw) +!endif +!if "$(RUBYW_INSTALL_NAME)" == "$(RUBY_INSTALL_NAME)" +RUBYW_INSTALL_NAME = $(RUBY_INSTALL_NAME)w +!endif +STUBPROGRAM = rubystub$(EXEEXT) +!if !defined(icondirs) && defined(ICONDIRS) +icondirs=$(ICONDIRS) +!endif +!if defined(icondirs) +icondirs=$(icondirs:\=/) +iconinc=-I$(icondirs: = -I) +!endif +############### + +.SUFFIXES: .def .lib + +!if !defined(CC) +CC = cl +!endif +!if !defined(CPP) || "$(CPP)" == "cl" +CPP = $(CC) -E +!endif +!if !defined(YACC) +YACC = bison +!endif +AR = lib -nologo +PURIFY = +AUTOCONF = autoconf +IFCHANGE = $(COMSPEC) /C $(srcdir:/=\)\win32\ifchange.bat +RM = $(COMSPEC) /C $(srcdir:/=\)\win32\rm.bat +RMDIR = $(COMSPEC) /C $(srcdir:/=\)\win32\rmdirs.bat +RMDIRS = $(COMSPEC) /C $(srcdir:/=\)\win32\rmdirs.bat +RMALL = $(COMSPEC) /C $(srcdir:/=\)\win32\rm.bat -r +MAKEDIRS = $(COMSPEC) /E:ON /C $(srcdir:/=\)\win32\makedirs.bat +CP = copy > nul +MV = move > nul +!if !defined(BASERUBY) +BASERUBY = ruby +!endif +!if !defined(TEST_RUNNABLE) +TEST_RUNNABLE = yes +!endif + +!if !defined(MACHINE) +MACHINE = x86 +!endif +!if "$(MACHINE)" == "x86" +!if !defined(PROCESSOR_LEVEL) +PROCESSOR_LEVEL = 5 +!endif +!if 6 < $(PROCESSOR_LEVEL) +PROCESSOR_LEVEL = 6 +!endif +!if $(MSC_VER) < 1400 +PROCESSOR_FLAG = -G$(PROCESSOR_LEVEL) +!endif +CPU = i$(PROCESSOR_LEVEL)86 +ARCH = i386 +!else +CPU = $(MACHINE) +ARCH = $(MACHINE) +!endif +!if !defined(DEBUGFLAGS) +DEBUGFLAGS = -Zi +!endif +!if !defined(OPTFLAGS) +!if $(MSC_VER) < 1400 +OPTFLAGS = -O2b2xg- +!else +OPTFLAGS = -O2sy- +!endif +!endif +!if !defined(PLATFORM) +PLATFORM = mswin32 +!endif +!if !defined(RT) +!error RT not defined. Retry from configure pass. +!endif +!ifdef NTVER +ARCHDEFS = -D_WIN32_WINNT=$(NTVER) $(ARCHDEFS) +!endif +!if !defined(PLATFORM_DIR) +PLATFORM_DIR = win32 +!endif + +arch = $(ARCH)-$(PLATFORM) +sitearch = $(ARCH)-$(RT) +!if !defined(ruby_version) +ruby_version = $(MAJOR).$(MINOR).$(TEENY) +!endif + +!ifndef RUBY_SO_NAME +RUBY_SO_NAME = $(RT)-$(RUBY_BASE_NAME)$(MAJOR)$(MINOR)$(TEENY) +!if "$(ARCH)" != "i386" +RUBY_SO_NAME = $(ARCH)-$(RUBY_SO_NAME) +!endif +!endif +!ifndef RUBY_PLATFORM +RUBY_PLATFORM = $(arch) +!endif + +!if !defined(prefix) +prefix = /usr +!endif +!if !defined(exec_prefix) +exec_prefix = $(prefix) +!endif +!if !defined(libdir) +libdir = $(exec_prefix)/lib +!endif +!if !defined(datadir) +datadir = $(prefix)/share +!endif +!ifndef EXTOUT +EXTOUT = .ext +!endif +!ifndef TESTUI +TESTUI = console +!endif +!ifndef TESTS +TESTS = +!endif +!ifndef CAPITARGET +! ifdef DOXYGEN +CAPITARGET = capi +! else +CAPITARGET = nodoc +! endif +!endif +!ifndef DOCTARGETS +! if "$(RDOCTARGET)" == "rdoc" || "$(RDOCTARGET)" == "" +DOCTARGETS = $(DOCTARGETS) rdoc +! endif +! if "$(CAPITARGET)" == "capi" +DOCTARGETS = $(DOCTARGETS) capi +! endif +!endif +!ifndef INSTALLDOC +! if "$(DOCTARGETS)" != "" +INSTALLDOC = all +! else +INSTALLDOC = nodoc +DOCTARGETS = nodoc +! endif +!endif + +OUTFLAG = -Fe +COUTFLAG = -Fo +!if !defined(RUNTIMEFLAG) +RUNTIMEFLAG = -MD +!endif +!if !defined(COMPILERFLAG) +COMPILERFLAG = -Zm600 +!endif +!if !defined(WARNFLAGS) +!if $(MSC_VER) >= 1400 +WARNFLAGS = -W2 -wd4996 -we4028 -we4142 +!else +WARNFLAGS = -W2 +!endif +!endif +WERRORFLAG = -WX +!if !defined(CFLAGS) +CFLAGS = $(RUNTIMEFLAG) $(DEBUGFLAGS) $(WARNFLAGS) $(OPTFLAGS) $(PROCESSOR_FLAG) $(COMPILERFLAG) +!endif +!if !defined(CXXFLAGS) +CXXFLAGS = $(CFLAGS) +!endif +!if !defined(LDFLAGS) +LDFLAGS = -incremental:no -debug -opt:ref -opt:icf +!endif +!if !defined(XLDFLAGS) +XLDFLAGS = -stack:$(STACK) +!endif +!if !defined(RFLAGS) +RFLAGS = -r +!endif +!if !defined(EXTLIBS) +EXTLIBS = +!endif +!if !defined(EXTSOLIBS) +EXTSOLIBS = +!endif +!if !defined(LIBS) +LIBS = user32.lib advapi32.lib shell32.lib ws2_32.lib +!if $(MSC_VER) >= 1400 +LIBS = $(LIBS) iphlpapi.lib +!endif +LIBS = $(LIBS) imagehlp.lib shlwapi.lib $(EXTLIBS) +!endif +!if !defined(MISSING) +MISSING = crypt.obj ffs.obj langinfo.obj lgamma_r.obj strlcat.obj strlcpy.obj win32/win32.obj win32/file.obj setproctitle.obj +!if $(RT_VER) < 120 +MISSING = $(MISSING) acosh.obj cbrt.obj erf.obj tgamma.obj +!endif +!endif +DLNOBJ = dln.obj + +ARFLAGS = -machine:$(MACHINE) -out: +CC = $(CC) -nologo +LD = $(CC) +LDSHARED = $(LD) -LD +XCFLAGS = -DRUBY_EXPORT -I. -I$(arch_hdrdir) -I$(hdrdir) -I$(srcdir) -I$(srcdir)/missing $(XCFLAGS) +!if $(MSC_VER) >= 1400 +# Prevents VC++ 2005 (cl ver 14) warnings +MANIFESTTOOL = mt -nologo +LDSHARED_0 = @if exist $(@).manifest $(MINIRUBY) -run -e wait_writable -- -n 10 $@ +LDSHARED_1 = @if exist $(@).manifest $(MANIFESTTOOL) -manifest $(@).manifest -outputresource:$(@);2 +LDSHARED_2 = @if exist $(@).manifest @$(RM) $(@:/=\).manifest +!endif +CPPFLAGS = $(DEFS) $(ARCHDEFS) $(CPPFLAGS) + +DLDFLAGS = $(LDFLAGS) -dll +SOLIBS = +RCFILES = $(RUBY_INSTALL_NAME).rc $(RUBYW_INSTALL_NAME).rc $(RUBY_SO_NAME).rc +!ifndef RCFLAGS +!if $(MSC_VER) >= 1600 +RCFLAGS=-nologo +!endif +!endif + +LIBRUBY_LDSHARED = $(LDSHARED) +LIBRUBY_DLDFLAGS = $(EXTLDFLAGS) -implib:dummy.lib -def:$(RUBYDEF) + +EXEEXT = .exe +EXECUTABLE_EXTS = ".exe",".com",".cmd",".bat" +!if !defined(PROGRAM) +PROGRAM=$(RUBY_INSTALL_NAME)$(EXEEXT) +!endif +!if !defined(WPROGRAM) && defined(RUBYW_INSTALL_NAME) +WPROGRAM=$(RUBYW_INSTALL_NAME)$(EXEEXT) +!endif +RUBYDEF = $(RUBY_SO_NAME).def +!if "$(CROSS_COMPILING)" == "yes" +MINIRUBY = $(RUBY) -I$(MAKEDIR) -r$(arch)-fake +RUNRUBY = $(MINIRUBY) +!else +MINIRUBY = .\miniruby$(EXEEXT) -I$(srcdir)/lib -I. +RUNRUBY = .\$(PROGRAM) -I$(srcdir)/lib -I"$(EXTOUT)/$(arch)" -I. +!endif +MINIRUBY = $(MINIRUBY) $(MINIRUBYOPT) +RUNRUBY = $(RUNRUBY) "$(srcdir)/tool/runruby.rb" --extout="$(EXTOUT)" $(RUNRUBYOPT) -- $(RUN_OPTS) +!if "$(CROSS_COMPILING)" == "yes" +XRUBY = $(MINIRUBY) +!else +XRUBY = $(RUNRUBY) +!endif +BTESTRUBY = $(MINIRUBY) +!ifndef RUBY +RUBY = ruby +!endif + +DTRACE_EXT = dmyh + +!if !defined(STACK) +!if "$(ARCH)" == "x64" || "$(ARCH)" == "ia64" +STACK = 0x400000 +!else +STACK = 0x200000 +!endif +!if defined(STACK_COMMIT) +STACK = $(STACK),$(STACK_COMMIT) +!endif +!endif +ORGLIBPATH = $(LIB) + +#### End of system configuration section. #### + +LIBRUBY_A = $(RUBY_SO_NAME)-static.lib +LIBRUBY_SO = $(RUBY_SO_NAME).dll +LIBRUBY = $(RUBY_SO_NAME).lib +LIBRUBYARG = $(LIBRUBY) +LIBRUBY_RELATIVE = yes + +THREAD_MODEL = win32 + +!if "$(CROSS_COMPILING)" == "yes" +PREP = $(arch)-fake.rb +!else +PREP = miniruby$(EXEEXT) +!endif + +!if !defined(EXTSTATIC) +EXTSTATIC = +!endif + +OBJEXT = obj +ASMEXT = asm + +INSTALLED_LIST= .installed.list + +SRC_FILE = $(<:\=/) +OS_SRC_FILE = $(<:/=\) +DEST_FILE = $(@:\=/) +OS_DEST_FILE = $(@:/=\) + +!if !defined(WINMAINOBJ) +WINMAINOBJ = winmain.$(OBJEXT) +!endif +ARCHMINIOBJS = dmydln.$(OBJEXT) miniruby.res +LIBOBJS = $(MISSING) $(LIBOBJS) + +!ifndef COMMON_LIBS +COMMON_LIBS = m +!endif +!ifndef COMMON_MACROS +COMMON_MACROS = WIN32_LEAN_AND_MEAN WIN32 +!endif +!ifndef COMMON_HEADERS +COMMON_HEADERS = winsock2.h ws2tcpip.h windows.h +!endif + +!if "$(EXTSTATIC)" == "static" +ENCOBJS = enc/encinit.$(OBJEXT) enc/libenc.lib enc/libtrans.lib +EXTOBJS = ext/extinit.$(OBJEXT) +! if !defined(ENCSTATIC) +ENCSTATIC = static +! endif +!else +ENCOBJS = dmyenc.$(OBJEXT) +EXTOBJS = dmyext.$(OBJEXT) +!endif + +arch_hdrdir = $(EXTOUT)/include/$(arch) +top_srcdir = $(srcdir) +hdrdir = $(srcdir)/include +VPATH = $(arch_hdrdir)/ruby;$(hdrdir)/ruby;$(srcdir);$(srcdir)/enc;$(srcdir)/missing;$(win_srcdir) + +!if exist($(srcdir)/.svn) +VCS = svn +VCSUP = $(VCS) up $(SVNUPOPTIONS) +!else if exist($(srcdir)/.git/svn) +VCS = git svn +VCSUP = $(VCS) rebase $(GITSVNREBASEOPTIONS) +!else if exist($(srcdir)/.git) +VCS = git +VCSUP = $(VCS) pull $(GITPULLOPTIONS) +!else +VCSUP = rem +!endif +ruby_pc = $(RUBY_BASE_NAME)-$(MAJOR).$(MINOR).pc + +MESSAGE_BEGIN = @for %I in ( +MESSAGE_END = ) do @echo.%~I +ECHO_BEGIN = @echo. +ECHO_END = + +all: $(srcdir)/win32/Makefile.sub $(win_srcdir)/Makefile.sub $(srcdir)/common.mk +prog: config + +ruby: $(PROGRAM) +rubyw: $(WPROGRAM) +stub: $(STUBPROGRAM) + +!if !exist(newline.c) && exist($(srcdir)/newline.c) +NEWLINE_C = $(srcdir)/newline.c +!else +NEWLINE_C = newline.c +!endif +!if !exist(miniprelude.c) && exist($(srcdir)/miniprelude.c) +MINIPRELUDE_C = $(srcdir)/miniprelude.c +!else +MINIPRELUDE_C = miniprelude.c +!endif +!if !exist(prelude.c) && exist($(srcdir)/prelude.c) +PRELUDE_C = $(srcdir)/prelude.c +!else +PRELUDE_C = prelude.c +!endif +RBCONFIG = ./.rbconfig.time + +!include $(srcdir)/common.mk +!if exist(verconf.mk) +! include verconf.mk +!endif + +!ifdef SCRIPTPROGRAMS +!else if [echo>scriptbin.mk SCRIPTPROGRAMS = \] +!else if [for %I in ($(srcdir:/=\)\bin\*) do @echo>>scriptbin.mk %~nI.exe \] +!else if [echo.>>scriptbin.mk] +!else if [echo.>>scriptbin.mk] +!endif +!if [for %I in ($(srcdir:/=\)\bin\*) do @for %J in (\ +"%~nI.exe: $$(srcdir)/bin/%~nI" \ +" $$(ECHO) generating $$(@)" \ +" $$(Q) copy /y /b $$(STUBPROGRAM) $$(@) > nul" \ +" $$(Q) echo.>>$$(@)" \ +" $$(Q) echo.>>$$(@)" \ +" $$(Q) copy /b $$(@)+$$(srcdir:/=\)\bin\%~nI $$(@) > nul" \ +"" \ +) do @echo.%~J>>scriptbin.mk] +!else +! include scriptbin.mk +! if [del scriptbin.mk > nul] +! endif +!endif + +scriptbin: $(SCRIPTPROGRAMS) + +$(SCRIPTPROGRAMS): $(STUBPROGRAM) + +up:: + @cd "$(srcdir:/=\)" && set LC_TIME=C && $(VCSUP) + +update-mspec: +!if exist($(srcdir)/spec/mspec) + @echo updating mspec ... + @cd $(srcdir:/=\)\spec\mspec && git pull +!else + @echo retrieving mspec ... + @cd $(srcdir:/=\) && git clone $(MSPEC_GIT_URL) spec/mspec +!endif + +update-rubyspec: update-mspec +!if exist($(srcdir)/spec/rubyspec) + @echo updating rubyspec ... + @cd $(srcdir:/=\)\spec\rubyspec && git pull +!else + @echo retrieving rubyspec ... + @cd $(srcdir:/=\) && git clone $(RUBYSPEC_GIT_URL) spec/rubyspec +!endif + +test-rubyspec-precheck: +!if !exist($(srcdir)/spec/rubyspec/.) + @echo No rubyspec here. make update-rubyspec first. + @exit 1 +!endif + +$(MKFILES): $(srcdir)/common.mk $(srcdir)/version.h \ + $(win_srcdir)/Makefile.sub $(win_srcdir)/configure.bat \ + $(win_srcdir)/setup.mak $(win_srcdir)/enc-setup.mak \ + $(srcdir)/enc/Makefile.in + $(COMSPEC) /C $(win_srcdir:/=\)\configure.bat $(configure_args) + @fc Makefile Makefile.old > nul && echo Makefile unchanged || \ + (echo $(MKFILES) was updated, re-run $(MAKE). & exit 1) + +RUBY_CONFIG_H = $(arch_hdrdir)/ruby/config.h +CONFIG_H = ./.config.h.time + +config: config.status + +config.status: $(CONFIG_H) + +BANG = ! + +!if exist($(RUBY_CONFIG_H)) +!include $(RUBY_CONFIG_H) +!endif + +guard = INCLUDE_RUBY_CONFIG_H + +$(CONFIG_H): $(MKFILES) $(srcdir)/win32/Makefile.sub $(win_srcdir)/Makefile.sub + @echo Creating config.h +!if !exist("$(arch_hdrdir)") + @md $(arch_hdrdir:/=\) +!endif +!if !exist("$(arch_hdrdir)/ruby") + @md $(arch_hdrdir:/=\)\ruby +!endif + @$(IFCHANGE) "--timestamp=$(@:/=\)" $(RUBY_CONFIG_H:/=\) << +#ifndef $(guard) +#define $(guard) 1 +#if _MSC_VER != $(MSC_VER) +#error MSC version unmatch: _MSC_VER: $(MSC_VER) is expected. +#endif +#define RUBY_MSVCRT_VERSION $(RT_VER) +#define STDC_HEADERS 1 +#define HAVE_SYS_TYPES_H 1 +#define HAVE_SYS_STAT_H 1 +#define HAVE_STDLIB_H 1 +#define HAVE_STDDEF_H 1 +#define HAVE_STRING_H 1 +#define HAVE_MEMORY_H 1 +!if $(MSC_VER) >= 1400 +#define HAVE_LONG_LONG 1 +!endif +#define HAVE_OFF_T 1 +#define SIZEOF_INT 4 +#define SIZEOF_SHORT 2 +#define SIZEOF_LONG 4 +!if $(MSC_VER) >= 1400 +#define SIZEOF_LONG_LONG 8 +!else +#define SIZEOF_LONG_LONG 0 +!endif +#define SIZEOF___INT64 8 +#define _INTEGRAL_MAX_BITS 64 +!if $(LARGEFILE_SUPPORT) +#define SIZEOF_OFF_T 8 +!else +#define SIZEOF_OFF_T 4 +!endif +!if "$(ARCH)" == "x64" || "$(ARCH)" == "ia64" +#define SIZEOF_VOIDP 8 +!else +#define SIZEOF_VOIDP 4 +!endif +#define SIZEOF_FLOAT 4 +#define SIZEOF_DOUBLE 8 +#define SIGNEDNESS_OF_TIME_T -1 +!if $(RT_VER) >= 80 +#define SIZEOF_TIME_T 8 +#define TIMET2NUM(v) LL2NUM(v) +#define NUM2TIMET(v) NUM2LL(v) +!else +#define SIZEOF_TIME_T 4 +#define TIMET2NUM(v) LONG2NUM(v) +#define NUM2TIMET(v) NUM2LONG(v) +!endif +#define CLOCKID2NUM(v) INT2NUM(v) +#define NUM2CLOCKID(v) NUM2INT(v) +#define SIZEOF_CLOCK_T 4 +#define SIZEOF_RLIM_T 0 +!if "$(ARCH)" == "x64" || "$(ARCH)" == "ia64" +#define SIZEOF_SIZE_T 8 +#define SIZEOF_PTRDIFF_T 8 +#define SIZEOF_INTPTR_T 8 +#define SIZEOF_UINTPTR_T 8 +!else +#define SIZEOF_SIZE_T 4 +#define SIZEOF_PTRDIFF_T 4 +#define SIZEOF_INTPTR_T 4 +#define SIZEOF_UINTPTR_T 4 +!endif +!if $(MSC_VER) < 1400 +#define SIZE_MAX UINT_MAX +!endif +#define HAVE_PROTOTYPES 1 +#define TOKEN_PASTE(x,y) x##y +#define HAVE_STDARG_PROTOTYPES 1 +!if $(MSC_VER) > 1100 +#define NORETURN(x) __declspec(noreturn) x +!endif +!if $(MSC_VER) >= 1300 +#define DEPRECATED(x) __declspec(deprecated) x +#define NOINLINE(x) __declspec(noinline) x +!endif +#define FUNC_STDCALL(x) __stdcall x +#define FUNC_CDECL(x) __cdecl x +#define FUNC_FASTCALL(x) __fastcall x +!if $(MSC_VER) >= 1500 +#define RUBY_FUNCTION_NAME_STRING __FUNCTION__ +#define PACKED_STRUCT(x) __pragma(pack(push, 1)) x __pragma(pack(pop)) +!else +#define PACKED_STRUCT(x) x +!endif +!if "$(ARCH)" == "x86" || "$(ARCH)" == "x64" || "$(ARCH)" == "ia64" +#define PACKED_STRUCT_UNALIGNED(x) PACKED_STRUCT(x) +!else +#define PACKED_STRUCT_UNALIGNED(x) x +!endif +#define RUBY_EXTERN extern __declspec(dllimport) +#define HAVE_DECL_SYS_NERR 1 +#define HAVE_LIMITS_H 1 +#define HAVE_FCNTL_H 1 +#define HAVE_SYS_UTIME_H 1 +#define HAVE_FLOAT_H 1 +#define HAVE_TIME_H 1 +#define rb_pid_t int +#define rb_gid_t int +#define rb_uid_t int +#define HAVE_STRUCT_STAT_ST_RDEV 1 +#define HAVE_ST_RDEV 1 +#define HAVE_STRUCT_TIMEVAL 1 +!if $(MSC_VER) >= 1600 +#define HAVE_STDINT_H 1 +!else +#define int8_t signed char +#define uint8_t unsigned char +#define int16_t short +#define uint16_t unsigned short +#define int32_t int +#define uint32_t unsigned int +#define int64_t __int64 +#define uint64_t unsigned __int64 +#define INT8_MIN _I8_MIN +#define INT8_MAX _I8_MAX +#define UINT8_MAX _UI8_MAX +#define INT16_MIN _I16_MIN +#define INT16_MAX _I16_MAX +#define UINT16_MAX _UI16_MAX +#define INT32_MIN _I32_MIN +#define INT32_MAX _I32_MAX +#define UINT32_MAX _UI32_MAX +#define INT64_MIN _I64_MIN +#define INT64_MAX _I64_MAX +#define UINT64_MAX _UI64_MAX +!endif +#define HAVE_INT8_T 1 +#define HAVE_UINT8_T 1 +#define SIZEOF_INT8_T 1 +#define SIZEOF_UINT8_T 1 +#define HAVE_INT16_T 1 +#define HAVE_UINT16_T 1 +#define SIZEOF_INT16_T 2 +#define SIZEOF_UINT16_T 2 +#define HAVE_INT32_T 1 +#define HAVE_UINT32_T 1 +#define SIZEOF_INT32_T 4 +#define SIZEOF_UINT32_T 4 +#define HAVE_INT64_T 1 +#define HAVE_UINT64_T 1 +#define SIZEOF_INT64_T 8 +#define SIZEOF_UINT64_T 8 +#define HAVE_INTPTR_T 1 +#define HAVE_UINTPTR_T 1 +#define HAVE_SSIZE_T 1 +!if "$(ARCH)" == "x64" || "$(ARCH)" == "ia64" +#define ssize_t __int64 +!else +#define ssize_t int +!endif +#define PRI_LL_PREFIX "I64" +#define PRI_PIDT_PREFIX PRI_INT_PREFIX +#define GETGROUPS_T int +#define RETSIGTYPE void +#define TYPEOF_TIMEVAL_TV_SEC long +!if $(RT_VER) >= 120 +#define HAVE_ACOSH 1 +#define HAVE_ASINH 1 +#define HAVE_ATANH 1 +#define HAVE_CBRT 1 +#define HAVE_LOG2 1 +#define log2(x) log2(x) +#define HAVE_ERF 1 +#define HAVE_ERFC 1 +#define HAVE_ROUND 1 +#define HAVE_TGAMMA 1 +#define HAVE_NEXTAFTER 1 +!endif +#define HAVE_ALLOCA 1 +#define HAVE_DUP2 1 +#define HAVE_MEMCMP 1 +#define HAVE_MEMMOVE 1 +#define HAVE_MKDIR 1 +#define HAVE_CLOCK_GETTIME 1 +#define HAVE_CLOCK_GETRES 1 +#define HAVE_SPAWNV 1 +#define HAVE_STRCASECMP 1 +#define HAVE_STRNCASECMP 1 +#define HAVE_STRERROR 1 +#define HAVE_STRFTIME 1 +#define HAVE_STRCHR 1 +#define HAVE_STRSTR 1 +#define HAVE_STRTOD 1 +#define HAVE_STRTOL 1 +#define HAVE_STRTOUL 1 +#define HAVE_FLOCK 1 +#define HAVE_ISNAN 1 +#define HAVE_FINITE 1 +#define HAVE_HYPOT 1 +#define HAVE_FMOD 1 +#define HAVE_FREXP 1 +#define HAVE_MODF 1 +#define HAVE_WAITPID 1 +#define HAVE_FSYNC 1 +#define HAVE_GETCWD 1 +#define HAVE_TRUNCATE 1 +#define HAVE_FTRUNCATE 1 +#define HAVE_TIMES 1 +#define HAVE_FCNTL 1 +#define HAVE_LINK 1 +#define HAVE__SETJMP 1 +#define HAVE_TELLDIR 1 +#define HAVE_SEEKDIR 1 +#define HAVE_MKTIME 1 +#define HAVE_COSH 1 +#define HAVE_SINH 1 +#define HAVE_TANH 1 +#define HAVE_SIGNBIT 1 +#define HAVE_TZNAME 1 +#define HAVE_DAYLIGHT 1 +#define HAVE_GMTIME_R 1 +#define HAVE_TYPE_NET_LUID 1 +#define SETPGRP_VOID 1 +#define RSHIFT(x,y) ((x)>>(int)y) +#define HAVE_RB_FD_INIT 1 +#define RUBY_SETJMP(env) _setjmp(env) +#define RUBY_LONGJMP(env,val) longjmp(env,val) +#define RUBY_JMP_BUF jmp_buf +#define inline __inline +#define NEED_IO_SEEK_BETWEEN_RW 1 +!if "$(MACHINE)" == "x86" || "$(ARCH)" == "x64" || "$(ARCH)" == "ia64" +#define STACK_GROW_DIRECTION -1 +!endif +#define CANONICALIZATION_FOR_MATHN 1 +#define DEFAULT_KCODE KCODE_NONE +!if "$(ENABLE_DEBUG_ENV)" == "yes" +#define RUBY_DEBUG_ENV 1 +!endif +#define LOAD_RELATIVE 1 +#define DLEXT ".so" +!if "$(EXTSTATIC)" == "static" +#define EXTSTATIC 1 +!endif +#define EXECUTABLE_EXTS $(EXECUTABLE_EXTS) +#define RUBY_COREDLL "$(RT)" +#define LIBRUBY_SO "$(LIBRUBY_SO)" +#define RUBY_PLATFORM "$(arch)" +#define RUBY_SITEARCH "$(sitearch)" +#if 0 +$(BANG)if "$(RUBY_SO_NAME)"!="$$(RUBY_SO_NAME)" || "$(ARCH)-$(PLATFORM)"!="$$(ARCH)-$$(PLATFORM)" +config.h: nul +$(BANG)endif +#endif +#endif /* $(guard) */ +<< + +#!if exist($(RUBY_CONFIG_H)) +#! if exist(config_h.bak) +# @del $(RUBY_CONFIG_H:.h=_h).bak +#! endif +# @copy $(RUBY_CONFIG_H) $(RUBY_CONFIG_H:.h=_h).bak +#!endif +#!if exist($(RUBY_CONFIG_H)) +# @echo NMAKE will abort if config.h is changed, then restart NMAKE. +# @fc.exe $(RUBY_CONFIG_H) $(RUBY_CONFIG_H:.h=_h).bak > nul +# @echo $(RUBY_CONFIG_H) unchanged. +# @del $(RUBY_CONFIG_H) +# @ren $(RUBY_CONFIG_H:.h=_h).bak $(RUBY_CONFIG_H) +#!endif + +EXECUTABLE_EXTS = $(EXECUTABLE_EXTS:"=) # " +EXECUTABLE_EXTS = $(EXECUTABLE_EXTS:,= ) + +config.status: $(MKFILES) $(srcdir)/win32/Makefile.sub $(win_srcdir)/Makefile.sub $(srcdir)/common.mk + @echo Creating $@ + @exit <<$@ +# Generated automatically by Makefile.sub. +s,@SHELL@,$$(COMSPEC),;t t +s,@BUILD_FILE_SEPARATOR@,\,;t t +s,@PATH_SEPARATOR@,;,;t t +s,@CFLAGS@,$(CFLAGS),;t t +s,@WERRORFLAG@,$(WERRORFLAG),;t t +s,@DEFS@,$(DEFS),;t t +s,@CPPFLAGS@,$(CPPFLAGS),;t t +s,@CXXFLAGS@,$(CXXFLAGS),;t t +s,@FFLAGS@,$(FFLAGS),;t t +s,@LDFLAGS@,$(LDFLAGS),;t t +s,@LIBS@,$(LIBS),;t t +s,@exec_prefix@,$${prefix},;t t +s,@prefix@,$(prefix),;t t +s,@program_transform_name@,s,.*,$(PROGRAM_PREFIX)&$(PROGRAM_SUFFIX),,;t t +s,@bindir@,$${exec_prefix}/bin,;t t +s,@sbindir@,$${exec_prefix}/sbin,;t t +s,@libexecdir@,$${exec_prefix}/libexec,;t t +s,@datadir@,$${prefix}/share,;t t +s,@sysconfdir@,$${prefix}/etc,;t t +s,@sharedstatedir@,/etc,;t t +s,@localstatedir@,/var,;t t +s,@libdir@,$${exec_prefix}/lib,;t t +s,@includedir@,$${prefix}/include,;t t +s,@oldincludedir@,/usr/include,;t t +s,@infodir@,$${datadir}/info,;t t +s,@mandir@,$${datadir}/man,;t t +s,@ridir@,$${datadir}/ri,;t t +s,@docdir@,$${datadir}/doc/$${RUBY_BASE_NAME},;t t +s,@build@,$(CPU)-pc-$(PLATFORM),;t t +s,@build_alias@,$(CPU)-$(PLATFORM),;t t +s,@build_cpu@,$(CPU),;t t +s,@build_vendor@,pc,;t t +s,@build_os@,$(PLATFORM),;t t +s,@host@,$(CPU)-pc-$(PLATFORM),;t t +s,@host_alias@,$(CPU)-$(PLATFORM),;t t +s,@host_cpu@,$(CPU),;t t +s,@host_vendor@,pc,;t t +s,@host_os@,$(PLATFORM),;t t +s,@target@,$(ARCH)-pc-$(PLATFORM),;t t +s,@target_alias@,$(ARCH)-$(PLATFORM),;t t +s,@target_cpu@,$(ARCH),;t t +s,@target_vendor@,pc,;t t +s,@target_os@,$(PLATFORM),;t t +s,@NULLCMD@,:,;t t +s,@CC@,$(CC),;t t +s,@CPP@,$(CPP),;t t +s,@CXX@,$$(CC),;t t +s,@LD@,$$(CC),;t t +s,@YACC@,$(YACC),;t t +s,@RANLIB@,,;t t +s,@AR@,$(AR),;t t +s,@ARFLAGS@,$(ARFLAGS),;t t +s,@LN_S@,$(LN_S),;t t +s,@SET_MAKE@,MFLAGS = -$$(MAKEFLAGS),;t t +s,@RM@,$$(COMSPEC) /C $$(top_srcdir:/=\)\win32\rm.bat,;t t +s,@RMDIR@,$$(COMSPEC) /C $$(top_srcdir:/=\)\win32\rmdirs.bat,:t t +s,@RMDIRS@,$$(COMSPEC) /C $$(top_srcdir:/=\)\win32\rmdirs.bat,;t t +s,@RMALL@,$$(COMSPEC) /C $$(top_srcdir:/=\)\win32\rm.bat -f -r,:t t +s,@MAKEDIRS@,$$(COMSPEC) /E:ON /C $$(top_srcdir:/=\)\win32\makedirs.bat,;t t +s,@LIBOBJS@,$(LIBOBJS),;t t +s,@ALLOCA@,$(ALLOCA),;t t +s,@DEFAULT_KCODE@,$(DEFAULT_KCODE),;t t +s,@EXEEXT@,.exe,;t t +s,@EXECUTABLE_EXTS@,$(EXECUTABLE_EXTS),;t t +s,@OBJEXT@,$(OBJEXT),;t t +s,@ASMEXT@,$(ASMEXT),;t t +s,@XCFLAGS@,$(XCFLAGS),;t t +s,@XLDFLAGS@,$(XLDFLAGS),;t t +s,@DLDFLAGS@,$(DLDFLAGS) $$(LIBPATH),;t t +s,@EXTDLDFLAGS@,$(EXTDLDFLAGS),;t t +s,@ARCH_FLAG@,$(ARCH_FLAG),;t t +s,@STATIC@,$(STATIC),;t t +s,@CCDLFLAGS@,,;t t +s,@LDSHARED@,$(LDSHARED),;t t +s,@DLEXT@,so,;t t +s,@LIBEXT@,lib,;t t +s,@STRIP@,$(STRIP),;t t +s,@EXTSTATIC@,$(EXTSTATIC),;t t +s,@setup@,Setup,;t t +s,@MINIRUBY@,$(MINIRUBY),;t t +s,@PREP@,miniruby$(EXEEXT),;t t +s,@RUNRUBY@,$(RUNRUBY),;t t +s,@EXTOUT@,$(EXTOUT),;t t +s,@ARCHFILE@,,;t t +s,@RDOCTARGET@,,;t t +s,@LIBRUBY_LDSHARED@,$(LIBRUBY_LDSHARED),;t t +s,@LIBRUBY_DLDFLAGS@,$(LIBRUBY_DLDFLAGS),;t t +s,@RUBY_BASE_NAME@,$(RUBY_BASE_NAME),;t t +s,@RUBY_INSTALL_NAME@,$(RUBY_INSTALL_NAME),;t t +s,@rubyw_install_name@,$(RUBYW_INSTALL_NAME),;t t +s,@RUBYW_INSTALL_NAME@,$(RUBYW_INSTALL_NAME),;t t +s,@RUBY_SO_NAME@,$(RUBY_SO_NAME),;t t +s,@LIBRUBY_A@,$$(RUBY_SO_NAME)-static.lib,;t t +s,@LIBRUBY_SO@,$$(RUBY_SO_NAME).dll,;t t +s,@LIBRUBY_ALIASES@,$(LIBRUBY_ALIASES),;t t +s,@LIBRUBY@,$$(RUBY_SO_NAME).lib,;t t +s,@LIBRUBYARG@,$$(LIBRUBYARG_SHARED),;t t +s,@LIBRUBYARG_STATIC@,$$(LIBRUBY_A),;t t +s,@LIBRUBYARG_SHARED@,$$(LIBRUBY),;t t +s,@SOLIBS@,$(SOLIBS),;t t +s,@DLDLIBS@,$(DLDLIBS),;t t +s,@ENABLE_SHARED@,yes,;t t +s,@BASERUBY@,$(BASERUBY),;t t +s,@OUTFLAG@,$(OUTFLAG),;t t +s,@COUTFLAG@,$(COUTFLAG),;t t +s,@CPPOUTFILE@,-P,;t t +s,@LIBPATHFLAG@, -libpath:%s,;t t +s,@RPATHFLAG@,,;t t +s,@LIBARG@,%s.lib,;t t +s,@LINK_SO@,$$(LDSHARED) -Fe$$(@) $$(OBJS) $$(LIBS) $$(LOCAL_LIBS) -link $$(DLDFLAGS) -implib:$$(*F:.so=)-$$(arch).lib -pdb:$$(*F:.so=)-$$(arch).pdb -def:$$(DEFFILE),;t t +!if $(MSC_VER) >= 1400 +s,@LINK_SO@,@if exist $$(@).manifest $$(RUBY) -run -e wait_writable -- -n 10 $$(@),;t t +s,@LINK_SO@,@if exist $$(@).manifest $(MANIFESTTOOL) -manifest $$(@).manifest -outputresource:$$(@);2,;t t +s,@LINK_SO@,@if exist $$(@).manifest $$(RM) $$(@:/=\).manifest,;t t +!endif +s,@COMPILE_C@,$$(CC) $$(INCFLAGS) $$(CFLAGS) $$(CPPFLAGS) $$(COUTFLAG)$$(@) -c -Tc$$(<:\=/),;t t +s,@COMPILE_CXX@,$$(CXX) $$(INCFLAGS) $$(CXXFLAGS) $$(CPPFLAGS) $$(COUTFLAG)$$(@) -c -Tp$$(<:\=/),;t t +s,@ASSEMBLE_C@,$$(CC) $$(CFLAGS) $$(CPPFLAGS) -Fa$$(@) -c -Tc$$(<:\=/),;t t +s,@ASSEMBLE_CXX@,$$(CXX) $$(CXXFLAGS) $$(CPPFLAGS) -Fa$$(@) -c -Tp$$(<:\=/),;t t +s,@COMPILE_RULES@,{$$(*VPATH*)}.%s.%s: .%s.%s:,;t t +s,@RULE_SUBST@,{.;$$(VPATH)}%s,;t t +s,@TRY_LINK@,$$(CC) -Feconftest $$(INCFLAGS) -I$$(hdrdir) $$(CPPFLAGS) $$(CFLAGS) $$(src) $$(LOCAL_LIBS) $$(LIBS) -link $$(LDFLAGS) $$(LIBPATH) $$(XLDFLAGS),;t t +s,@COMMON_LIBS@,$(COMMON_LIBS),;t t +s,@COMMON_MACROS@,$(COMMON_MACROS),;t t +s,@COMMON_HEADERS@,$(COMMON_HEADERS),;t t +s,@cleanobjs@,$$*.exp $$*.lib $$*.pdb,;t t +s,@DISTCLEANFILES@,vc*.pdb,;t t +s,@EXPORT_PREFIX@, ,;t t +s,@archlibdir@,$${libdir}/$${arch},;t t +s,@sitearchlibdir@,$${libdir}/$${sitearch},;t t +s,@archincludedir@,$${includedir}/$${arch},;t t +s,@sitearchincludedir@,$${includedir}/$${sitearch},;t t +s,@arch@,$(ARCH)-$(PLATFORM),;t t +s,@sitearch@,$(ARCH)-$(RT),;t t +s,@ruby_version@,$(ruby_version),;t t +s,@rubylibprefix@,$${prefix}/lib/$${RUBY_BASE_NAME},;t t +s,@rubyarchdir@,$${rubylibdir}/$${arch},;t t +s,@rubylibdir@,$${rubylibprefix}/$${ruby_version},;t t +s,@sitedir@,$${rubylibprefix}/site_ruby,;t t +s,@sitearchdir@,$${sitelibdir}/$${sitearch},;t t +s,@sitelibdir@,$${sitedir}/$${ruby_version},;t t +s,@vendordir@,$${rubylibprefix}/vendor_ruby,;t t +s,@vendorarchdir@,$${vendorlibdir}/$${sitearch},;t t +s,@vendorlibdir@,$${vendordir}/$${ruby_version},;t t +s,@rubyhdrdir@,$$(includedir)/$${RUBY_BASE_NAME}-$$(ruby_version),;t t +s,@sitehdrdir@,$$(rubyhdrdir)/site_ruby,;t t +s,@vendorhdrdir@,$$(rubyhdrdir)/vendor_ruby,;t t +s,@rubyarchhdrdir@,$$(rubyhdrdir)/$${arch},;t t +s,@sitearchhdrdir@,$$(sitehdrdir)/$${sitearch},;t t +s,@vendorarchhdrdir@,$$(vendorhdrdir)/$${sitearch},;t t +s,@PLATFORM_DIR@,$(PLATFORM_DIR),;t t +s,@THREAD_MODEL@,$(THREAD_MODEL),;t t +s,@configure_args@,--with-make-prog=nmake --enable-shared $(configure_args),;t t +s,@configure_input@,$$configure_input,;t t +s,@srcdir@,$(srcdir),;t t +s,@top_srcdir@,$(srcdir),;t t +s,@try_header@,try_compile,;t t +s,@ruby_pc@,$(ruby_pc),;t t +< $@ + +!if "$(PROGRAM)" != "" +$(PROGRAM): $(MAINOBJ) $(LIBRUBY_SO) $(RUBY_INSTALL_NAME).res + $(ECHO) linking $(@:\=/) + $(Q) $(PURIFY) $(CC) $(MAINOBJ) $(RUBY_INSTALL_NAME).res \ + $(OUTFLAG)$@ $(LIBRUBYARG) -link $(LDFLAGS) $(XLDFLAGS) + $(Q) $(LDSHARED_0) + $(Q) $(LDSHARED_1) + $(Q) $(LDSHARED_2) +!endif + +!if "$(WPROGRAM)" != "" +$(WPROGRAM): $(MAINOBJ) $(WINMAINOBJ) $(LIBRUBY_SO) $(RUBYW_INSTALL_NAME).res + $(ECHO) linking $(@:\=/) + $(Q) $(PURIFY) $(CC) $(MAINOBJ) $(WINMAINOBJ) \ + $(RUBYW_INSTALL_NAME).res $(OUTFLAG)$@ $(LIBRUBYARG) \ + -link $(LDFLAGS) $(XLDFLAGS) -subsystem:Windows + $(Q) $(LDSHARED_0) + $(Q) $(LDSHARED_1) + $(Q) $(LDSHARED_2) +!endif + +!if "$(STUBPROGRAM)" != "" +$(STUBPROGRAM): stub.$(OBJEXT) $(LIBRUBY) $(LIBRUBY_SO) $(RUBY_INSTALL_NAME).res + $(ECHO) linking $(@:\=/) + $(Q) $(PURIFY) $(CC) stub.$(OBJEXT) $(RUBY_INSTALL_NAME).res \ + $(OUTFLAG)$@ $(LIBRUBYARG) -link $(LDFLAGS) $(XLDFLAGS) + $(Q) $(LDSHARED_0) + $(Q) $(LDSHARED_1) + $(Q) $(LDSHARED_2) +!endif + +$(LIBRUBY_A): $(OBJS) $(INITOBJS) + $(ECHO) linking static-library $(@:\=/) + $(Q) $(AR) $(ARFLAGS)$@ $(OBJS) $(INITOBJS) + +$(LIBRUBY): $(RUBYDEF) + $(ECHO) linking import-library $(@:\=/) + $(Q) $(AR) $(ARFLAGS)$@ -def:$(RUBYDEF) + +$(LIBRUBY_SO): $(LIBRUBY_A) $(DLDOBJS) $(RUBYDEF) $(RUBY_SO_NAME).res + @echo $(DLDOBJS) + @-$(PRE_LIBRUBY_UPDATE) + $(ECHO) linking shared-library $(@:\=/) + $(Q) $(LDSHARED) $(MAINOBJ) $(DLDOBJS) $(LIBRUBY_A) \ + $(RUBY_SO_NAME).res $(LIBS) -Fe$@ -link $(LDFLAGS) \ + $(LIBRUBY_DLDFLAGS) + @$(RM) dummy.lib dummy.exp + $(Q) $(LDSHARED_0) + $(Q) $(LDSHARED_1) + $(Q) $(LDSHARED_2) +# | findstr -v -c:LNK4049 -c:LNK4217 + +$(RUBYDEF): $(LIBRUBY_A) $(PREP) + $(ECHO) generating $(@:\=/) + $(Q) $(MINIRUBY) $(srcdir)/win32/mkexports.rb \ + -output=$@ -arch=$(ARCH) $(LIBRUBY_A) + +{$(win_srcdir)}.def.lib: + $(Q) $(AR) $(ARFLAGS)$@ -def:$< + +clean-local:: + $(Q)$(RM) $(WINMAINOBJ) ext\extinit.c ext\extinit.$(OBJEXT) ext\vc*.pdb miniruby.lib + $(Q)$(RM) $(RUBY_INSTALL_NAME).res $(RUBYW_INSTALL_NAME).res $(RUBY_SO_NAME).res + $(Q)$(RM) miniruby.rc $(RUBY_INSTALL_NAME).rc $(RUBYW_INSTALL_NAME).rc $(RUBY_SO_NAME).rc + $(Q)$(RM) *.map *.pdb *.ilk *.exp $(RUBYDEF) ext\ripper\y.output + +distclean-local:: + $(Q)$(RM) ext\config.cache $(RBCONFIG:/=\) $(CONFIG_H:/=\) + -$(Q)$(RM) $(INSTALLED_LIST:/=\) $(arch_hdrdir:/=\)\ruby\config.h verconf.h + -$(Q)$(RMDIRS) $(arch_hdrdir:/=\)\ruby + +clean-ext distclean-ext realclean-ext:: +!if "$(EXTS)" != "" + @for %I in ($(EXTS)) \ +!else + @for /R ext %I in (.) \ +!endif + do @if exist %I\Makefile ( \ + cd %I && ( \ + echo $(@:-ext=)ing %~nI & \ + $(MAKE) $(MFLAGS) $(@:-ext=) & \ + cd %CD% & \ + $(RMDIRS) %I \ + ) ) + +distclean-ext realclean-ext:: + -$(Q)rmdir ext + +clean-extout: + +clean-enc distclean-enc realclean-enc: +!if exist($(ENC_MK)) + @echo $(@:-enc=ing) encodings + @-$(MAKE) -f $(ENC_MK) $(MFLAGS) V=$(V) $(@:-enc=) +!endif + +$(RCFILES): $(RBCONFIG) $(srcdir)/revision.h $(srcdir)/win32/resource.rb + @$(MINIRUBY) $(srcdir)/win32/resource.rb \ + -ruby_name=$(RUBY_INSTALL_NAME) \ + -rubyw_name=$(RUBYW_INSTALL_NAME) \ + -so_name=$(RUBY_SO_NAME) \ + . $(icondirs) $(win_srcdir) + +$(arch)-fake.rb: $(MKFILES) $(srcdir)/version.h + @echo Creating <<$@ +class Object + remove_const :CROSS_COMPILING if defined?(CROSS_COMPILING) + CROSS_COMPILING = RUBY_PLATFORM + remove_const :RUBY_PLATFORM + remove_const :RUBY_VERSION + remove_const :RUBY_DESCRIPTION if defined?(RUBY_DESCRIPTION) + RUBY_PLATFORM = "$(arch)" + RUBY_VERSION = $(RUBY_PROGRAM_VERSION) + RUBY_DESCRIPTION = "ruby #{RUBY_VERSION} (" $(RUBY_RELEASE_DATE) ") [#{RUBY_PLATFORM}]" +end +class File + remove_const :ALT_SEPARATOR + ALT_SEPARATOR = "\\" +end +< $@ + +{$(srcdir)/enc}.c.obj: + $(ECHO) compiling $(<:\=/) + $(Q) $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) $(COUTFLAG)$@ -c -Tc$(<:\=/) +{$(srcdir)/missing}.c.obj: + $(ECHO) compiling $(<:\=/) + $(Q) $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) $(COUTFLAG)$@ -c -Tc$(<:\=/) +{$(win_srcdir)}.c.obj: + $(ECHO) compiling $(<:\=/) + $(Q) $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) $(COUTFLAG)$@ -c -Tc$(<:\=/) +{$(srcdir)}.c{}.obj: + $(ECHO) compiling $(<:\=/) + $(Q) $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) $(COUTFLAG)$@ -c -Tc$(<:\=/) +.c.obj: + $(ECHO) compiling $(<:\=/) + $(Q) $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) $(COUTFLAG)$@ -c -Tc$(<:\=/) + +{$(srcdir)/missing}.c.asm: + $(ECHO) translating $(<:\=/) + $(Q) $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -Fa$@ -c -Tc$(<:\=/) +{$(win_srcdir)}.c.asm: + $(ECHO) translating $(<:\=/) + $(Q) $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -Fa$@ -c -Tc$(<:\=/) +{$(srcdir)}.c{}.asm: + $(ECHO) translating $(<:\=/) + $(Q) $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -Fa$@ -c -Tc$(<:\=/) +.c.asm: + $(ECHO) translating $(<:\=/) + $(Q) $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -Fa$@ -c -Tc$(<:\=/) + +{$(srcdir)/missing}.c.i: + $(ECHO) preprocessing $(<:\=/) + $(Q) $(CC) $(XCFLAGS) $(CPPFLAGS) -P -Tc$(<:\=/) > $@ +{$(win_srcdir)}.c.i: + $(ECHO) preprocessing $(<:\=/) + $(Q) $(CC) $(XCFLAGS) $(CPPFLAGS) -P -Tc$(<:\=/) +{$(srcdir)}.c{}.i: + $(ECHO) preprocessing $(<:\=/) + $(Q) $(CC) $(XCFLAGS) $(CPPFLAGS) -P -Tc$(<:\=/) +.c.i: + $(ECHO) preprocessing $(<:\=/) + $(Q) $(CC) $(XCFLAGS) $(CPPFLAGS) -P -Tc$(<:\=/) + +.rc.res: + $(ECHO) compiling $(<:\=/) + $(Q) $(RC) $(RCFLAGS) -I. -I$( nul + +enc/jis/props.h: {$(srcdir)}enc/jis/props.h.blt + @if not exist $(@D:/=\) md $(@D:/=\) + $(ECHO) copying $@ + $(Q) copy $(?:/=\) $(@:/=\) > nul + +$(OBJS): {$(hdrdir)/ruby}win32.h + +dir.$(OBJEXT) win32/win32.$(OBJEXT): {$(srcdir)}win32/dir.h + +ext/extinit.obj: ext/extinit.c $(SETUP) + $(ECHO) compiling ext/extinit.c + $(Q) $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) $(COUTFLAG)$@ -c ext/extinit.c + +probes.h: {$(VPATH)}probes.dmyh + @$(ECHO) copying dummy $(DEST_FILE) + @if exist probes.dmyh (\ + $(Q) $(CP) probes.dmyh $(OS_DEST_FILE)\ + ) else (\ + $(Q) $(CP) $(srcdir:/=\)\probes.dmyh $(OS_DEST_FILE)\ + ) + +INSNS = opt_sc.inc optinsn.inc optunifs.inc insns.inc insns_info.inc \ + vmtc.inc vm.inc + +!if [exit > insns_rules.mk] +!else if [for %I in ($(INSNS)) do \ + @for %J in (\ +"%I: $$(srcdir)/insns.def {$$(VPATH)}vm_opts.h \" \ +" $$(srcdir)/defs/opt_operand.def $$(srcdir)/defs/opt_insn_unif.def \" \ +" $$(srcdir)/tool/instruction.rb $$(srcdir)/tool/insns2vm.rb" \ +" @$$(RM) $$(PROGRAM)" \ +" $$(BASERUBY) -Ku $$(srcdir)/tool/insns2vm.rb $$(INSNS2VMOPT) %I" \ +"" \ +) do @echo.%~J>>insns_rules.mk] +!else +! include insns_rules.mk +! if [del insns_rules.mk > nul] +! endif +!endif + +verconf.h: verconf.mk + +loadpath: verconf.h + @$(CPP) $(XCFLAGS) $(CPPFLAGS) $(srcdir)/loadpath.c | \ + sed -e '1,/^const char ruby_initial_load_paths/d;/;/,$$d' \ + -e '/^^ /!d;s/ *"\\\\0"$$//;s/" *"//g' diff --git a/jni/ruby/win32/README.win32 b/jni/ruby/win32/README.win32 new file mode 100644 index 0000000..314feb3 --- /dev/null +++ b/jni/ruby/win32/README.win32 @@ -0,0 +1,141 @@ +=begin + += How to build ruby using Visual C++ + +== Requirement + +(1) Windows XP or later. + +(2) Visual C++ 6.0 or later. (strongly recommended VC++ 10 or later) + + Note: if you want to build x64 or ia64 version, use native compiler for + x64/ia64. + +(3) Please set environment variable (({INCLUDE})), (({LIB})), (({PATH})) + to run required commands properly from the command line. + + Note: building ruby requires following commands. + * nmake + * cl + * lib + * dumpbin + +(4) If you want to build from SVN source, following commands are required. + * bison + * sed + * ruby 1.8 or later + +(5) Enable Command Extension of your command line. It's the default behavior + of cmd.exe. If you want to enable it explicitly, run cmd.exe with /E:ON + option. + +== How to compile and install + +(1) Execute win32\configure.bat on your build directory. + You can specify the target platform as an argument. + For example, run `((%configure --target=i686-mswin32%))' + You can also specify the install directory. + For example, run `((%configure --prefix=%))' + Default of the install directory is /usr . + The default ((||)) is `(({i386-mswin32}))'. + +(2) Change ((|RUBY_INSTALL_NAME|)) and ((|RUBY_SO_NAME|)) in (({Makefile})) + if you want to change the name of the executable files. + And add ((|RUBYW_INSTALL_NAME|)) to change the name of the + executable without console window if also you want. + +(3) Run `((%nmake%))' + +(4) Run `((%nmake test%))' + +(5) Run `((%nmake install%))' + +== Icons + +Any icon files(*.ico) in the build directory, directories specified with +((|icondirs|)) make variable and (({win32})) directory under the ruby +source directory will be included in DLL or executable files, according +to their base names. + $(RUBY_INSTALL_NAME).ico or ruby.ico --> $(RUBY_INSTALL_NAME).exe + $(RUBYW_INSTALL_NAME).ico or rubyw.ico --> $(RUBYW_INSTALL_NAME).exe + the others --> $(RUBY_SO_NAME).dll + +Although no icons are distributed with the ruby source or in the official +site, you can use anything you like. For example, followings are written +in Japanese, but you can download at least. + +* (()) or + (()) + +== Build examples + +* Build on the ruby source directory. + + ex.) + ruby source directory: C:\ruby + build directory: C:\ruby + install directory: C:\usr\local + + C: + cd \ruby + win32\configure --prefix=/usr/local + nmake + nmake test + nmake install + +* Build on the relative directory from the ruby source directory. + + ex.) + ruby source directory: C:\ruby + build directory: C:\ruby\mswin32 + install directory: C:\usr\local + + C: + cd \ruby + mkdir mswin32 + cd mswin32 + ..\win32\configure --prefix=/usr/local + nmake + nmake test + nmake install + +* Build on the different drive. + + ex.) + ruby source directory: C:\src\ruby + build directory: D:\build\ruby + install directory: C:\usr\local + + D: + cd D:\build\ruby + C:\src\ruby\win32\configure --prefix=/usr/local + nmake + nmake test + nmake install DESTDIR=C: + +* Build x64 version (requires native x64 VC++ compiler) + + ex.) + ruby source directory: C:\ruby + build directory: C:\ruby + install directory: C:\usr\local + + C: + cd \ruby + win32\configure --prefix=/usr/local --target=x64-mswin64 + nmake + nmake test + nmake install + +== Bugs + +You can ((*NOT*)) use a path name that contains any white space characters as +the ruby source directory, this restriction comes from the behavior of +(({!INCLUDE})) directives of (({NMAKE})). +((- you may call it a bug. -)) + +You can build ruby in any directory including the source directory, +except (({win32})) directory in the source directory. +This is restriction originating in the path search method of (({NMAKE})). + +=end diff --git a/jni/ruby/win32/configure.bat b/jni/ruby/win32/configure.bat new file mode 100755 index 0000000..edf18b7 --- /dev/null +++ b/jni/ruby/win32/configure.bat @@ -0,0 +1,216 @@ +@echo off +@setlocal disabledelayedexpansion +set witharg= + +for %%I in (%0) do if /%%~dpI/ == /%CD%\/ ( + echo don't run in win32 directory. + exit /b 999 +) + +echo> ~tmp~.mak #### +echo>> ~tmp~.mak conf = %0 +echo>> ~tmp~.mak $(conf): nul +echo>> ~tmp~.mak @del ~setup~.mak +echo>> ~tmp~.mak @-$(MAKE) -l$(MAKEFLAGS) -f $(@D)/setup.mak \ +if exist pathlist.tmp del pathlist.tmp +echo>confargs.tmp #define CONFIGURE_ARGS \ +:loop +set opt=%1 +if "%1" == "" goto :end +if "%1" == "--prefix" goto :prefix +if "%1" == "--srcdir" goto :srcdir +if "%1" == "srcdir" goto :srcdir +if "%1" == "--target" goto :target +if "%1" == "target" goto :target +if "%1" == "--with-static-linked-ext" goto :extstatic +if "%1" == "--program-prefix" goto :pprefix +if "%1" == "--program-suffix" goto :suffix +if "%1" == "--program-name" goto :installname +if "%1" == "--install-name" goto :installname +if "%1" == "--so-name" goto :soname +if "%1" == "--enable-install-doc" goto :enable-rdoc +if "%1" == "--disable-install-doc" goto :disable-rdoc +if "%1" == "--enable-debug-env" goto :enable-debug-env +if "%1" == "--disable-debug-env" goto :disable-debug-env +if "%1" == "--enable-rubygems" goto :enable-rubygems +if "%1" == "--disable-rubygems" goto :disable-rubygems +if "%1" == "--extout" goto :extout +if "%1" == "--path" goto :path +if "%1" == "--with-baseruby" goto :baseruby +if "%1" == "--with-ntver" goto :ntver +if "%1" == "--without-ext" goto :witharg +if "%1" == "--without-extensions" goto :witharg +if "%opt:~0,10%" == "--without-" goto :withoutarg +if "%opt:~0,7%" == "--with-" goto :witharg +if "%1" == "-h" goto :help +if "%1" == "--help" goto :help + if "%opt:~0,1%" == "-" ( + echo>>confargs.tmp %1 \ + set witharg= + ) else if "%witharg" == "" ( + echo>>confargs.tmp %1 \ + ) else ( + echo>>confargs.tmp ,%1\ + ) + shift +goto :loop +:srcdir + echo>> ~tmp~.mak "srcdir=%~2" \ + echo>>confargs.tmp --srcdir=%2 \ + shift + shift +goto :loop +:prefix + echo>> ~tmp~.mak "prefix=%~2" \ + echo>>confargs.tmp %1=%2 \ + shift + shift +goto :loop +:pprefix + echo>> ~tmp~.mak "PROGRAM_PREFIX=%~2" \ + echo>>confargs.tmp %1=%2 \ + shift + shift +goto :loop +:suffix + echo>> ~tmp~.mak "PROGRAM_SUFFIX=%~2" \ + echo>>confargs.tmp %1=%2 \ + shift + shift +goto :loop +:installname + echo>> ~tmp~.mak "RUBY_INSTALL_NAME=%~2" \ + echo>>confargs.tmp %1=%2 \ + shift + shift +goto :loop +:soname + echo>> ~tmp~.mak "RUBY_SO_NAME=%~2" \ + echo>>confargs.tmp %1=%2 \ + shift + shift +goto :loop +:target + echo>> ~tmp~.mak "%~2" \ + echo>>confargs.tmp --target=%2 \ + if "%~2" == "x64-mswin64" goto target2 + if NOT "%~2" == "ia64-mswin64" goto target3 +:target2 + echo>> ~tmp~.mak "TARGET_OS=mswin64" \ +:target3 + shift + shift +goto :loop +:extstatic + echo>> ~tmp~.mak "EXTSTATIC=static" \ + echo>>confargs.tmp %1 \ + shift +goto :loop +:enable-rdoc + echo>> ~tmp~.mak "RDOCTARGET=rdoc" \ + echo>>confargs.tmp %1 \ + shift +goto :loop +:disable-rdoc + echo>> ~tmp~.mak "RDOCTARGET=nodoc" \ + echo>>confargs.tmp %1 \ + shift +goto :loop +:enable-debug-env + echo>> ~tmp~.mak "ENABLE_DEBUG_ENV=yes" \ + echo>>confargs.tmp %1 \ + shift +goto :loop +:disable-debug-env + echo>> ~tmp~.mak "ENABLE_DEBUG_ENV=no" \ + echo>>confargs.tmp %1 \ + shift +goto :loop +:enable-rubygems + echo>> ~tmp~.mak "USE_RUBYGEMS=YES" \ + echo>>confargs.tmp %1 \ + shift +goto :loop +:disable-rubygems + echo>> ~tmp~.mak "USE_RUBYGEMS=NO" \ + echo>>confargs.tmp %1 \ + shift +goto :loop +:ntver + echo>> ~tmp~.mak "NTVER=%~2" \ + echo>>confargs.tmp %1=%2 \ + shift + shift +goto :loop +:extout + echo>> ~tmp~.mak "EXTOUT=%~2" \ + echo>>confargs.tmp %1=%2 \ + shift + shift +goto :loop +:path + echo>>pathlist.tmp %~2;\ + echo>>confargs.tmp %1=%2 \ + shift + shift +goto :loop +:baseruby + echo>> ~tmp~.mak "BASERUBY=%~2" \ + echo>>confargs.tmp %1=%2 \ + shift + shift +goto :loop +:witharg + echo>>confargs.tmp %1=%2\ + set witharg=1 + shift + shift +goto :loop +:withoutarg + echo>>confargs.tmp %1 \ + shift +goto :loop +:help + echo Configuration: + echo --help display this help + echo --srcdir=DIR find the sources in DIR [configure dir or `..'] + echo Installation directories: + echo --prefix=PREFIX install files in PREFIX [/usr] + echo System types: + echo --target=TARGET configure for TARGET [i386-mswin32] + echo Optional Package: + echo --with-baseruby=RUBY use RUBY as baseruby [ruby] + echo --with-static-linked-ext link external modules statically + echo --with-ext="a,b,..." use extensions a, b, ... + echo --without-ext="a,b,..." ignore extensions a, b, ... + echo --disable-install-doc do not install rdoc indexes during install + echo --with-ntver=0xXXXX target NT version (shouldn't use with old SDK) + del *.tmp + del ~tmp~.mak +goto :exit +:end +echo>> ~tmp~.mak WIN32DIR=$(@D:\=/) +echo.>>confargs.tmp +echo>confargs.c #define $ $$ +echo>>confargs.c !ifndef CONFIGURE_ARGS +type>>confargs.c confargs.tmp +echo>>confargs.c configure_args = CONFIGURE_ARGS +echo>>confargs.c !endif +echo>>confargs.c #undef $ +if exist pathlist.tmp echo>>confargs.c #define PATH_LIST \ +if exist pathlist.tmp type>>confargs.c pathlist.tmp +if exist pathlist.tmp echo.>>confargs.c +if exist pathlist.tmp echo>>confargs.c pathlist = PATH_LIST +cl -EP confargs.c > ~setup~.mak 2>nul +if exist pathlist.tmp echo>>~setup~.mak PATH = $(pathlist:;=/bin;)$(PATH) +if exist pathlist.tmp echo>>~setup~.mak INCLUDE = $(pathlist:;=/include;) +if exist pathlist.tmp echo>>~setup~.mak LIB = $(pathlist:;=/lib;) +type>>~setup~.mak ~tmp~.mak +del *.tmp > nul +del ~tmp~.mak > nul +echo>>~setup~.mak @if exist Makefile.old del Makefile.old +echo>>~setup~.mak @if exist Makefile ren Makefile Makefile.old +echo>>~setup~.mak @ren Makefile.new Makefile +nmake -alf ~setup~.mak MAKEFILE=Makefile.new +:exit +@endlocal diff --git a/jni/ruby/win32/dir.h b/jni/ruby/win32/dir.h new file mode 100644 index 0000000..0e1bff0 --- /dev/null +++ b/jni/ruby/win32/dir.h @@ -0,0 +1,45 @@ +#ifndef RUBY_WIN32_DIR_H +#define RUBY_WIN32_DIR_H + +#ifdef __BORLANDC__ +# ifndef WIN32_DIR_H_ +# define WIN32_DIR_H_ +# include +# endif +#endif + +struct direct +{ + long d_namlen; + ino_t d_ino; + char *d_name; + char d_isdir; /* directory */ + char d_isrep; /* reparse point */ +}; +typedef struct { + WCHAR *start; + WCHAR *curr; + long size; + long nfiles; + long loc; /* [0, nfiles) */ + struct direct dirstr; + char *bits; /* used for d_isdir and d_isrep */ +} DIR; + + +DIR* rb_w32_opendir(const char*); +DIR* rb_w32_uopendir(const char*); +struct direct* rb_w32_readdir(DIR *, rb_encoding *); +long rb_w32_telldir(DIR *); +void rb_w32_seekdir(DIR *, long); +void rb_w32_rewinddir(DIR *); +void rb_w32_closedir(DIR *); + +#define opendir(s) rb_w32_opendir((s)) +#define readdir(d) rb_w32_readdir((d), 0) +#define telldir(d) rb_w32_telldir((d)) +#define seekdir(d, l) rb_w32_seekdir((d), (l)) +#define rewinddir(d) rb_w32_rewinddir((d)) +#define closedir(d) rb_w32_closedir((d)) + +#endif /* RUBY_WIN32_DIR_H */ diff --git a/jni/ruby/win32/enc-setup.mak b/jni/ruby/win32/enc-setup.mak new file mode 100644 index 0000000..44345a2 --- /dev/null +++ b/jni/ruby/win32/enc-setup.mak @@ -0,0 +1,10 @@ +encs: BUILTIN_ENCOBJS BUILTIN_TRANSOBJS +BUILTIN_ENCOBJS BUILTIN_TRANSOBJS: $(srcdir)/enc/Makefile.in + +!include $(srcdir)/enc/Makefile.in + +BUILTIN_ENCOBJS: + @echo BUILTIN_ENCOBJS = $(BUILTIN_ENCS:.c=.obj) >> $(MAKEFILE) + +BUILTIN_TRANSOBJS: + @echo BUILTIN_TRANSOBJS = $(BUILTIN_TRANSES:.trans=.obj) >> $(MAKEFILE) diff --git a/jni/ruby/win32/file.c b/jni/ruby/win32/file.c new file mode 100644 index 0000000..38b3d12 --- /dev/null +++ b/jni/ruby/win32/file.c @@ -0,0 +1,682 @@ +#include "ruby/ruby.h" +#include "ruby/encoding.h" +#include "ruby/thread.h" +#include "internal.h" +#include +#include +#include + +#ifndef INVALID_FILE_ATTRIBUTES +# define INVALID_FILE_ATTRIBUTES ((DWORD)-1) +#endif + +/* cache 'encoding name' => 'code page' into a hash */ +static struct code_page_table { + USHORT *table; + unsigned int count; +} rb_code_page; + +#define IS_DIR_SEPARATOR_P(c) (c == L'\\' || c == L'/') +#define IS_DIR_UNC_P(c) (IS_DIR_SEPARATOR_P(c[0]) && IS_DIR_SEPARATOR_P(c[1])) + +/* MultiByteToWideChar() doesn't work with code page 51932 */ +#define INVALID_CODE_PAGE 51932 +#define PATH_BUFFER_SIZE MAX_PATH * 2 + +#define insecure_obj_p(obj, level) ((level) >= 4 || ((level) > 0 && OBJ_TAINTED(obj))) + +/* defined in win32/win32.c */ +#define system_code_page rb_w32_filecp +#define mbstr_to_wstr rb_w32_mbstr_to_wstr +#define wstr_to_mbstr rb_w32_wstr_to_mbstr +UINT rb_w32_filecp(void); +WCHAR *rb_w32_mbstr_to_wstr(UINT, const char *, int, long *); +char *rb_w32_wstr_to_mbstr(UINT, const WCHAR *, int, long *); + +static inline void +replace_wchar(wchar_t *s, int find, int replace) +{ + while (*s != 0) { + if (*s == find) + *s = replace; + s++; + } +} + +/* + Return user's home directory using environment variables combinations. + Memory allocated by this function should be manually freed afterwards. + + Try: + HOME, HOMEDRIVE + HOMEPATH and USERPROFILE environment variables + TODO: Special Folders - Profile and Personal +*/ +static wchar_t * +home_dir(void) +{ + wchar_t *buffer = NULL; + size_t buffer_len = 0, len = 0; + size_t home_env = 0; + + /* + GetEnvironmentVariableW when used with NULL will return the required + buffer size and its terminating character. + http://msdn.microsoft.com/en-us/library/windows/desktop/ms683188(v=vs.85).aspx + */ + + if ((len = GetEnvironmentVariableW(L"HOME", NULL, 0)) != 0) { + buffer_len = len; + home_env = 1; + } + else if ((len = GetEnvironmentVariableW(L"HOMEDRIVE", NULL, 0)) != 0) { + buffer_len = len; + if ((len = GetEnvironmentVariableW(L"HOMEPATH", NULL, 0)) != 0) { + buffer_len += len; + home_env = 2; + } + else { + buffer_len = 0; + } + } + else if ((len = GetEnvironmentVariableW(L"USERPROFILE", NULL, 0)) != 0) { + buffer_len = len; + home_env = 3; + } + + /* allocate buffer */ + if (home_env) + buffer = (wchar_t *)xmalloc(buffer_len * sizeof(wchar_t)); + + switch (home_env) { + case 1: + /* HOME */ + GetEnvironmentVariableW(L"HOME", buffer, buffer_len); + break; + case 2: + /* HOMEDRIVE + HOMEPATH */ + len = GetEnvironmentVariableW(L"HOMEDRIVE", buffer, buffer_len); + GetEnvironmentVariableW(L"HOMEPATH", buffer + len, buffer_len - len); + break; + case 3: + /* USERPROFILE */ + GetEnvironmentVariableW(L"USERPROFILE", buffer, buffer_len); + break; + default: + break; + } + + if (home_env) { + /* sanitize backslashes with forwardslashes */ + replace_wchar(buffer, L'\\', L'/'); + + return buffer; + } + + return NULL; +} + +/* Remove trailing invalid ':$DATA' of the path. */ +static inline size_t +remove_invalid_alternative_data(wchar_t *wfullpath, size_t size) +{ + static const wchar_t prime[] = L":$DATA"; + enum { prime_len = (sizeof(prime) / sizeof(wchar_t)) -1 }; + + if (size <= prime_len || _wcsnicmp(wfullpath + size - prime_len, prime, prime_len) != 0) + return size; + + /* alias of stream */ + /* get rid of a bug of x64 VC++ */ + if (wfullpath[size - (prime_len + 1)] == ':') { + /* remove trailing '::$DATA' */ + size -= prime_len + 1; /* prime */ + wfullpath[size] = L'\0'; + } + else { + /* remove trailing ':$DATA' of paths like '/aa:a:$DATA' */ + wchar_t *pos = wfullpath + size - (prime_len + 1); + while (!IS_DIR_SEPARATOR_P(*pos) && pos != wfullpath) { + if (*pos == L':') { + size -= prime_len; /* alternative */ + wfullpath[size] = L'\0'; + break; + } + pos--; + } + } + return size; +} + +void rb_enc_foreach_name(int (*func)(st_data_t name, st_data_t idx, st_data_t arg), st_data_t arg); + +static int +code_page_i(st_data_t name, st_data_t idx, st_data_t arg) +{ + const char *n = (const char *)name; + if (strncmp("CP", n, 2) == 0) { + int code_page = atoi(n + 2); + if (code_page != 0) { + struct code_page_table *cp = (struct code_page_table *)arg; + unsigned int count = cp->count; + USHORT *table = cp->table; + if (count <= idx) { + unsigned int i = count; + cp->count = count = (((idx + 4) & ~31) | 28); + cp->table = table = realloc(table, count * sizeof(*table)); + while (i < count) table[i++] = INVALID_CODE_PAGE; + } + table[idx] = (USHORT)code_page; + } + } + return ST_CONTINUE; +} + +/* + Return code page number of the encoding. + Cache code page into a hash for performance since finding the code page in + Encoding#names is slow. +*/ +static UINT +code_page(rb_encoding *enc) +{ + int enc_idx; + + if (!enc) + return system_code_page(); + + enc_idx = rb_enc_to_index(enc); + + /* map US-ASCII and ASCII-8bit as code page 1252 (us-ascii) */ + if (enc_idx == rb_usascii_encindex() || enc_idx == rb_ascii8bit_encindex()) { + return 1252; + } + if (enc_idx == rb_utf8_encindex()) { + return CP_UTF8; + } + + if (0 <= enc_idx && (unsigned int)enc_idx < rb_code_page.count) + return rb_code_page.table[enc_idx]; + + return INVALID_CODE_PAGE; +} + +#define fix_string_encoding(str, encoding) rb_str_conv_enc((str), (encoding), rb_utf8_encoding()) + +/* + Replace the last part of the path to long name. + We try to avoid to call FindFirstFileW() since it takes long time. +*/ +static inline size_t +replace_to_long_name(wchar_t **wfullpath, size_t size, int heap) +{ + WIN32_FIND_DATAW find_data; + HANDLE find_handle; + + /* + Skip long name conversion if the path is already long name. + Short name is 8.3 format. + http://en.wikipedia.org/wiki/8.3_filename + This check can be skipped for directory components that have file + extensions longer than 3 characters, or total lengths longer than + 12 characters. + http://msdn.microsoft.com/en-us/library/windows/desktop/aa364980(v=vs.85).aspx + */ + size_t const max_short_name_size = 8 + 1 + 3; + size_t const max_extension_size = 3; + size_t path_len = 1, extension_len = 0; + wchar_t *pos = *wfullpath; + + if (size == 3 && pos[1] == L':' && pos[2] == L'\\' && pos[3] == L'\0') { + /* root path doesn't need short name expansion */ + return size; + } + + /* skip long name conversion if path contains wildcard characters */ + if (wcspbrk(pos, L"*?")) { + return size; + } + + pos = *wfullpath + size - 1; + while (!IS_DIR_SEPARATOR_P(*pos) && pos != *wfullpath) { + if (!extension_len && *pos == L'.') { + extension_len = path_len - 1; + } + if (path_len > max_short_name_size || extension_len > max_extension_size) { + return size; + } + path_len++; + pos--; + } + + find_handle = FindFirstFileW(*wfullpath, &find_data); + if (find_handle != INVALID_HANDLE_VALUE) { + size_t trail_pos = wcslen(*wfullpath); + size_t file_len = wcslen(find_data.cFileName); + + FindClose(find_handle); + while (trail_pos > 0) { + if (IS_DIR_SEPARATOR_P((*wfullpath)[trail_pos])) + break; + trail_pos--; + } + size = trail_pos + 1 + file_len; + if ((size + 1) > sizeof(*wfullpath) / sizeof((*wfullpath)[0])) { + wchar_t *buf = (wchar_t *)xmalloc((size + 1) * sizeof(wchar_t)); + wcsncpy(buf, *wfullpath, trail_pos + 1); + if (heap) + xfree(*wfullpath); + *wfullpath = buf; + } + wcsncpy(*wfullpath + trail_pos + 1, find_data.cFileName, file_len + 1); + } + return size; +} + +static inline size_t +user_length_in_path(const wchar_t *wuser, size_t len) +{ + size_t i; + + for (i = 0; i < len && !IS_DIR_SEPARATOR_P(wuser[i]); i++) + ; + + return i; +} + +static VALUE +append_wstr(VALUE dst, const wchar_t *ws, size_t len, UINT cp, UINT path_cp, rb_encoding *path_encoding) +{ + long olen, nlen = (long)len; + + if (cp == path_cp) { + nlen = WideCharToMultiByte(cp, 0, ws, len, NULL, 0, NULL, NULL); + olen = RSTRING_LEN(dst); + rb_str_modify_expand(dst, nlen); + WideCharToMultiByte(cp, 0, ws, len, RSTRING_PTR(dst) + olen, nlen, NULL, NULL); + rb_enc_associate(dst, path_encoding); + rb_str_set_len(dst, olen + nlen); + } + else { + const int replaceflags = ECONV_UNDEF_REPLACE|ECONV_INVALID_REPLACE; + char *utf8str = wstr_to_mbstr(CP_UTF8, ws, (int)len, &nlen); + rb_econv_t *ec = rb_econv_open("UTF-8", rb_enc_name(path_encoding), replaceflags); + dst = rb_econv_append(ec, utf8str, nlen, dst, replaceflags); + rb_econv_close(ec); + free(utf8str); + } + return dst; +} + +VALUE +rb_file_expand_path_internal(VALUE fname, VALUE dname, int abs_mode, int long_name, VALUE result) +{ + size_t size = 0, whome_len = 0; + size_t buffer_len = 0; + long wpath_len = 0, wdir_len = 0; + char *fullpath = NULL; + wchar_t *wfullpath = NULL, *wpath = NULL, *wpath_pos = NULL; + wchar_t *wdir = NULL, *wdir_pos = NULL; + wchar_t *whome = NULL, *buffer = NULL, *buffer_pos = NULL; + UINT path_cp, cp; + VALUE path = fname, dir = dname; + wchar_t wfullpath_buffer[PATH_BUFFER_SIZE]; + wchar_t path_drive = L'\0', dir_drive = L'\0'; + int ignore_dir = 0; + rb_encoding *path_encoding; + int tainted = 0; + + /* tainted if path is tainted */ + tainted = OBJ_TAINTED(path); + + /* get path encoding */ + if (NIL_P(dir)) { + path_encoding = rb_enc_get(path); + } + else { + path_encoding = rb_enc_check(path, dir); + } + + cp = path_cp = code_page(path_encoding); + + /* workaround invalid codepage */ + if (path_cp == INVALID_CODE_PAGE) { + cp = CP_UTF8; + if (!NIL_P(path)) { + path = fix_string_encoding(path, path_encoding); + } + } + + /* convert char * to wchar_t */ + if (!NIL_P(path)) { + wpath = mbstr_to_wstr(cp, RSTRING_PTR(path), (int)RSTRING_LEN(path), &wpath_len); + wpath_pos = wpath; + } + + /* determine if we need the user's home directory */ + /* expand '~' only if NOT rb_file_absolute_path() where `abs_mode` is 1 */ + if (abs_mode == 0 && wpath_len > 0 && wpath_pos[0] == L'~' && + (wpath_len == 1 || IS_DIR_SEPARATOR_P(wpath_pos[1]))) { + /* tainted if expanding '~' */ + tainted = 1; + + whome = home_dir(); + if (whome == NULL) { + xfree(wpath); + rb_raise(rb_eArgError, "couldn't find HOME environment -- expanding `~'"); + } + whome_len = wcslen(whome); + + if (PathIsRelativeW(whome) && !(whome_len >= 2 && IS_DIR_UNC_P(whome))) { + xfree(wpath); + xfree(whome); + rb_raise(rb_eArgError, "non-absolute home"); + } + + if (path_cp == INVALID_CODE_PAGE || rb_enc_str_asciionly_p(path)) { + /* use filesystem encoding if expanding home dir */ + path_encoding = rb_filesystem_encoding(); + cp = path_cp = system_code_page(); + } + + /* ignores dir since we are expanding home */ + ignore_dir = 1; + + /* exclude ~ from the result */ + wpath_pos++; + wpath_len--; + + /* exclude separator if present */ + if (wpath_len && IS_DIR_SEPARATOR_P(wpath_pos[0])) { + wpath_pos++; + wpath_len--; + } + } + else if (wpath_len >= 2 && wpath_pos[1] == L':') { + if (wpath_len >= 3 && IS_DIR_SEPARATOR_P(wpath_pos[2])) { + /* ignore dir since path contains a drive letter and a root slash */ + ignore_dir = 1; + } + else { + /* determine if we ignore dir or not later */ + path_drive = wpath_pos[0]; + wpath_pos += 2; + wpath_len -= 2; + } + } + else if (abs_mode == 0 && wpath_len >= 2 && wpath_pos[0] == L'~') { + result = rb_str_new_cstr("can't find user "); + result = append_wstr(result, wpath_pos + 1, user_length_in_path(wpath_pos + 1, wpath_len - 1), + cp, path_cp, path_encoding); + + if (wpath) + xfree(wpath); + + rb_exc_raise(rb_exc_new_str(rb_eArgError, result)); + } + + /* convert dir */ + if (!ignore_dir && !NIL_P(dir)) { + /* fix string encoding */ + if (path_cp == INVALID_CODE_PAGE) { + dir = fix_string_encoding(dir, path_encoding); + } + + /* convert char * to wchar_t */ + if (!NIL_P(dir)) { + wdir = mbstr_to_wstr(cp, RSTRING_PTR(dir), (int)RSTRING_LEN(dir), &wdir_len); + wdir_pos = wdir; + } + + if (abs_mode == 0 && wdir_len > 0 && wdir_pos[0] == L'~' && + (wdir_len == 1 || IS_DIR_SEPARATOR_P(wdir_pos[1]))) { + /* tainted if expanding '~' */ + tainted = 1; + + whome = home_dir(); + if (whome == NULL) { + free(wpath); + free(wdir); + rb_raise(rb_eArgError, "couldn't find HOME environment -- expanding `~'"); + } + whome_len = wcslen(whome); + + if (PathIsRelativeW(whome) && !(whome_len >= 2 && IS_DIR_UNC_P(whome))) { + free(wpath); + free(wdir); + xfree(whome); + rb_raise(rb_eArgError, "non-absolute home"); + } + + /* exclude ~ from the result */ + wdir_pos++; + wdir_len--; + + /* exclude separator if present */ + if (wdir_len && IS_DIR_SEPARATOR_P(wdir_pos[0])) { + wdir_pos++; + wdir_len--; + } + } + else if (wdir_len >= 2 && wdir[1] == L':') { + dir_drive = wdir[0]; + if (wpath_len && IS_DIR_SEPARATOR_P(wpath_pos[0])) { + wdir_len = 2; + } + } + else if (wdir_len >= 2 && IS_DIR_UNC_P(wdir)) { + /* UNC path */ + if (wpath_len && IS_DIR_SEPARATOR_P(wpath_pos[0])) { + /* cut the UNC path tail to '//host/share' */ + long separators = 0; + long pos = 2; + while (pos < wdir_len && separators < 2) { + if (IS_DIR_SEPARATOR_P(wdir[pos])) { + separators++; + } + pos++; + } + if (separators == 2) + wdir_len = pos - 1; + } + } + else if (abs_mode == 0 && wdir_len >= 2 && wdir_pos[0] == L'~') { + result = rb_str_new_cstr("can't find user "); + result = append_wstr(result, wdir_pos + 1, user_length_in_path(wdir_pos + 1, wdir_len - 1), + cp, path_cp, path_encoding); + if (wpath) + free(wpath); + + if (wdir) + free(wdir); + + rb_exc_raise(rb_exc_new_str(rb_eArgError, result)); + } + } + + /* determine if we ignore dir or not */ + if (!ignore_dir && path_drive && dir_drive) { + if (towupper(path_drive) != towupper(dir_drive)) { + /* ignore dir since path drive is different from dir drive */ + ignore_dir = 1; + wdir_len = 0; + dir_drive = 0; + } + } + + if (!ignore_dir && wpath_len >= 2 && IS_DIR_UNC_P(wpath)) { + /* ignore dir since path has UNC root */ + ignore_dir = 1; + wdir_len = 0; + } + else if (!ignore_dir && wpath_len >= 1 && IS_DIR_SEPARATOR_P(wpath[0]) && + !dir_drive && !(wdir_len >= 2 && IS_DIR_UNC_P(wdir))) { + /* ignore dir since path has root slash and dir doesn't have drive or UNC root */ + ignore_dir = 1; + wdir_len = 0; + } + + buffer_len = wpath_len + 1 + wdir_len + 1 + whome_len + 1; + + buffer = buffer_pos = (wchar_t *)xmalloc((buffer_len + 1) * sizeof(wchar_t)); + + /* add home */ + if (whome_len) { + wcsncpy(buffer_pos, whome, whome_len); + buffer_pos += whome_len; + } + + /* Add separator if required */ + if (whome_len && wcsrchr(L"\\/:", buffer_pos[-1]) == NULL) { + buffer_pos[0] = L'\\'; + buffer_pos++; + } + else if (!dir_drive && path_drive) { + *buffer_pos++ = path_drive; + *buffer_pos++ = L':'; + } + + if (wdir_len) { + /* tainted if dir is used and dir is tainted */ + if (!tainted && OBJ_TAINTED(dir)) + tainted = 1; + + wcsncpy(buffer_pos, wdir_pos, wdir_len); + buffer_pos += wdir_len; + } + + /* add separator if required */ + if (wdir_len && wcsrchr(L"\\/:", buffer_pos[-1]) == NULL) { + buffer_pos[0] = L'\\'; + buffer_pos++; + } + + /* now deal with path */ + if (wpath_len) { + wcsncpy(buffer_pos, wpath_pos, wpath_len); + buffer_pos += wpath_len; + } + + /* GetFullPathNameW requires at least "." to determine current directory */ + if (wpath_len == 0) { + buffer_pos[0] = L'.'; + buffer_pos++; + } + + /* Ensure buffer is NULL terminated */ + buffer_pos[0] = L'\0'; + + /* tainted if path is relative */ + if (!tainted && PathIsRelativeW(buffer) && !(buffer_len >= 2 && IS_DIR_UNC_P(buffer))) + tainted = 1; + + /* FIXME: Make this more robust */ + /* Determine require buffer size */ + size = GetFullPathNameW(buffer, PATH_BUFFER_SIZE, wfullpath_buffer, NULL); + if (size > PATH_BUFFER_SIZE) { + /* allocate more memory than alloted originally by PATH_BUFFER_SIZE */ + wfullpath = (wchar_t *)xmalloc(size * sizeof(wchar_t)); + size = GetFullPathNameW(buffer, size, wfullpath, NULL); + } + else { + wfullpath = wfullpath_buffer; + } + + /* Remove any trailing slashes */ + if (IS_DIR_SEPARATOR_P(wfullpath[size - 1]) && + wfullpath[size - 2] != L':' && + !(size == 2 && IS_DIR_UNC_P(wfullpath))) { + size -= 1; + wfullpath[size] = L'\0'; + } + + /* Remove any trailing dot */ + if (wfullpath[size - 1] == L'.') { + size -= 1; + wfullpath[size] = L'\0'; + } + + /* removes trailing invalid ':$DATA' */ + size = remove_invalid_alternative_data(wfullpath, size); + + /* Replace the trailing path to long name */ + if (long_name) + size = replace_to_long_name(&wfullpath, size, (wfullpath != wfullpath_buffer)); + + /* sanitize backslashes with forwardslashes */ + replace_wchar(wfullpath, L'\\', L'/'); + + /* convert to VALUE and set the path encoding */ + rb_str_set_len(result, 0); + result = append_wstr(result, wfullpath, size, cp, path_cp, path_encoding); + + /* makes the result object tainted if expanding tainted strings or returning modified path */ + if (tainted) + OBJ_TAINT(result); + + /* TODO: better cleanup */ + if (buffer) + xfree(buffer); + + if (wpath) + free(wpath); + + if (wdir) + free(wdir); + + if (whome) + xfree(whome); + + if (wfullpath && wfullpath != wfullpath_buffer) + xfree(wfullpath); + + if (fullpath) + xfree(fullpath); + + rb_enc_associate(result, path_encoding); + return result; +} + +static void * +loadopen_func(void *wpath) +{ + return (void *)CreateFileW(wpath, GENERIC_READ, + FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); +} + +int +rb_file_load_ok(const char *path) +{ + DWORD attr; + int ret = 1; + long len; + wchar_t* wpath; + + wpath = mbstr_to_wstr(CP_UTF8, path, -1, &len); + if (!wpath) return 0; + + attr = GetFileAttributesW(wpath); + if (attr == INVALID_FILE_ATTRIBUTES || + (attr & FILE_ATTRIBUTE_DIRECTORY)) { + ret = 0; + } + else { + HANDLE h = (HANDLE)rb_thread_call_without_gvl(loadopen_func, (void *)wpath, + RUBY_UBF_IO, 0); + if (h != INVALID_HANDLE_VALUE) { + CloseHandle(h); + } + else { + ret = 0; + } + } + free(wpath); + return ret; +} + +void +Init_w32_codepage(void) +{ + if (rb_code_page.count) return; + rb_enc_foreach_name(code_page_i, (st_data_t)&rb_code_page); +} diff --git a/jni/ruby/win32/ifchange.bat b/jni/ruby/win32/ifchange.bat new file mode 100755 index 0000000..ed10914 --- /dev/null +++ b/jni/ruby/win32/ifchange.bat @@ -0,0 +1,95 @@ +@echo off +:: usage: ifchange target temporary + +set timestamp= +set keepsuffix= +set empty= +:optloop +for %%I in (%1) do set opt=%%~I +if "%opt%" == "--timestamp" ( + set timestamp=. + shift + goto :optloop +) else if "%opt:~0,12%" == "--timestamp=" ( + set timestamp=%opt:~12% + shift + goto :optloop +) else if "%opt%" == "--keep" ( + set keepsuffix=.old + shift + goto :optloop +) else if "%opt:~0,7%" == "--keep=" ( + set keepsuffix=%opt:~7% + shift + goto :optloop +) else if "%opt%" == "--empty" ( + set empty=yes + shift + goto :optloop +) +if "%opt%" == "" goto :end + +set dest=%1 +set src=%2 +set dest=%dest:/=\% +set src=%src:/=\% +if not "%dest%" == "" if not "%dest%" == "%%dest:/=\%%" goto :nt + +if not exist %2 goto :end + +:: check if fc.exe works. +echo foo > conftst1.tmp +echo bar > conftst2.tmp +fc.exe conftst1.tmp conftst2.tmp > nul +if not errorlevel 1 goto :brokenfc +del conftst1.tmp > nul +del conftst2.tmp > nul + +:: target does not exist or new file differs from it. +if not exist %1 goto :update +fc.exe %1 %2 > nul +if errorlevel 1 goto :update + +:unchange +echo %1 unchanged. +del %2 +goto :end + +:brokenfc +del conftest1.tmp > nul +del conftest2.tmp > nul +echo FC.EXE does not work properly. +echo assuming %1 should be changed. + +:update +echo %1 updated. +:: if exist %1 del %1 +dir /b %2 +if "%keepsuffix%" != "" %1 %1%keepsuffix% +copy %2 %1 +del %2 +goto :end + +:nt +if exist %dest% ( + if not exist %src% goto :nt_unchanged1 + if "%empty%" == "" for %%I in (%src%) do if %%~zI == 0 goto :nt_unchanged + fc.exe %dest% %src% > nul && ( + :nt_unchanged + del %src% + :nt_unchanged1 + for %%I in (%1) do echo %%~I unchanged + goto :nt_end + ) +) +for %%I in (%1) do echo %%~I updated +copy %src% %dest% > nul +del %src% + +:nt_end +if "%timestamp%" == "" goto :end + if "%timestamp%" == "." ( + for %%I in ("%dest%") do set timestamp=%%~dpI.time.%%~nxI + ) + goto :end > "%timestamp%" +:end diff --git a/jni/ruby/win32/makedirs.bat b/jni/ruby/win32/makedirs.bat new file mode 100755 index 0000000..13740d8 --- /dev/null +++ b/jni/ruby/win32/makedirs.bat @@ -0,0 +1,3 @@ +@echo off +setlocal EnableExtensions +for %%I in (%*) do if not exist "%%~I/." mkdir "%%~I" diff --git a/jni/ruby/win32/mkexports.rb b/jni/ruby/win32/mkexports.rb new file mode 100755 index 0000000..ab29fc1 --- /dev/null +++ b/jni/ruby/win32/mkexports.rb @@ -0,0 +1,172 @@ +#!./miniruby -sI. + +$name = $library = $description = nil + +module RbConfig + autoload :CONFIG, "./rbconfig" +end + +class Exports + @@subclass = [] + def self.inherited(klass) + @@subclass << [/#{klass.name.sub(/.*::/, '').downcase}/i, klass] + end + + def self.create(*args, &block) + platform = RUBY_PLATFORM + pat, klass = @@subclass.find {|p, k| p =~ platform} + unless klass + raise ArgumentError, "unsupported platform: #{platform}" + end + klass.new(*args, &block) + end + + def self.extract(objs, *rest) + create(objs).exports(*rest) + end + + def self.output(output = $output, &block) + if output + open(output, 'wb', &block) + else + yield STDOUT + end + end + + def initialize(objs) + syms = {} + winapis = {} + syms["ruby_sysinit_real"] = "ruby_sysinit" + each_export(objs) do |internal, export| + syms[internal] = export + winapis[$1] = internal if /^_?(rb_w32_\w+)(?:@\d+)?$/ =~ internal + end + incdir = File.join(File.dirname(File.dirname(__FILE__)), "include/ruby") + read_substitution(incdir+"/win32.h", syms, winapis) + read_substitution(incdir+"/subst.h", syms, winapis) + syms["rb_w32_vsnprintf"] ||= "ruby_vsnprintf" + syms["rb_w32_snprintf"] ||= "ruby_snprintf" + @syms = syms + end + + def read_substitution(header, syms, winapis) + IO.foreach(header) do |line| + if /^#define (\w+)\((.*?)\)\s+(?:\(void\))?(rb_w32_\w+)\((.*?)\)\s*$/ =~ line and + $2.delete(" ") == $4.delete(" ") + export, internal = $1, $3 + if syms[internal] or internal = winapis[internal] + syms[forwarding(internal, export)] = internal + end + end + end + end + + def exports(name = $name, library = $library, description = $description) + exports = [] + if name + exports << "Name " + name + elsif library + exports << "Library " + library + end + exports << "Description " + description.dump if description + exports << "VERSION #{RbConfig::CONFIG['MAJOR']}.#{RbConfig::CONFIG['MINOR']}" + exports << "EXPORTS" << symbols() + exports + end + + private + def forwarding(internal, export) + internal.sub(/^[^@]+/, "\\1#{export}") + end + + def each_export(objs) + end + + def objdump(objs, &block) + if objs.empty? + $stdin.each_line(&block) + else + each_line(objs, &block) + end + end + + def symbols() + @syms.sort.collect {|k, v| v ? v == true ? "#{k} DATA" : "#{k}=#{v}" : k} + end +end + +class Exports::Mswin < Exports + def each_line(objs, &block) + IO.popen(%w"dumpbin -symbols -exports" + objs) do |f| + f.each(&block) + end + end + + def each_export(objs) + noprefix = ($arch ||= nil and /^(sh|i\d86)/ !~ $arch) + objs = objs.collect {|s| s.tr('/', '\\')} + filetype = nil + objdump(objs) do |l| + if (filetype = l[/^File Type: (.+)/, 1])..(/^\f/ =~ l) + case filetype + when /OBJECT/, /LIBRARY/ + next if /^[[:xdigit:]]+ 0+ UNDEF / =~ l + next unless /External/ =~ l + next unless l.sub!(/.*?\s(\(\)\s+)?External\s+\|\s+/, '') + is_data = !$1 + if noprefix or /^[@_]/ =~ l + next if /(?!^)@.*@/ =~ l || /@[[:xdigit:]]{8,32}$/ =~ l || + /^_?(?:Init_|.*_threadptr_|DllMain\b)/ =~ l + l.sub!(/^[@_]/, '') if /@\d+$/ !~ l + elsif !l.sub!(/^(\S+) \([^@?\`\']*\)$/, '\1') + next + end + when /DLL/ + next unless l.sub!(/^\s*\d+\s+[[:xdigit:]]+\s+[[:xdigit:]]+\s+/, '') + else + next + end + yield l.strip, is_data + end + end + yield "strcasecmp", "msvcrt.stricmp" + yield "strncasecmp", "msvcrt.strnicmp" + end +end + +class Exports::Cygwin < Exports + def self.nm + @@nm ||= RbConfig::CONFIG["NM"] + end + + def exports(*) + super() + end + + def each_line(objs, &block) + IO.foreach("|#{self.class.nm} --extern --defined #{objs.join(' ')}", &block) + end + + def each_export(objs) + symprefix = RbConfig::CONFIG["SYMBOL_PREFIX"] + symprefix.strip! if symprefix + re = /\s(?:(T)|[[:upper:]])\s#{symprefix}((?!Init_|.*_threadptr_|DllMain\b).*)$/ + objdump(objs) do |l| + next if /@.*@/ =~ l + yield $2, !$1 if re =~ l + end + end +end + +class Exports::Mingw < Exports::Cygwin + def each_export(objs) + super + yield "strcasecmp", "_stricmp" + yield "strncasecmp", "_strnicmp" + end +end + +END { + exports = Exports.extract(ARGV) + Exports.output {|f| f.puts(*exports)} +} diff --git a/jni/ruby/win32/resource.rb b/jni/ruby/win32/resource.rb new file mode 100755 index 0000000..786edb0 --- /dev/null +++ b/jni/ruby/win32/resource.rb @@ -0,0 +1,97 @@ +#!./miniruby -sI. + +require './rbconfig' + +CONFIG = RbConfig::MAKEFILE_CONFIG + +version = RUBY_VERSION.split(/\./) +patch = CONFIG['PATCHLEVEL'] +nversion = (version + [patch.to_i < 0 ? '0' : patch]).join(',') +sversion = version.join('.') + (patch.to_i < 0 ? 'dev' : "p#{patch}") + +$ruby_name ||= CONFIG["RUBY_INSTALL_NAME"] +$rubyw_name ||= CONFIG["RUBYW_INSTALL_NAME"] || $ruby_name.sub(/ruby/, '\&w') +$so_name ||= CONFIG["RUBY_SO_NAME"] + +icons = {} +def icons.find(path) + if File.directory?(path) + Dir.open(File.expand_path(path)) do |d| + d.grep(/\.ico$/i) {|i| self[$`] = i} + end + else + self[File.basename(path, '.ico')] = path + end + self +end + +if ARGV.empty? + icons.find('.') +else + ARGV.each {|i| icons.find(i)} +end + +ruby_icon = rubyw_icon = nil +[$ruby_name, 'ruby'].find do |i| + if i = icons[i] + ruby_icon = "1 ICON DISCARDABLE "+i.dump+"\n" + end +end +[$rubyw_name, 'rubyw'].find do |i| + if i = icons[i] + rubyw_icon = "1 ICON DISCARDABLE "+i.dump+"\n" + end +end +dll_icons = [] +icons.keys.sort.each do |i| + dll_icons << "#{dll_icons.size + 1} ICON DISCARDABLE "+icons[i].dump+"\n" +end + +[ # base name extension file type desc, icons + [$ruby_name, CONFIG["EXEEXT"], 'VFT_APP', 'CUI', ruby_icon], + [$rubyw_name, CONFIG["EXEEXT"], 'VFT_APP', 'GUI', rubyw_icon || ruby_icon], + [$so_name, '.dll', 'VFT_DLL', 'DLL', dll_icons.join], +].each do |base, ext, type, desc, icon| + open(base + '.rc', "w") { |f| + f.binmode if /mingw/ =~ RUBY_PLATFORM + + f.print < +#include +#endif + +#{icon || ''} +VS_VERSION_INFO VERSIONINFO + FILEVERSION #{nversion} + PRODUCTVERSION #{nversion} + FILEFLAGSMASK 0x3fL + FILEFLAGS 0x0L + FILEOS VOS__WINDOWS32 + FILETYPE #{type} + FILESUBTYPE VFT2_UNKNOWN +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "000004b0" + BEGIN + VALUE "Comments", "#{RUBY_RELEASE_DATE}\\0" + VALUE "CompanyName", "http://www.ruby-lang.org/\\0" + VALUE "FileDescription", "Ruby interpreter (#{desc}) #{sversion} [#{RUBY_PLATFORM}]\\0" + VALUE "FileVersion", "#{sversion}\\0" + VALUE "InternalName", "#{base + ext}\\0" + VALUE "LegalCopyright", "Copyright (C) 1993-#{RUBY_RELEASE_DATE[/\d+/]} Yukihiro Matsumoto\\0" + VALUE "OriginalFilename", "#{base + ext}\\0" + VALUE "ProductName", "Ruby interpreter #{sversion} [#{RUBY_PLATFORM}]\\0" + VALUE "ProductVersion", "#{sversion}\\0" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x0, 0x4b0 + END +END +EOF + } +end + diff --git a/jni/ruby/win32/rm.bat b/jni/ruby/win32/rm.bat new file mode 100755 index 0000000..9496441 --- /dev/null +++ b/jni/ruby/win32/rm.bat @@ -0,0 +1,18 @@ +@echo off +:optloop +if "%1" == "-f" shift +if "%1" == "-r" (shift & set recursive=1 & goto :optloop) +if "%recursive%" == "1" goto :recursive +:begin +if "%1" == "" goto :end +set p=%1 +if exist "%p:/=\%" for %%I in ("%p:/=\%") do @del "%%I" +shift +goto :begin +:recursive +if "%1" == "" goto :end +set p=%1 +if exist "%p:/=\%" rd /s /q "%p:/=\%" +shift +goto :recursive +:end diff --git a/jni/ruby/win32/rmdirs.bat b/jni/ruby/win32/rmdirs.bat new file mode 100755 index 0000000..829e93d --- /dev/null +++ b/jni/ruby/win32/rmdirs.bat @@ -0,0 +1,29 @@ +::-*- batch -*- +@echo off +if "%1" == "-p" shift +:begin +if "%1" == "" goto :end + set dir=%1 + shift + set dir=%dir:/=\% + :rmdirs + if not exist "%dir%\." goto :begin + if "%dir%" == "." goto :begin + if "%dir%" == ".." goto :begin + rd "%dir%" 2> nul || goto :begin + :trim_sep + if not /%dir:~-1%/ == /\/ goto :trim_base + set dir=%dir:~0,-1% + if not "%dir%" == "" goto :trim_sep + :trim_base + if /%dir:~-1%/ == /\/ goto :parent + set dir=%dir:~0,-1% + if not "%dir%" == "" goto :trim_base + :parent + set dir=%dir:~0,-1% + if "%dir%" == "" goto :begin + if "%dir:~-1%" == ":" goto :begin + goto :rmdirs +shift +goto :begin +:end diff --git a/jni/ruby/win32/rtname.cmd b/jni/ruby/win32/rtname.cmd new file mode 100644 index 0000000..1f410a0 --- /dev/null +++ b/jni/ruby/win32/rtname.cmd @@ -0,0 +1,18 @@ +@echo off +set rt= +set rtver= +set osver= +for /f "usebackq" %%I in (`dumpbin -dependents %1 ^| findstr -r -i "\&2 + exit 1 +) +for %%i in (a b c d e f g h i j k l m n o p q r s t u v w x y z) do @call set rt=%%rt:%%i=%%i%% +if "%rt%" == "msvcrt" ( + call set rtver=60 +) else ( + call set rtver=%%rt:msvcr=%% + call set rt=msvcr%%rtver%% + call set osver=_%%rtver%% +) +for %%I in ("PLATFORM = $(TARGET_OS)%osver%" "RT = %rt%" "RT_VER = %rtver%") do @echo %%~I diff --git a/jni/ruby/win32/setup.mak b/jni/ruby/win32/setup.mak new file mode 100644 index 0000000..f00418e --- /dev/null +++ b/jni/ruby/win32/setup.mak @@ -0,0 +1,213 @@ +# -*- makefile -*- + +!if "$(srcdir)" != "" +WIN32DIR = $(srcdir)/win32 +!elseif "$(WIN32DIR)" == "win32" +srcdir = . +!elseif "$(WIN32DIR)" == "$(WIN32DIR:/win32=)/win32" +srcdir = $(WIN32DIR:/win32=) +!else +srcdir = $(WIN32DIR)/.. +!endif +!ifndef prefix +prefix = /usr +!endif +BANG = ! +APPEND = echo.>>$(MAKEFILE) +!ifdef MAKEFILE +MAKE = $(MAKE) -f $(MAKEFILE) +!else +MAKEFILE = Makefile +!endif +CPU = PROCESSOR_LEVEL +CC = cl -nologo +CPP = $(CC) -EP + +all: -prologue- -generic- -epilogue- +i386-mswin32: -prologue32- -i386- -epilogue- +i486-mswin32: -prologue32- -i486- -epilogue- +i586-mswin32: -prologue32- -i586- -epilogue- +i686-mswin32: -prologue32- -i686- -epilogue- +alpha-mswin32: -prologue32- -alpha- -epilogue- +x64-mswin64: -prologue64- -x64- -epilogue- +ia64-mswin64: -prologue64- -ia64- -epilogue- + +-prologue-: -basic-vars- -system-vars- -version- -program-name- + +-prologue32-: -basic-vars- -system-vars32- -version- -program-name- + +-prologue64-: -basic-vars- -system-vars64- -version- -program-name- + +-basic-vars-: nul + @type << > $(MAKEFILE) +### Makefile for ruby $(TARGET_OS) ### +MAKE = nmake +srcdir = $(srcdir:\=/) +prefix = $(prefix:\=/) +EXTSTATIC = $(EXTSTATIC) +!if defined(RDOCTARGET) +RDOCTARGET = $(RDOCTARGET) +!endif +!if defined(EXTOUT) +EXTOUT = $(EXTOUT) +!endif +!if defined(BASERUBY) +BASERUBY = $(BASERUBY:/=\) +!endif +!if defined(NTVER) +NTVER = $(NTVER) +!endif +!if defined(USE_RUBYGEMS) +USE_RUBYGEMS = $(USE_RUBYGEMS) +!endif + +<< +!if !defined(BASERUBY) + @for %I in (ruby.exe) do @echo BASERUBY = %~s$$PATH:I>> $(MAKEFILE) + @echo !if "$$(BASERUBY)" == "">> $(MAKEFILE) + @echo BASERUBY = echo executable host ruby is required. use --with-baseruby option.^& exit 1 >> $(MAKEFILE) + @echo HAVE_BASERUBY = no>> $(MAKEFILE) + @echo !else>> $(MAKEFILE) + @echo HAVE_BASERUBY = yes>> $(MAKEFILE) + @echo !endif>> $(MAKEFILE) +!elseif [$(BASERUBY) -eexit 2> nul] == 0 + @echo HAVE_BASERUBY = yes>> $(MAKEFILE) +!else + @echo HAVE_BASERUBY = no>> $(MAKEFILE) +!endif + +-system-vars-: -osname- -runtime- -headers- + +-system-vars32-: -osname32- -runtime- -headers- + +-system-vars64-: -osname64- -runtime- -headers- + +-osname32-: nul + @echo TARGET_OS = mswin32>>$(MAKEFILE) + +-osname64-: nul + @echo TARGET_OS = mswin64>>$(MAKEFILE) + +-osname-: nul + @echo !ifndef TARGET_OS>>$(MAKEFILE) + @($(CC) -c < nul && (echo TARGET_OS = mswin32) || (echo TARGET_OS = mswin64)) >>$(MAKEFILE) +#ifdef _WIN64 +#error +#endif +<< + @echo !endif>>$(MAKEFILE) + @$(WIN32DIR:/=\)\rm.bat conftest.* + +-runtime-: nul + @$(CC) -MD < nul +#include +int main(void) {FILE *volatile f = stdin; return 0;} +<< + @$(WIN32DIR:/=\)\rtname conftest.exe >>$(MAKEFILE) + @$(WIN32DIR:/=\)\rm.bat conftest.* + +-headers-: nul + +check-psapi.h: nul + ($(CC) -MD <>$(MAKEFILE) HAVE_PSAPI_H=1) & $(WIN32DIR:/=\)\rm.bat conftest.* +#include +#include +int main(void) {return (EnumProcesses(NULL,0,NULL) ? 0 : 1);} +<< + +-version-: nul verconf.mk + @$(APPEND) + @$(CPP) -I$(srcdir) -I$(srcdir)/include <<"Creating $(MAKEFILE)" | findstr "=" >>$(MAKEFILE) +#define RUBY_REVISION 0 +#include "version.h" +MAJOR = RUBY_API_VERSION_MAJOR +MINOR = RUBY_API_VERSION_MINOR +TEENY = RUBY_API_VERSION_TEENY +RUBY_PROGRAM_VERSION = RUBY_VERSION +MSC_VER = _MSC_VER +<< + +verconf.mk: nul + @echo RUBY_RELEASE_DATE \>$(@) + @$(CPP) -I$(srcdir) -I$(srcdir)/include <<"Creating $(@)" | findstr "=" >>$(@) +#define RUBY_REVISION 0 +#include "version.h" + = RUBY_RELEASE_DATE +<< + +-program-name-: + @type << >>$(MAKEFILE) +!ifdef PROGRAM_PREFIX +PROGRAM_PREFIX = $(PROGRAM_PREFIX) +!endif +!ifdef PROGRAM_SUFFIX +PROGRAM_SUFFIX = $(PROGRAM_SUFFIX) +!endif +!ifdef RUBY_INSTALL_NAME +RUBY_INSTALL_NAME = $(RUBY_INSTALL_NAME) +!endif +!ifdef RUBY_SO_NAME +RUBY_SO_NAME = $(RUBY_SO_NAME) +!endif +<< + +-generic-: nul + @$(CPP) <nul | findstr = >>$(MAKEFILE) +#if defined _M_X64 +MACHINE = x64 +#elif defined _M_IA64 +MACHINE = ia64 +#else +MACHINE = x86 +#endif +<< +!if defined($(CPU)) + @echo>>$(MAKEFILE) $(CPU) = $(PROCESSOR_LEVEL) +!endif + @$(APPEND) + +-alpha-: nul + @echo MACHINE = alpha>>$(MAKEFILE) +-x64-: nul + @echo MACHINE = x64>>$(MAKEFILE) +-ia64-: nul + @echo MACHINE = ia64>>$(MAKEFILE) +-ix86-: nul + @echo MACHINE = x86>>$(MAKEFILE) + +-i386-: -ix86- + @echo $(CPU) = 3>>$(MAKEFILE) +-i486-: -ix86- + @echo $(CPU) = 4>>$(MAKEFILE) +-i586-: -ix86- + @echo $(CPU) = 5>>$(MAKEFILE) +-i686-: -ix86- + @echo $(CPU) = 6>>$(MAKEFILE) + +-epilogue-: -encs- + +-encs-: nul + @$(MAKE) -l -f $(srcdir)/win32/enc-setup.mak srcdir="$(srcdir)" MAKEFILE=$(MAKEFILE) + +-epilogue-: nul +!if exist(confargs.c) + @$(APPEND) + @$(CPP) confargs.c 2>&1 | findstr "! =" >> $(MAKEFILE) + @del confargs.c +!endif + @type << >>$(MAKEFILE) + +# RUBY_INSTALL_NAME = ruby +# RUBY_SO_NAME = $$(RT)-$$(RUBY_INSTALL_NAME)$$(MAJOR)$$(MINOR) +# CFLAGS = -nologo -MD $$(DEBUGFLAGS) $$(OPTFLAGS) $$(PROCESSOR_FLAG) +# CPPFLAGS = -I. -I$$(srcdir) -I$$(srcdir)/missing -DLIBRUBY_SO=\"$$(LIBRUBY_SO)\" +# STACK = 0x2000000 +# LDFLAGS = $$(CFLAGS) -Fm +# XLDFLAGS = +# RFLAGS = -r +# EXTLIBS = + +$(BANG)include $$(srcdir)/win32/Makefile.sub +<< + @$(COMSPEC) /C $(srcdir:/=\)\win32\rm.bat config.h config.status + @echo "type `nmake' to make ruby." diff --git a/jni/ruby/win32/stub.c b/jni/ruby/win32/stub.c new file mode 100644 index 0000000..fc82d73 --- /dev/null +++ b/jni/ruby/win32/stub.c @@ -0,0 +1,42 @@ +#include +static void stub_sysinit(int *argc, char ***argv); +#define ruby_sysinit stub_sysinit +#include +#undef ruby_sysinit + +void +stub_sysinit(int *argc, char ***argv) +{ + char exename[4096]; + size_t lenexe, len0, lenall; + int i, ac; + char **av, *p; + + lenexe = (size_t)GetModuleFileName(NULL, exename, sizeof exename); + ruby_sysinit(argc, argv); + ac = *argc; + av = *argv; + len0 = strlen(av[0]) + 1; + lenall = 0; + for (i = 1; i < ac; ++i) { + lenall += strlen(av[i]) + 1; + } + *argv = av = realloc(av, lenall + (lenexe + 1) * 2 + sizeof(char *) * (i + 2)); + *argc = ++ac; + p = (char *)(av + i + 2); + memmove(p + (lenexe + 1) * 2, (char *)(av + ac) + len0, lenall); + memcpy(p, exename, lenexe); + p[lenexe] = '\0'; + *av++ = p; + p += lenexe + 1; + memcpy(p, exename, lenexe); + p[lenexe] = '\0'; + *av++ = p; + p += lenexe + 1; + while (--i) { + *av++ = p; + p += strlen(p) + 1; + } + *av = NULL; +} + diff --git a/jni/ruby/win32/win32.c b/jni/ruby/win32/win32.c new file mode 100644 index 0000000..eb1818a --- /dev/null +++ b/jni/ruby/win32/win32.c @@ -0,0 +1,7274 @@ +/* + * Copyright (c) 1993, Intergraph Corporation + * + * You may distribute under the terms of either the GNU General Public + * License or the Artistic License, as specified in the perl README file. + * + * Various Unix compatibility functions and NT specific functions. + * + * Some of this code was derived from the MSDOS port(s) and the OS/2 port. + * + */ +/* + The parts licensed under above copyright notice are marked as "Artistic or + GPL". + Another parts are licensed under Ruby's License. + + Copyright (C) 1993-2011 Yukihiro Matsumoto + Copyright (C) 2000 Network Applied Communication Laboratory, Inc. + Copyright (C) 2000 Information-technology Promotion Agency, Japan + */ + +#undef __STRICT_ANSI__ + +#include "ruby/ruby.h" +#include "ruby/encoding.h" +#include +#include +#include +/* #include */ +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#if _MSC_VER >= 1400 +#include +#include +#endif +#ifdef __MINGW32__ +#include +#endif +#include "ruby/win32.h" +#include "win32/dir.h" +#include "internal.h" +#define isdirsep(x) ((x) == '/' || (x) == '\\') + +#if defined _MSC_VER && _MSC_VER <= 1200 +# define CharNextExA(cp, p, flags) CharNextExA((WORD)(cp), (p), (flags)) +#endif + +static int w32_stati64(const char *path, struct stati64 *st, UINT cp); +static char *w32_getenv(const char *name, UINT cp); + +#undef getenv +#define DLN_FIND_EXTRA_ARG_DECL ,UINT cp +#define DLN_FIND_EXTRA_ARG ,cp +#define rb_w32_stati64(path, st) w32_stati64(path, st, cp) +#define getenv(name) w32_getenv(name, cp) +#undef CharNext +#define CharNext(p) CharNextExA(cp, (p), 0) +#define dln_find_exe_r rb_w32_udln_find_exe_r +#define dln_find_file_r rb_w32_udln_find_file_r +#include "dln.h" +#include "dln_find.c" +#undef MAXPATHLEN +#undef rb_w32_stati64 +#undef dln_find_exe_r +#undef dln_find_file_r +#define dln_find_exe_r(fname, path, buf, size) rb_w32_udln_find_exe_r(fname, path, buf, size, cp) +#define dln_find_file_r(fname, path, buf, size) rb_w32_udln_find_file_r(fname, path, buf, size, cp) +#undef CharNext /* no default cp version */ + +#undef stat +#undef fclose +#undef close +#undef setsockopt +#undef dup2 + +#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 WCHAR *, const WCHAR *, SECURITY_ATTRIBUTES *, HANDLE, HANDLE, HANDLE, DWORD); +static int has_redirection(const char *, UINT); +int rb_w32_wait_events(HANDLE *events, int num, DWORD timeout); +static int rb_w32_open_osfhandle(intptr_t osfhandle, int flags); +static int wstati64(const WCHAR *path, struct stati64 *st); +VALUE rb_w32_conv_from_wchar(const WCHAR *wstr, rb_encoding *enc); +int ruby_brace_glob_with_enc(const char *str, int flags, ruby_glob_func *func, VALUE arg, rb_encoding *enc); + +#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 }, + { ERROR_MOD_NOT_FOUND, ENOENT }, + { WSAEINTR, EINTR }, + { WSAEBADF, EBADF }, + { WSAEACCES, EACCES }, + { WSAEFAULT, EFAULT }, + { WSAEINVAL, EINVAL }, + { WSAEMFILE, EMFILE }, + { WSAEWOULDBLOCK, EWOULDBLOCK }, + { WSAEINPROGRESS, EINPROGRESS }, + { WSAEALREADY, EALREADY }, + { WSAENOTSOCK, ENOTSOCK }, + { WSAEDESTADDRREQ, EDESTADDRREQ }, + { WSAEMSGSIZE, EMSGSIZE }, + { WSAEPROTOTYPE, EPROTOTYPE }, + { WSAENOPROTOOPT, ENOPROTOOPT }, + { WSAEPROTONOSUPPORT, EPROTONOSUPPORT }, + { WSAESOCKTNOSUPPORT, ESOCKTNOSUPPORT }, + { WSAEOPNOTSUPP, EOPNOTSUPP }, + { WSAEPFNOSUPPORT, EPFNOSUPPORT }, + { WSAEAFNOSUPPORT, EAFNOSUPPORT }, + { WSAEADDRINUSE, EADDRINUSE }, + { WSAEADDRNOTAVAIL, EADDRNOTAVAIL }, + { WSAENETDOWN, ENETDOWN }, + { WSAENETUNREACH, ENETUNREACH }, + { WSAENETRESET, ENETRESET }, + { WSAECONNABORTED, ECONNABORTED }, + { WSAECONNRESET, ECONNRESET }, + { WSAENOBUFS, ENOBUFS }, + { WSAEISCONN, EISCONN }, + { WSAENOTCONN, ENOTCONN }, + { WSAESHUTDOWN, ESHUTDOWN }, + { WSAETOOMANYREFS, ETOOMANYREFS }, + { WSAETIMEDOUT, ETIMEDOUT }, + { WSAECONNREFUSED, ECONNREFUSED }, + { WSAELOOP, ELOOP }, + { WSAENAMETOOLONG, ENAMETOOLONG }, + { WSAEHOSTDOWN, EHOSTDOWN }, + { WSAEHOSTUNREACH, EHOSTUNREACH }, + { WSAEPROCLIM, EPROCLIM }, + { WSAENOTEMPTY, ENOTEMPTY }, + { WSAEUSERS, EUSERS }, + { WSAEDQUOT, EDQUOT }, + { WSAESTALE, ESTALE }, + { WSAEREMOTE, EREMOTE }, +}; + +/* License: Ruby's */ +int +rb_w32_map_errno(DWORD winerr) +{ + int i; + + if (winerr == 0) { + return 0; + } + + for (i = 0; i < (int)(sizeof(errmap) / sizeof(*errmap)); i++) { + if (errmap[i].winerr == winerr) { + return errmap[i].err; + } + } + + if (winerr >= WSABASEERR) { + return winerr; + } + return EINVAL; +} + +#define map_errno rb_w32_map_errno + +static const char *NTLoginName; + +static OSVERSIONINFO osver; + +/* License: Artistic or GPL */ +static void +get_version(void) +{ + memset(&osver, 0, sizeof(OSVERSIONINFO)); + osver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); + GetVersionEx(&osver); +} + +#ifdef _M_IX86 +/* License: Artistic or GPL */ +DWORD +rb_w32_osid(void) +{ + return osver.dwPlatformId; +} +#endif + +/* License: Artistic or GPL */ +DWORD +rb_w32_osver(void) +{ + return osver.dwMajorVersion; +} + +/* simulate flock by locking a range on the file */ + +/* License: Artistic or GPL */ +#define LK_ERR(f,i) \ + do { \ + if (f) \ + i = 0; \ + else { \ + DWORD err = GetLastError(); \ + if (err == ERROR_LOCK_VIOLATION || err == ERROR_IO_PENDING) \ + errno = EWOULDBLOCK; \ + else if (err == ERROR_NOT_LOCKED) \ + i = 0; \ + else \ + errno = map_errno(err); \ + } \ + } while (0) +#define LK_LEN ULONG_MAX + +/* License: Artistic or GPL */ +static uintptr_t +flock_winnt(uintptr_t self, int argc, uintptr_t* argv) +{ + OVERLAPPED o; + int i = -1; + const HANDLE fh = (HANDLE)self; + const int oper = argc; + + memset(&o, 0, sizeof(o)); + + switch(oper) { + case LOCK_SH: /* shared lock */ + LK_ERR(LockFileEx(fh, 0, 0, LK_LEN, LK_LEN, &o), i); + break; + case LOCK_EX: /* exclusive lock */ + LK_ERR(LockFileEx(fh, LOCKFILE_EXCLUSIVE_LOCK, 0, LK_LEN, LK_LEN, &o), i); + break; + case LOCK_SH|LOCK_NB: /* non-blocking shared lock */ + LK_ERR(LockFileEx(fh, LOCKFILE_FAIL_IMMEDIATELY, 0, LK_LEN, LK_LEN, &o), i); + break; + case LOCK_EX|LOCK_NB: /* non-blocking exclusive lock */ + LK_ERR(LockFileEx(fh, + LOCKFILE_EXCLUSIVE_LOCK|LOCKFILE_FAIL_IMMEDIATELY, + 0, LK_LEN, LK_LEN, &o), i); + break; + case LOCK_UN: /* unlock lock */ + case LOCK_UN|LOCK_NB: /* unlock is always non-blocking, I hope */ + LK_ERR(UnlockFileEx(fh, 0, LK_LEN, LK_LEN, &o), i); + break; + default: /* unknown */ + errno = EINVAL; + break; + } + return i; +} + +#undef LK_ERR + +/* License: Artistic or GPL */ +int +flock(int fd, int oper) +{ + const asynchronous_func_t locker = flock_winnt; + + return rb_w32_asynchronize(locker, + (VALUE)_get_osfhandle(fd), oper, NULL, + (DWORD)-1); +} + +/* License: Ruby's */ +static inline WCHAR * +translate_wchar(WCHAR *p, int from, int to) +{ + for (; *p; p++) { + if (*p == from) + *p = to; + } + return p; +} + +/* License: Ruby's */ +static inline char * +translate_char(char *p, int from, int to, UINT cp) +{ + while (*p) { + if ((unsigned char)*p == from) + *p = to; + p = CharNextExA(cp, p, 0); + } + return p; +} + +#ifndef CSIDL_LOCAL_APPDATA +#define CSIDL_LOCAL_APPDATA 28 +#endif +#ifndef CSIDL_COMMON_APPDATA +#define CSIDL_COMMON_APPDATA 35 +#endif +#ifndef CSIDL_WINDOWS +#define CSIDL_WINDOWS 36 +#endif +#ifndef CSIDL_SYSTEM +#define CSIDL_SYSTEM 37 +#endif +#ifndef CSIDL_PROFILE +#define CSIDL_PROFILE 40 +#endif + +/* License: Ruby's */ +static BOOL +get_special_folder(int n, WCHAR *env) +{ + LPITEMIDLIST pidl; + LPMALLOC alloc; + BOOL f = FALSE; + if (SHGetSpecialFolderLocation(NULL, n, &pidl) == 0) { + f = SHGetPathFromIDListW(pidl, env); + SHGetMalloc(&alloc); + alloc->lpVtbl->Free(alloc, pidl); + alloc->lpVtbl->Release(alloc); + } + return f; +} + +/* License: Ruby's */ +static void +regulate_path(WCHAR *path) +{ + WCHAR *p = translate_wchar(path, L'\\', L'/'); + if (p - path == 2 && path[1] == L':') { + *p++ = L'/'; + *p = L'\0'; + } +} + +/* License: Ruby's */ +static FARPROC +get_proc_address(const char *module, const char *func, HANDLE *mh) +{ + HANDLE h; + FARPROC ptr; + + if (mh) + h = LoadLibrary(module); + else + h = GetModuleHandle(module); + if (!h) + return NULL; + + ptr = GetProcAddress(h, func); + if (mh) { + if (ptr) + *mh = h; + else + FreeLibrary(h); + } + return ptr; +} + +/* License: Ruby's */ +static UINT +get_system_directory(WCHAR *path, UINT len) +{ + typedef UINT WINAPI wgetdir_func(WCHAR*, UINT); + FARPROC ptr = + get_proc_address("kernel32", "GetSystemWindowsDirectoryW", NULL); + if (ptr) + return (*(wgetdir_func *)ptr)(path, len); + return GetWindowsDirectoryW(path, len); +} + +/* License: Ruby's */ +VALUE +rb_w32_special_folder(int type) +{ + WCHAR path[_MAX_PATH]; + + if (!get_special_folder(type, path)) return Qnil; + regulate_path(path); + return rb_w32_conv_from_wchar(path, rb_filesystem_encoding()); +} + +/* License: Ruby's */ +UINT +rb_w32_system_tmpdir(WCHAR *path, UINT len) +{ + static const WCHAR temp[] = L"temp"; + WCHAR *p; + + if (!get_special_folder(CSIDL_LOCAL_APPDATA, path)) { + if (get_system_directory(path, len)) return 0; + } + p = translate_wchar(path, L'\\', L'/'); + if (*(p - 1) != L'/') *p++ = L'/'; + if ((UINT)(p - path + numberof(temp)) >= len) return 0; + memcpy(p, temp, sizeof(temp)); + return (UINT)(p - path + numberof(temp) - 1); +} + +/* License: Ruby's */ +static void +init_env(void) +{ + static const WCHAR TMPDIR[] = L"TMPDIR"; + struct {WCHAR name[6], eq, val[_MAX_PATH];} wk; + DWORD len; + BOOL f; +#define env wk.val +#define set_env_val(vname) do { \ + typedef char wk_name_offset[(numberof(wk.name) - (numberof(vname) - 1)) * 2 + 1]; \ + WCHAR *const buf = wk.name + sizeof(wk_name_offset) / 2; \ + MEMCPY(buf, vname, WCHAR, numberof(vname) - 1); \ + _wputenv(buf); \ + } while (0) + + wk.eq = L'='; + + if (!GetEnvironmentVariableW(L"HOME", env, numberof(env))) { + f = FALSE; + if (GetEnvironmentVariableW(L"HOMEDRIVE", env, numberof(env))) + len = lstrlenW(env); + else + len = 0; + if (GetEnvironmentVariableW(L"HOMEPATH", env + len, numberof(env) - len) || len) { + f = TRUE; + } + else if (GetEnvironmentVariableW(L"USERPROFILE", env, numberof(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) { + regulate_path(env); + set_env_val(L"HOME"); + } + } + + if (!GetEnvironmentVariableW(L"USER", env, numberof(env))) { + if (!GetEnvironmentVariableW(L"USERNAME", env, numberof(env)) && + !GetUserNameW(env, (len = numberof(env), &len))) { + NTLoginName = ""; + } + else { + set_env_val(L"USER"); + NTLoginName = rb_w32_wstr_to_mbstr(CP_UTF8, env, -1, NULL); + } + } + else { + NTLoginName = rb_w32_wstr_to_mbstr(CP_UTF8, env, -1, NULL); + } + + if (!GetEnvironmentVariableW(TMPDIR, env, numberof(env)) && + !GetEnvironmentVariableW(L"TMP", env, numberof(env)) && + !GetEnvironmentVariableW(L"TEMP", env, numberof(env)) && + rb_w32_system_tmpdir(env, numberof(env))) { + set_env_val(TMPDIR); + } + +#undef env +#undef set_env_val +} + + +typedef BOOL (WINAPI *cancel_io_t)(HANDLE); +static cancel_io_t cancel_io = NULL; + +/* License: Ruby's */ +static void +init_func(void) +{ + if (!cancel_io) + cancel_io = (cancel_io_t)get_proc_address("kernel32", "CancelIo", NULL); +} + +static void init_stdhandle(void); + +#if RUBY_MSVCRT_VERSION >= 80 +/* License: Ruby's */ +static void +invalid_parameter(const wchar_t *expr, const wchar_t *func, const wchar_t *file, unsigned int line, uintptr_t dummy) +{ + // nothing to do +} + +int ruby_w32_rtc_error; + +/* License: Ruby's */ +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 st_table *conlist = NULL; +#define conlist_disabled ((st_table *)-1) +static char *uenvarea; + +/* License: Ruby's */ +struct constat { + struct { + int state, seq[16], reverse; + WORD attr; + COORD saved; + } vt100; +}; +enum {constat_init = -2, constat_esc = -1, constat_seq = 0}; + +/* License: Ruby's */ +static int +free_conlist(st_data_t key, st_data_t val, st_data_t arg) +{ + xfree((struct constat *)val); + return ST_DELETE; +} + +/* License: Ruby's */ +static void +constat_delete(HANDLE h) +{ + if (conlist && conlist != conlist_disabled) { + st_data_t key = (st_data_t)h, val; + st_delete(conlist, &key, &val); + xfree((struct constat *)val); + } +} + +/* License: Ruby's */ +static void +exit_handler(void) +{ + if (NtSocketsInitialized) { + WSACleanup(); + if (socklist) { + st_free_table(socklist); + socklist = NULL; + } + DeleteCriticalSection(&select_mutex); + NtSocketsInitialized = 0; + } + if (conlist && conlist != conlist_disabled) { + st_foreach(conlist, free_conlist, 0); + st_free_table(conlist); + conlist = NULL; + } + if (uenvarea) { + free(uenvarea); + uenvarea = NULL; + } +} + +/* License: Artistic or GPL */ +static void +StartSockets(void) +{ + WORD version; + WSADATA retdata; + + // + // initialize the winsock interface and insure that it's + // cleaned up at exit. + // + version = MAKEWORD(2, 0); + if (WSAStartup(version, &retdata)) + rb_fatal ("Unable to locate winsock library!\n"); + if (LOBYTE(retdata.wVersion) != 2) + rb_fatal("could not find version 2 of winsock dll\n"); + + InitializeCriticalSection(&select_mutex); + + NtSocketsInitialized = 1; +} + +#define MAKE_SOCKDATA(af, fl) ((int)((((int)af)<<4)|((fl)&0xFFFF))) +#define GET_FAMILY(v) ((int)(((v)>>4)&0xFFFF)) +#define GET_FLAGS(v) ((int)((v)&0xFFFF)) + +/* License: Ruby's */ +static inline int +socklist_insert(SOCKET sock, int flag) +{ + if (!socklist) + socklist = st_init_numtable(); + return st_insert(socklist, (st_data_t)sock, (st_data_t)flag); +} + +/* License: Ruby's */ +static inline int +socklist_lookup(SOCKET sock, int *flagp) +{ + st_data_t data; + int ret; + + if (!socklist) + return 0; + ret = st_lookup(socklist, (st_data_t)sock, (st_data_t *)&data); + if (ret && flagp) + *flagp = (int)data; + + return ret; +} + +/* License: Ruby's */ +static inline int +socklist_delete(SOCKET *sockp, int *flagp) +{ + st_data_t key; + st_data_t data; + int ret; + + if (!socklist) + return 0; + key = (st_data_t)*sockp; + if (flagp) + data = (st_data_t)*flagp; + ret = st_delete(socklist, &key, &data); + if (ret) { + *sockp = (SOCKET)key; + if (flagp) + *flagp = (int)data; + } + + return ret; +} + +static int w32_cmdvector(const WCHAR *, char ***, UINT, rb_encoding *); +// +// Initialization stuff +// +/* License: Ruby's */ +void +rb_w32_sysinit(int *argc, char ***argv) +{ +#if RUBY_MSVCRT_VERSION >= 80 + static void set_pioinfo_extra(void); + + _CrtSetReportMode(_CRT_ASSERT, 0); + _set_invalid_parameter_handler(invalid_parameter); + _RTC_SetErrorFunc(rtc_error_handler); + set_pioinfo_extra(); +#else + SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOGPFAULTERRORBOX); +#endif + + get_version(); + + // + // subvert cmd.exe's feeble attempt at command line parsing + // + *argc = w32_cmdvector(GetCommandLineW(), argv, CP_UTF8, rb_utf8_encoding()); + + // + // Now set up the correct time stuff + // + + tzset(); + + init_env(); + + init_func(); + + init_stdhandle(); + + atexit(exit_handler); + + // Initialize Winsock + StartSockets(); +} + +char * +getlogin(void) +{ + return (char *)NTLoginName; +} + +#define MAXCHILDNUM 256 /* max num of child processes */ + +/* License: Ruby's */ +static struct ChildRecord { + HANDLE hProcess; /* process handle */ + rb_pid_t pid; /* process id */ +} ChildRecord[MAXCHILDNUM]; + +/* License: Ruby's */ +#define FOREACH_CHILD(v) do { \ + struct ChildRecord* v; \ + for (v = ChildRecord; v < ChildRecord + sizeof(ChildRecord) / sizeof(ChildRecord[0]); ++v) +#define END_FOREACH_CHILD } while (0) + +/* License: Ruby's */ +static struct ChildRecord * +FindChildSlot(rb_pid_t pid) +{ + + FOREACH_CHILD(child) { + if (child->pid == pid) { + return child; + } + } END_FOREACH_CHILD; + return NULL; +} + +/* License: Ruby's */ +static struct ChildRecord * +FindChildSlotByHandle(HANDLE h) +{ + + FOREACH_CHILD(child) { + if (child->hProcess == h) { + return child; + } + } END_FOREACH_CHILD; + return NULL; +} + +/* License: Ruby's */ +static void +CloseChildHandle(struct ChildRecord *child) +{ + HANDLE h = child->hProcess; + child->hProcess = NULL; + child->pid = 0; + CloseHandle(h); +} + +/* License: Ruby's */ +static struct ChildRecord * +FindFreeChildSlot(void) +{ + FOREACH_CHILD(child) { + if (!child->pid) { + child->pid = -1; /* lock the slot */ + child->hProcess = NULL; + return child; + } + } END_FOREACH_CHILD; + return NULL; +} + + +/* + 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", + "\3" "break", + "\3" "call", + "\3" "cd", + "\1" "chcp", + "\3" "chdir", + "\3" "cls", + "\2" "color", + "\3" "copy", + "\1" "ctty", + "\3" "date", + "\3" "del", + "\3" "dir", + "\3" "echo", + "\2" "endlocal", + "\3" "erase", + "\3" "exit", + "\3" "for", + "\2" "ftype", + "\3" "goto", + "\3" "if", + "\1" "lfnfor", + "\1" "lh", + "\1" "lock", + "\3" "md", + "\3" "mkdir", + "\2" "move", + "\3" "path", + "\3" "pause", + "\2" "popd", + "\3" "prompt", + "\2" "pushd", + "\3" "rd", + "\3" "rem", + "\3" "ren", + "\3" "rename", + "\3" "rmdir", + "\3" "set", + "\2" "setlocal", + "\3" "shift", + "\2" "start", + "\3" "time", + "\2" "title", + "\1" "truename", + "\3" "type", + "\1" "unlock", + "\3" "ver", + "\3" "verify", + "\3" "vol", +}; + +/* License: Ruby's */ +static int +internal_match(const void *key, const void *elem) +{ + return strcmp(key, (*(const char *const *)elem) + 1); +} + +/* License: Ruby's */ +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); + +/* License: Ruby's */ +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)); + if (c == '@') + return 1; + while (isalpha(c)) { + *b++ = tolower(c); + if (b == cmdname + sizeof(cmdname)) return 0; + c = *cmd++; + } + if (c == '.') c = *cmd; + switch (c) { + case '<': case '>': case '|': + return 1; + case '\0': case ' ': case '\t': case '\n': + break; + default: + return 0; + } + *b = 0; + return internal_cmd_match(cmdname, nt); +} + +/* License: Ruby's */ +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][0] & (nt ? 2 : 1))) + return 0; + return 1; +} + +/* License: Ruby's */ +SOCKET +rb_w32_get_osfhandle(int fh) +{ + return _get_osfhandle(fh); +} + +/* License: Ruby's */ +static int +join_argv(char *cmd, char *const *argv, BOOL escape, UINT cp, int backslash) +{ + const char *p, *s; + char *q, *const *t; + int len, n, bs, quote; + + for (t = argv, q = cmd, len = 0; (p = *t) != 0; t++) { + quote = 0; + s = p; + if (!*p || strpbrk(p, " \t\"'")) { + quote = 1; + len++; + if (q) *q++ = '"'; + } + for (bs = 0; *p; ++p) { + switch (*p) { + case '\\': + ++bs; + break; + case '"': + len += n = p - s; + if (q) { + memcpy(q, s, n); + q += n; + } + s = p; + len += ++bs; + if (q) { + memset(q, '\\', bs); + q += bs; + } + bs = 0; + break; + case '<': case '>': case '|': case '^': + if (escape && !quote) { + len += (n = p - s) + 1; + if (q) { + memcpy(q, s, n); + q += n; + *q++ = '^'; + } + s = p; + break; + } + default: + bs = 0; + p = CharNextExA(cp, p, 0) - 1; + break; + } + } + len += (n = p - s) + 1; + if (quote) len++; + if (q) { + memcpy(q, s, n); + if (backslash > 0) { + --backslash; + q[n] = 0; + translate_char(q, '/', '\\', cp); + } + q += n; + if (quote) *q++ = '"'; + *q++ = ' '; + } + } + if (q > cmd) --len; + if (q) { + if (q > cmd) --q; + *q = '\0'; + } + return len; +} + +#ifdef HAVE_SYS_PARAM_H +# include +#else +# define MAXPATHLEN 512 +#endif + +/* License: Ruby's */ +#define STRNDUPV(ptr, v, src, len) \ + (((char *)memcpy(((ptr) = ALLOCV((v), (len) + 1)), (src), (len)))[len] = 0) + +/* License: Ruby's */ +static int +check_spawn_mode(int mode) +{ + switch (mode) { + case P_NOWAIT: + case P_OVERLAY: + return 0; + default: + errno = EINVAL; + return -1; + } +} + +/* License: Ruby's */ +static rb_pid_t +child_result(struct ChildRecord *child, int mode) +{ + DWORD exitcode; + + if (!child) { + return -1; + } + + if (mode == P_OVERLAY) { + WaitForSingleObject(child->hProcess, INFINITE); + GetExitCodeProcess(child->hProcess, &exitcode); + CloseChildHandle(child); + _exit(exitcode); + } + return child->pid; +} + +/* License: Ruby's */ +static struct ChildRecord * +CreateChild(const WCHAR *cmd, const WCHAR *prog, SECURITY_ATTRIBUTES *psa, + HANDLE hInput, HANDLE hOutput, HANDLE hError, DWORD dwCreationFlags) +{ + BOOL fRet; + STARTUPINFOW 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(aStartupInfo)); + memset(&aProcessInformation, 0, sizeof(aProcessInformation)); + aStartupInfo.cb = sizeof(aStartupInfo); + aStartupInfo.dwFlags = STARTF_USESTDHANDLES; + if (hInput) { + aStartupInfo.hStdInput = hInput; + } + else { + aStartupInfo.hStdInput = GetStdHandle(STD_INPUT_HANDLE); + } + if (hOutput) { + aStartupInfo.hStdOutput = hOutput; + } + else { + aStartupInfo.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE); + } + if (hError) { + aStartupInfo.hStdError = hError; + } + else { + aStartupInfo.hStdError = GetStdHandle(STD_ERROR_HANDLE); + } + + dwCreationFlags |= NORMAL_PRIORITY_CLASS; + + if (lstrlenW(cmd) > 32767) { + child->pid = 0; /* release the slot */ + errno = E2BIG; + return NULL; + } + + RUBY_CRITICAL({ + fRet = CreateProcessW(prog, (WCHAR *)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; + + return child; +} + +/* License: Ruby's */ +static int +is_batch(const char *cmd) +{ + int len = strlen(cmd); + if (len <= 4) return 0; + cmd += len - 4; + if (*cmd++ != '.') return 0; + if (strcasecmp(cmd, "bat") == 0) return 1; + if (strcasecmp(cmd, "cmd") == 0) return 1; + return 0; +} + +UINT rb_w32_filecp(void); +#define filecp rb_w32_filecp +#define mbstr_to_wstr rb_w32_mbstr_to_wstr +#define wstr_to_mbstr rb_w32_wstr_to_mbstr +#define acp_to_wstr(str, plen) mbstr_to_wstr(CP_ACP, str, -1, plen) +#define wstr_to_acp(str, plen) wstr_to_mbstr(CP_ACP, str, -1, plen) +#define filecp_to_wstr(str, plen) mbstr_to_wstr(filecp(), str, -1, plen) +#define wstr_to_filecp(str, plen) wstr_to_mbstr(filecp(), str, -1, plen) +#define utf8_to_wstr(str, plen) mbstr_to_wstr(CP_UTF8, str, -1, plen) +#define wstr_to_utf8(str, plen) wstr_to_mbstr(CP_UTF8, str, -1, plen) + +/* License: Artistic or GPL */ +static rb_pid_t +w32_spawn(int mode, const char *cmd, const char *prog, UINT cp) +{ + char fbuf[MAXPATHLEN]; + char *p = NULL; + const char *shell = NULL; + WCHAR *wcmd = NULL, *wshell = NULL; + int e = 0; + rb_pid_t ret = -1; + VALUE v = 0; + VALUE v2 = 0; + int sep = 0; + char *cmd_sep = NULL; + + if (check_spawn_mode(mode)) return -1; + + if (prog) { + if (!(p = dln_find_exe_r(prog, NULL, fbuf, sizeof(fbuf)))) { + shell = prog; + } + else { + shell = p; + translate_char(p, '/', '\\', cp); + } + } + else { + int redir = -1; + int nt; + while (ISSPACE(*cmd)) cmd++; + if ((shell = getenv("RUBYSHELL")) && (redir = has_redirection(cmd, cp))) { + size_t shell_len = strlen(shell); + char *tmp = ALLOCV(v, shell_len + strlen(cmd) + sizeof(" -c ") + 2); + memcpy(tmp, shell, shell_len + 1); + translate_char(tmp, '/', '\\', cp); + sprintf(tmp + shell_len, " -c \"%s\"", cmd); + cmd = tmp; + } + else if ((shell = getenv("COMSPEC")) && + (nt = !is_command_com(shell), + (redir < 0 ? has_redirection(cmd, cp) : redir) || + is_internal_cmd(cmd, nt))) { + char *tmp = ALLOCV(v, 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, quote = (*cmd == '"') ? '"' : (*cmd == '\'') ? '\'' : 0; + int slash = 0; + for (prog = cmd + !!quote;; prog = CharNextExA(cp, prog, 0)) { + if (*prog == '/') slash = 1; + if (!*prog) { + len = prog - cmd; + if (slash) { + STRNDUPV(p, v2, cmd, len); + cmd = p; + } + shell = cmd; + break; + } + if ((unsigned char)*prog == quote) { + len = prog++ - cmd - 1; + STRNDUPV(p, v2, cmd + 1, len); + shell = p; + break; + } + if (quote) continue; + if (ISSPACE(*prog) || strchr("<>|*?\"", *prog)) { + len = prog - cmd; + STRNDUPV(p, v2, cmd, len + (slash ? strlen(prog) : 0)); + if (slash) { + cmd = p; + sep = *(cmd_sep = &p[len]); + *cmd_sep = '\0'; + } + shell = p; + break; + } + } + shell = dln_find_exe_r(shell, NULL, fbuf, sizeof(fbuf)); + if (p && slash) translate_char(p, '/', '\\', cp); + if (!shell) { + shell = p ? p : cmd; + } + else { + len = strlen(shell); + if (strchr(shell, ' ')) quote = -1; + if (shell == fbuf) { + p = fbuf; + } + else if (shell != p && strchr(shell, '/')) { + STRNDUPV(p, v2, shell, len); + shell = p; + } + if (p) translate_char(p, '/', '\\', cp); + if (is_batch(shell)) { + int alen = strlen(prog); + cmd = p = ALLOCV(v, len + alen + (quote ? 2 : 0) + 1); + if (quote) *p++ = '"'; + memcpy(p, shell, len); + p += len; + if (quote) *p++ = '"'; + memcpy(p, prog, alen + 1); + shell = 0; + } + } + } + } + + if (!e && shell && !(wshell = mbstr_to_wstr(cp, shell, -1, NULL))) e = E2BIG; + if (cmd_sep) *cmd_sep = sep; + if (!e && cmd && !(wcmd = mbstr_to_wstr(cp, cmd, -1, NULL))) e = E2BIG; + if (v2) ALLOCV_END(v2); + if (v) ALLOCV_END(v); + + if (!e) { + ret = child_result(CreateChild(wcmd, wshell, NULL, NULL, NULL, NULL, 0), mode); + } + free(wshell); + free(wcmd); + if (e) errno = e; + return ret; +} + +/* License: Ruby's */ +rb_pid_t +rb_w32_spawn(int mode, const char *cmd, const char *prog) +{ + /* assume ACP */ + return w32_spawn(mode, cmd, prog, filecp()); +} + +/* License: Ruby's */ +rb_pid_t +rb_w32_uspawn(int mode, const char *cmd, const char *prog) +{ + return w32_spawn(mode, cmd, prog, CP_UTF8); +} + +/* License: Artistic or GPL */ +static rb_pid_t +w32_aspawn_flags(int mode, const char *prog, char *const *argv, DWORD flags, UINT cp) +{ + int c_switch = 0; + size_t len; + BOOL ntcmd = FALSE, tmpnt; + const char *shell; + char *cmd, fbuf[MAXPATHLEN]; + WCHAR *wcmd = NULL, *wprog = NULL; + int e = 0; + rb_pid_t ret = -1; + VALUE v = 0; + + 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; + } + else if ((cmd = dln_find_exe_r(prog, NULL, fbuf, sizeof(fbuf)))) { + if (cmd == prog) strlcpy(cmd = fbuf, prog, sizeof(fbuf)); + translate_char(cmd, '/', '\\', cp); + prog = cmd; + } + else if (strchr(prog, '/')) { + len = strlen(prog); + if (len < sizeof(fbuf)) + strlcpy(cmd = fbuf, prog, sizeof(fbuf)); + else + STRNDUPV(cmd, v, prog, len); + translate_char(cmd, '/', '\\', cp); + prog = cmd; + } + if (c_switch || is_batch(prog)) { + char *progs[2]; + progs[0] = (char *)prog; + progs[1] = NULL; + len = join_argv(NULL, progs, ntcmd, cp, 1); + if (c_switch) len += 3; + else ++argv; + if (argv[0]) len += join_argv(NULL, argv, ntcmd, cp, 0); + cmd = ALLOCV(v, len); + join_argv(cmd, progs, ntcmd, cp, 1); + if (c_switch) strlcat(cmd, " /c", len); + if (argv[0]) join_argv(cmd + strlcat(cmd, " ", len), argv, ntcmd, cp, 0); + prog = c_switch ? shell : 0; + } + else { + len = join_argv(NULL, argv, FALSE, cp, 1); + cmd = ALLOCV(v, len); + join_argv(cmd, argv, FALSE, cp, 1); + } + + if (!e && cmd && !(wcmd = mbstr_to_wstr(cp, cmd, -1, NULL))) e = E2BIG; + if (v) ALLOCV_END(v); + if (!e && prog && !(wprog = mbstr_to_wstr(cp, prog, -1, NULL))) e = E2BIG; + + if (!e) { + ret = child_result(CreateChild(wcmd, wprog, NULL, NULL, NULL, NULL, flags), mode); + } + free(wprog); + free(wcmd); + if (e) errno = e; + return ret; +} + +/* License: Ruby's */ +rb_pid_t +rb_w32_aspawn_flags(int mode, const char *prog, char *const *argv, DWORD flags) +{ + /* assume ACP */ + return w32_aspawn_flags(mode, prog, argv, flags, filecp()); +} + +/* License: Ruby's */ +rb_pid_t +rb_w32_uaspawn_flags(int mode, const char *prog, char *const *argv, DWORD flags) +{ + return w32_aspawn_flags(mode, prog, argv, flags, CP_UTF8); +} + +/* License: Ruby's */ +rb_pid_t +rb_w32_aspawn(int mode, const char *prog, char *const *argv) +{ + return rb_w32_aspawn_flags(mode, prog, argv, 0); +} + +/* License: Ruby's */ +rb_pid_t +rb_w32_uaspawn(int mode, const char *prog, char *const *argv) +{ + return rb_w32_uaspawn_flags(mode, prog, argv, 0); +} + +/* License: Artistic or GPL */ +typedef struct _NtCmdLineElement { + struct _NtCmdLineElement *next; + char *str; + long len; + int flags; +} NtCmdLineElement; + +// +// Possible values for flags +// + +#define NTGLOB 0x1 // element contains a wildcard +#define NTMALLOC 0x2 // string in element was malloc'ed +#define NTSTRING 0x4 // element contains a quoted string + +/* License: Ruby's */ +static int +insert(const char *path, VALUE vinfo, void *enc) +{ + NtCmdLineElement *tmpcurr; + NtCmdLineElement ***tail = (NtCmdLineElement ***)vinfo; + + tmpcurr = (NtCmdLineElement *)malloc(sizeof(NtCmdLineElement)); + if (!tmpcurr) return -1; + MEMZERO(tmpcurr, NtCmdLineElement, 1); + tmpcurr->len = strlen(path); + tmpcurr->str = strdup(path); + if (!tmpcurr->str) return -1; + tmpcurr->flags |= NTMALLOC; + **tail = tmpcurr; + *tail = &tmpcurr->next; + + return 0; +} + +/* License: Artistic or GPL */ +static NtCmdLineElement ** +cmdglob(NtCmdLineElement *patt, NtCmdLineElement **tail, UINT cp, rb_encoding *enc) +{ + char buffer[MAXPATHLEN], *buf = buffer; + 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'; + translate_char(buf, '\\', '/', cp); + status = ruby_brace_glob_with_enc(buf, 0, insert, (VALUE)&tail, enc); + if (buf != buffer) + free(buf); + + if (status || last == tail) return 0; + if (patt->flags & NTMALLOC) + free(patt->str); + free(patt); + return tail; +} + +// +// Check a command string to determine if it has I/O redirection +// characters that require it to be executed by a command interpreter +// + +/* License: Artistic or GPL */ +static int +has_redirection(const char *cmd, UINT cp) +{ + char quote = '\0'; + const char *ptr; + + // + // Scan the string, looking for redirection characters (< or >), pipe + // character (|) or newline (\n) that are not in a quoted string + // + + for (ptr = cmd; *ptr;) { + switch (*ptr) { + case '\'': + case '\"': + if (!quote) + quote = *ptr; + else if (quote == *ptr) + quote = '\0'; + ptr++; + break; + + case '>': + case '<': + case '|': + case '&': + case '\n': + if (!quote) + return TRUE; + ptr++; + break; + + case '%': + if (*++ptr != '_' && !ISALPHA(*ptr)) break; + while (*++ptr == '_' || ISALNUM(*ptr)); + if (*ptr++ == '%') return TRUE; + break; + + case '\\': + ptr++; + default: + ptr = CharNextExA(cp, ptr, 0); + break; + } + } + return FALSE; +} + +/* License: Ruby's */ +static inline WCHAR * +skipspace(WCHAR *ptr) +{ + while (iswspace(*ptr)) + ptr++; + return ptr; +} + +/* License: Artistic or GPL */ +static int +w32_cmdvector(const WCHAR *cmd, char ***vec, UINT cp, rb_encoding *enc) +{ + int globbing, len; + int elements, strsz, done; + int slashes, escape; + WCHAR *ptr, *base, *cmdline; + char *cptr, *buffer; + char **vptr; + WCHAR quote; + NtCmdLineElement *curr, **tail; + NtCmdLineElement *cmdhead = NULL, **cmdtail = &cmdhead; + + // + // just return if we don't have a command line + // + while (iswspace(*cmd)) + cmd++; + if (!*cmd) { + *vec = NULL; + return 0; + } + + ptr = cmdline = wcsdup(cmd); + + // + // Ok, parse the command line, building a list of CmdLineElements. + // When we've finished, and it's an input command (meaning that it's + // the processes argv), we'll do globing and then build the argument + // vector. + // The outer loop does one iteration for each element seen. + // The inner loop does one iteration for each character in the element. + // + + while (*(ptr = skipspace(ptr))) { + base = ptr; + quote = slashes = globbing = escape = 0; + for (done = 0; !done && *ptr; ) { + // + // Switch on the current character. We only care about the + // white-space characters, the wild-card characters, and the + // quote characters. + // + + switch (*ptr) { + case L'\\': + if (quote != L'\'') slashes++; + break; + + case L' ': + case L'\t': + case L'\n': + // + // if we're not in a string, then we're finished with this + // element + // + + if (!quote) { + *ptr = 0; + done = 1; + } + break; + + case L'*': + case L'?': + case L'[': + case L'{': + // + // record the fact that this element has a wildcard character + // N.B. Don't glob if inside a single quoted string + // + + if (quote != L'\'') + globbing++; + slashes = 0; + break; + + case L'\'': + case L'\"': + // + // if we're already in a string, see if this is the + // terminating close-quote. If it is, we're finished with + // the string, but not necessarily with the element. + // If we're not already in a string, start one. + // + + if (!(slashes & 1)) { + if (!quote) + quote = *ptr; + else if (quote == *ptr) { + if (quote == L'"' && quote == ptr[1]) + ptr++; + quote = L'\0'; + } + } + escape++; + slashes = 0; + break; + + default: + ptr = CharNextW(ptr); + slashes = 0; + continue; + } + ptr++; + } + + // + // when we get here, we've got a pair of pointers to the element, + // base and ptr. Base points to the start of the element while ptr + // points to the character following the element. + // + + len = ptr - base; + if (done) --len; + + // + // if it's an input vector element and it's enclosed by quotes, + // we can remove them. + // + + if (escape) { + WCHAR *p = base, c; + slashes = quote = 0; + while (p < base + len) { + switch (c = *p) { + case L'\\': + p++; + if (quote != L'\'') slashes++; + break; + + case L'\'': + case L'"': + if (!(slashes & 1) && quote && quote != c) { + p++; + slashes = 0; + break; + } + memcpy(p - ((slashes + 1) >> 1), p + (~slashes & 1), + sizeof(WCHAR) * (base + len - p)); + len -= ((slashes + 1) >> 1) + (~slashes & 1); + p -= (slashes + 1) >> 1; + if (!(slashes & 1)) { + if (quote) { + if (quote == L'"' && quote == *p) + p++; + quote = L'\0'; + } + else + quote = c; + } + else + p++; + slashes = 0; + break; + + default: + p = CharNextW(p); + slashes = 0; + break; + } + } + } + + curr = (NtCmdLineElement *)calloc(sizeof(NtCmdLineElement), 1); + if (!curr) goto do_nothing; + curr->str = rb_w32_wstr_to_mbstr(cp, base, len, &curr->len); + curr->flags |= NTMALLOC; + + if (globbing && (tail = cmdglob(curr, cmdtail, cp, enc))) { + cmdtail = tail; + } + else { + *cmdtail = curr; + cmdtail = &curr->next; + } + } + + // + // Almost done! + // Count up the elements, then allocate space for a vector of pointers + // (argv) and a string table for the elements. + // + + for (elements = 0, strsz = 0, curr = cmdhead; curr; curr = curr->next) { + elements++; + strsz += (curr->len + 1); + } + + len = (elements+1)*sizeof(char *) + strsz; + buffer = (char *)malloc(len); + if (!buffer) { + do_nothing: + while ((curr = cmdhead) != 0) { + cmdhead = curr->next; + if (curr->flags & NTMALLOC) free(curr->str); + free(curr); + } + free(cmdline); + for (vptr = *vec; *vptr; ++vptr); + return vptr - *vec; + } + + // + // make vptr point to the start of the buffer + // and cptr point to the area we'll consider the string table. + // + // buffer (*vec) + // | + // V ^---------------------V + // +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ + // | | | .... | NULL | | ..... |\0 | | ..... |\0 |... + // +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ + // |- elements+1 -| ^ 1st element ^ 2nd element + + vptr = (char **) buffer; + + cptr = buffer + (elements+1) * sizeof(char *); + + while ((curr = cmdhead) != 0) { + strlcpy(cptr, curr->str, curr->len + 1); + *vptr++ = cptr; + cptr += curr->len + 1; + cmdhead = curr->next; + if (curr->flags & NTMALLOC) free(curr->str); + free(curr); + } + *vptr = 0; + + *vec = (char **) buffer; + free(cmdline); + return elements; +} + +// +// UNIX compatible directory access functions for NT +// + +// +// The idea here is to read all the directory names into a string table +// (separated by nulls) and when one of the other dir functions is called +// return the pointer to the current file name. +// + +/* License: Ruby's */ +#define GetBit(bits, i) ((bits)[(i) / CHAR_BIT] & (1 << (i) % CHAR_BIT)) +#define SetBit(bits, i) ((bits)[(i) / CHAR_BIT] |= (1 << (i) % CHAR_BIT)) + +#define BitOfIsDir(n) ((n) * 2) +#define BitOfIsRep(n) ((n) * 2 + 1) +#define DIRENT_PER_CHAR (CHAR_BIT / 2) + +/* License: Artistic or GPL */ +static HANDLE +open_dir_handle(const WCHAR *filename, WIN32_FIND_DATAW *fd) +{ + HANDLE fh; + static const WCHAR wildcard[] = L"\\*"; + WCHAR *scanname; + WCHAR *p; + int len; + VALUE v; + + // + // Create the search pattern + // + len = lstrlenW(filename); + scanname = ALLOCV_N(WCHAR, v, len + sizeof(wildcard) / sizeof(WCHAR)); + lstrcpyW(scanname, filename); + 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); + ALLOCV_END(v); + if (fh == INVALID_HANDLE_VALUE) { + errno = map_errno(GetLastError()); + } + return fh; +} + +/* License: Artistic or GPL */ +static DIR * +opendir_internal(WCHAR *wpath, const char *filename) +{ + struct stati64 sbuf; + WIN32_FIND_DATAW fd; + HANDLE fh; + DIR *p; + long len; + long idx; + WCHAR *tmpW; + char *tmp; + + // + // check to see if we've got a directory + // + if (wstati64(wpath, &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(wpath, &fd); + 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; +} + +/* License: Ruby's */ +UINT +filecp(void) +{ + UINT cp = AreFileApisANSI() ? CP_ACP : CP_OEMCP; + return cp; +} + +/* License: Ruby's */ +char * +rb_w32_wstr_to_mbstr(UINT cp, const WCHAR *wstr, int clen, long *plen) +{ + char *ptr; + int len = WideCharToMultiByte(cp, 0, wstr, clen, NULL, 0, NULL, NULL); + if (!(ptr = malloc(len))) return 0; + WideCharToMultiByte(cp, 0, wstr, clen, ptr, len, NULL, NULL); + if (plen) { + /* exclude NUL only if NUL-terminated string */ + if (clen == -1) --len; + *plen = len; + } + return ptr; +} + +/* License: Ruby's */ +WCHAR * +rb_w32_mbstr_to_wstr(UINT cp, const char *str, int clen, long *plen) +{ + WCHAR *ptr; + int len = MultiByteToWideChar(cp, 0, str, clen, NULL, 0); + if (!(ptr = malloc(sizeof(WCHAR) * len))) return 0; + MultiByteToWideChar(cp, 0, str, clen, ptr, len); + if (plen) { + /* exclude NUL only if NUL-terminated string */ + if (clen == -1) --len; + *plen = len; + } + return ptr; +} + +/* License: Ruby's */ +DIR * +rb_w32_opendir(const char *filename) +{ + DIR *ret; + WCHAR *wpath = filecp_to_wstr(filename, NULL); + if (!wpath) + return NULL; + ret = opendir_internal(wpath, filename); + free(wpath); + return ret; +} + +/* License: Ruby's */ +DIR * +rb_w32_uopendir(const char *filename) +{ + DIR *ret; + WCHAR *wpath = utf8_to_wstr(filename, NULL); + if (!wpath) + return NULL; + ret = opendir_internal(wpath, filename); + free(wpath); + return ret; +} + +// +// Move to next entry +// + +/* License: Artistic or GPL */ +static void +move_to_next_entry(DIR *dirp) +{ + if (dirp->curr) { + dirp->loc++; + dirp->curr += lstrlenW(dirp->curr) + 1; + if (dirp->curr >= (dirp->start + dirp->size)) { + dirp->curr = NULL; + } + } +} + +// +// Readdir just returns the current string pointer and bumps the +// string pointer to the next entry. +// +/* License: Ruby's */ +static BOOL +win32_direct_conv(const WCHAR *file, struct direct *entry, const void *enc) +{ + UINT cp = *((UINT *)enc); + if (!(entry->d_name = wstr_to_mbstr(cp, file, -1, &entry->d_namlen))) + return FALSE; + return TRUE; +} + +/* License: Ruby's */ +VALUE +rb_w32_conv_from_wchar(const WCHAR *wstr, rb_encoding *enc) +{ + VALUE src; + long len = lstrlenW(wstr); + int encindex = rb_enc_to_index(enc); + + if (encindex == ENCINDEX_UTF_16LE) { + return rb_enc_str_new((char *)wstr, len * sizeof(WCHAR), enc); + } + else { +#if SIZEOF_INT < SIZEOF_LONG +# error long should equal to int on Windows +#endif + int clen = rb_long2int(len); + len = WideCharToMultiByte(CP_UTF8, 0, wstr, clen, NULL, 0, NULL, NULL); + src = rb_enc_str_new(0, len, rb_enc_from_index(ENCINDEX_UTF_8)); + WideCharToMultiByte(CP_UTF8, 0, wstr, clen, RSTRING_PTR(src), len, NULL, NULL); + } + switch (encindex) { + case ENCINDEX_ASCII: + case ENCINDEX_US_ASCII: + /* assume UTF-8 */ + case ENCINDEX_UTF_8: + /* do nothing */ + return src; + } + return rb_str_conv_enc_opts(src, NULL, enc, ECONV_UNDEF_REPLACE, Qnil); +} + +/* License: Ruby's */ +char * +rb_w32_conv_from_wstr(const WCHAR *wstr, long *lenp, rb_encoding *enc) +{ + VALUE str = rb_w32_conv_from_wchar(wstr, enc); + long len; + char *ptr; + + if (NIL_P(str)) return wstr_to_filecp(wstr, lenp); + *lenp = len = RSTRING_LEN(str); + memcpy(ptr = malloc(len + 1), RSTRING_PTR(str), len); + ptr[len] = '\0'; + return ptr; +} + +/* License: Ruby's */ +static BOOL +ruby_direct_conv(const WCHAR *file, struct direct *entry, const void *enc) +{ + if (!(entry->d_name = rb_w32_conv_from_wstr(file, &entry->d_namlen, enc))) + return FALSE; + return TRUE; +} + +/* License: Artistic or GPL */ +static struct direct * +readdir_internal(DIR *dirp, BOOL (*conv)(const WCHAR *, struct direct *, const void *), const void *enc) +{ + static int dummy = 0; + + if (dirp->curr) { + + // + // first set up the structure to return + // + if (dirp->dirstr.d_name) + free(dirp->dirstr.d_name); + 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; +} + +/* License: Ruby's */ +struct direct * +rb_w32_readdir(DIR *dirp, rb_encoding *enc) +{ + if (!enc || enc == rb_ascii8bit_encoding()) { + const UINT cp = filecp(); + return readdir_internal(dirp, win32_direct_conv, &cp); + } + else if (enc == rb_utf8_encoding()) { + const UINT cp = CP_UTF8; + return readdir_internal(dirp, win32_direct_conv, &cp); + } + else + return readdir_internal(dirp, ruby_direct_conv, enc); +} + +// +// Telldir returns the current string pointer position +// + +/* License: Artistic or GPL */ +long +rb_w32_telldir(DIR *dirp) +{ + return dirp->loc; +} + +// +// Seekdir moves the string pointer to a previously saved position +// (Saved by telldir). + +/* License: Ruby's */ +void +rb_w32_seekdir(DIR *dirp, long loc) +{ + if (dirp->loc > loc) rb_w32_rewinddir(dirp); + + while (dirp->curr && dirp->loc < loc) { + move_to_next_entry(dirp); + } +} + +// +// Rewinddir resets the string pointer to the start +// + +/* License: Artistic or GPL */ +void +rb_w32_rewinddir(DIR *dirp) +{ + dirp->curr = dirp->start; + dirp->loc = 0; +} + +// +// This just free's the memory allocated by opendir +// + +/* License: Artistic or GPL */ +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 + +/* License: Ruby's */ +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 RUBY_MSVCRT_VERSION >= 80 + 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[]; +static inline ioinfo* _pioinfo(int); + +#define IOINFO_L2E 5 +#define IOINFO_ARRAY_ELTS (1 << IOINFO_L2E) +#define _osfhnd(i) (_pioinfo(i)->osfhnd) +#define _osfile(i) (_pioinfo(i)->osfile) +#define _pipech(i) (_pioinfo(i)->pipech) + +#if RUBY_MSVCRT_VERSION >= 80 +static size_t pioinfo_extra = 0; /* workaround for VC++8 SP1 */ + +/* License: Ruby's */ +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 + +static inline ioinfo* +_pioinfo(int fd) +{ + const size_t sizeof_ioinfo = sizeof(ioinfo) + pioinfo_extra; + return (ioinfo*)((char*)__pioinfo[fd >> IOINFO_L2E] + + (fd & (IOINFO_ARRAY_ELTS - 1)) * sizeof_ioinfo); +} + +#define _set_osfhnd(fh, osfh) (void)(_osfhnd(fh) = osfh) +#define _set_osflags(fh, flags) (_osfile(fh) = (flags)) + +#define FOPEN 0x01 /* file handle open */ +#define FEOFLAG 0x02 /* end of file has been encountered */ +#define FPIPE 0x08 /* file handle refers to a pipe */ +#define FNOINHERIT 0x10 /* file handle opened O_NOINHERIT */ +#define FAPPEND 0x20 /* file handle opened O_APPEND */ +#define FDEV 0x40 /* file handle refers to device */ +#define FTEXT 0x80 /* file handle is in text mode */ + +static int is_socket(SOCKET); +static int is_console(SOCKET); + +/* License: Ruby's */ +int +rb_w32_io_cancelable_p(int fd) +{ + return cancel_io != NULL && (is_socket(TO_SOCKET(fd)) || !is_console(TO_SOCKET(fd))); +} + +/* License: Ruby's */ +static int +rb_w32_open_osfhandle(intptr_t osfhandle, int flags) +{ + int fh; + char fileflags; /* _osfile flags */ + HANDLE hF; + + /* copy relevant flags from second parameter */ + fileflags = FDEV; + + if (flags & O_APPEND) + fileflags |= FAPPEND; + + if (flags & O_TEXT) + fileflags |= FTEXT; + + if (flags & O_NOINHERIT) + fileflags |= FNOINHERIT; + + /* attempt to allocate a C Runtime file handle */ + hF = CreateFile("NUL", 0, 0, NULL, OPEN_ALWAYS, 0, NULL); + fh = _open_osfhandle((intptr_t)hF, 0); + CloseHandle(hF); + if (fh == -1) { + errno = EMFILE; /* too many open files */ + _doserrno = 0L; /* not an OS error */ + } + else { + + 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 */ +} + +/* License: Ruby's */ +static void +init_stdhandle(void) +{ + int nullfd = -1; + int keep = 0; +#define open_null(fd) \ + (((nullfd < 0) ? \ + (nullfd = open("NUL", O_RDWR)) : 0), \ + ((nullfd == (fd)) ? (keep = 1) : dup2(nullfd, fd)), \ + (fd)) + + if (fileno(stdin) < 0) { + stdin->_file = open_null(0); + } + else { + setmode(fileno(stdin), O_BINARY); + } + if (fileno(stdout) < 0) { + stdout->_file = open_null(1); + } + if (fileno(stderr) < 0) { + stderr->_file = open_null(2); + } + 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)) + +/* License: Ruby's */ +static void +init_stdhandle(void) +{ +} +#endif + +/* License: Ruby's */ +#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 + +/* License: Ruby's */ +static int +is_socket(SOCKET sock) +{ + if (socklist_lookup(sock, NULL)) + return TRUE; + else + return FALSE; +} + +/* License: Ruby's */ +int +rb_w32_is_socket(int fd) +{ + return is_socket(TO_SOCKET(fd)); +} + +// +// Since the errors returned by the socket error function +// WSAGetLastError() are not known by the library routine strerror +// we have to roll our own. +// + +#undef strerror + +/* License: Artistic or GPL */ +char * +rb_w32_strerror(int e) +{ + static char buffer[512]; + DWORD source = 0; + char *p; + +#if 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 WSAEWOULDBLOCK != EWOULDBLOCK + else if (e >= EADDRINUSE && e <= EWOULDBLOCK) { + static int s = -1; + int i; + if (s < 0) + for (s = 0; s < (int)(sizeof(errmap)/sizeof(*errmap)); s++) + if (errmap[s].winerr == WSAEWOULDBLOCK) + break; + for (i = s; i < (int)(sizeof(errmap)/sizeof(*errmap)); i++) + if (errmap[i].err == e) { + e = errmap[i].winerr; + break; + } + } +#endif + if (FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, &source, e, + MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), + buffer, sizeof(buffer), NULL) == 0 && + FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, &source, e, 0, + buffer, sizeof(buffer), NULL) == 0) + strlcpy(buffer, "Unknown Error", sizeof(buffer)); + } + else + strlcpy(buffer, strerror(e), sizeof(buffer)); + + p = buffer; + while ((p = strpbrk(p, "\r\n")) != NULL) { + memmove(p, p + 1, strlen(p)); + } + return buffer; +} + +// +// various stubs +// + + +// Ownership +// +// Just pretend that everyone is a superuser. NT will let us know if +// we don't really have permission to do something. +// + +#define ROOT_UID 0 +#define ROOT_GID 0 + +/* License: Artistic or GPL */ +rb_uid_t +getuid(void) +{ + return ROOT_UID; +} + +/* License: Artistic or GPL */ +rb_uid_t +geteuid(void) +{ + return ROOT_UID; +} + +/* License: Artistic or GPL */ +rb_gid_t +getgid(void) +{ + return ROOT_GID; +} + +/* License: Artistic or GPL */ +rb_gid_t +getegid(void) +{ + return ROOT_GID; +} + +/* License: Artistic or GPL */ +int +setuid(rb_uid_t uid) +{ + return (uid == ROOT_UID ? 0 : -1); +} + +/* License: Artistic or GPL */ +int +setgid(rb_gid_t gid) +{ + return (gid == ROOT_GID ? 0 : -1); +} + +// +// File system stuff +// + +/* License: Artistic or GPL */ +int +ioctl(int i, int u, ...) +{ + errno = EINVAL; + return -1; +} + +void +rb_w32_fdset(int fd, fd_set *set) +{ + FD_SET(fd, set); +} + +#undef FD_CLR + +/* License: Ruby's */ +void +rb_w32_fdclr(int fd, fd_set *set) +{ + unsigned int i; + SOCKET s = TO_SOCKET(fd); + + for (i = 0; i < set->fd_count; i++) { + if (set->fd_array[i] == s) { + memmove(&set->fd_array[i], &set->fd_array[i+1], + sizeof(set->fd_array[0]) * (--set->fd_count - i)); + break; + } + } +} + +#undef FD_ISSET + +/* License: Ruby's */ +int +rb_w32_fdisset(int fd, fd_set *set) +{ + int ret; + SOCKET s = TO_SOCKET(fd); + if (s == (SOCKET)INVALID_HANDLE_VALUE) + return 0; + RUBY_CRITICAL(ret = __WSAFDIsSet(s, set)); + return ret; +} + +/* License: Ruby's */ +void +rb_w32_fd_copy(rb_fdset_t *dst, const fd_set *src, int max) +{ + max = min(src->fd_count, (UINT)max); + if ((UINT)dst->capa < (UINT)max) { + dst->capa = (src->fd_count / FD_SETSIZE + 1) * FD_SETSIZE; + dst->fdset = xrealloc(dst->fdset, sizeof(unsigned int) + sizeof(SOCKET) * dst->capa); + } + + memcpy(dst->fdset->fd_array, src->fd_array, + max * sizeof(src->fd_array[0])); + dst->fdset->fd_count = src->fd_count; +} + +/* License: Ruby's */ +void +rb_w32_fd_dup(rb_fdset_t *dst, const rb_fdset_t *src) +{ + if ((UINT)dst->capa < src->fdset->fd_count) { + dst->capa = (src->fdset->fd_count / FD_SETSIZE + 1) * FD_SETSIZE; + dst->fdset = xrealloc(dst->fdset, sizeof(unsigned int) + sizeof(SOCKET) * dst->capa); + } + + memcpy(dst->fdset->fd_array, src->fdset->fd_array, + src->fdset->fd_count * sizeof(src->fdset->fd_array[0])); + dst->fdset->fd_count = src->fdset->fd_count; +} + +// +// Networking trampolines +// These are used to avoid socket startup/shutdown overhead in case +// the socket routines aren't used. +// + +#undef select + +/* License: Ruby's */ +static int +extract_fd(rb_fdset_t *dst, fd_set *src, int (*func)(SOCKET)) +{ + unsigned int s = 0; + unsigned int m = 0; + if (!src) return 0; + + while (s < src->fd_count) { + SOCKET fd = src->fd_array[s]; + + if (!func || (*func)(fd)) { + if (dst) { /* move it to dst */ + unsigned int d; + + for (d = 0; d < dst->fdset->fd_count; d++) { + if (dst->fdset->fd_array[d] == fd) + break; + } + if (d == dst->fdset->fd_count) { + if ((int)dst->fdset->fd_count >= dst->capa) { + dst->capa = (dst->fdset->fd_count / FD_SETSIZE + 1) * FD_SETSIZE; + dst->fdset = xrealloc(dst->fdset, 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 { + m++; + s++; + } + } + else s++; + } + + return dst ? dst->fdset->fd_count : m; +} + +/* License: Ruby's */ +static int +copy_fd(fd_set *dst, fd_set *src) +{ + unsigned int s; + if (!src || !dst) return 0; + + for (s = 0; s < src->fd_count; ++s) { + SOCKET fd = src->fd_array[s]; + unsigned int d; + for (d = 0; d < dst->fd_count; ++d) { + if (dst->fd_array[d] == fd) + break; + } + if (d == dst->fd_count && d < FD_SETSIZE) { + dst->fd_array[dst->fd_count++] = fd; + } + } + + return dst->fd_count; +} + +/* License: Ruby's */ +static int +is_not_socket(SOCKET sock) +{ + return !is_socket(sock); +} + +/* License: Ruby's */ +static int +is_pipe(SOCKET sock) /* DONT call this for SOCKET! it claims it is PIPE. */ +{ + int ret; + + RUBY_CRITICAL({ + ret = (GetFileType((HANDLE)sock) == FILE_TYPE_PIPE); + }); + + return ret; +} + +/* License: Ruby's */ +static int +is_readable_pipe(SOCKET sock) /* call this for pipe only */ +{ + int ret; + DWORD n = 0; + + RUBY_CRITICAL( + if (PeekNamedPipe((HANDLE)sock, NULL, 0, NULL, &n, NULL)) { + ret = (n > 0); + } + else { + ret = (GetLastError() == ERROR_BROKEN_PIPE); /* pipe was closed */ + } + ); + + return ret; +} + +/* License: Ruby's */ +static int +is_console(SOCKET sock) /* DONT call this for SOCKET! */ +{ + int ret; + DWORD n = 0; + INPUT_RECORD ir; + + RUBY_CRITICAL( + ret = (PeekConsoleInput((HANDLE)sock, &ir, 1, &n)) + ); + + return ret; +} + +/* License: Ruby's */ +static int +is_readable_console(SOCKET sock) /* call this for console only */ +{ + int ret = 0; + DWORD n = 0; + INPUT_RECORD ir; + + RUBY_CRITICAL( + if (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; +} + +/* License: Ruby's */ +static int +is_invalid_handle(SOCKET sock) +{ + return (HANDLE)sock == INVALID_HANDLE_VALUE; +} + +/* License: Artistic or GPL */ +static int +do_select(int nfds, fd_set *rd, fd_set *wr, fd_set *ex, + struct timeval *timeout) +{ + int r = 0; + + if (nfds == 0) { + if (timeout) + rb_w32_sleep(timeout->tv_sec * 1000 + timeout->tv_usec / 1000); + else + rb_w32_sleep(INFINITE); + } + else { + if (!NtSocketsInitialized) + StartSockets(); + + 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; +} + +/* + * rest -= wait + * return 0 if rest is smaller than wait. + */ +/* License: Ruby's */ +int +rb_w32_time_subtract(struct timeval *rest, const struct timeval *wait) +{ + if (rest->tv_sec < wait->tv_sec) { + return 0; + } + while (rest->tv_usec < wait->tv_usec) { + if (rest->tv_sec <= wait->tv_sec) { + return 0; + } + rest->tv_sec -= 1; + rest->tv_usec += 1000 * 1000; + } + rest->tv_sec -= wait->tv_sec; + rest->tv_usec -= wait->tv_usec; + return rest->tv_sec != 0 || rest->tv_usec != 0; +} + +/* License: Ruby's */ +static inline int +compare(const struct timeval *t1, const struct timeval *t2) +{ + if (t1->tv_sec < t2->tv_sec) + return -1; + if (t1->tv_sec > t2->tv_sec) + return 1; + if (t1->tv_usec < t2->tv_usec) + return -1; + if (t1->tv_usec > t2->tv_usec) + return 1; + return 0; +} + +#undef Sleep + +int rb_w32_check_interrupt(void *); /* @internal */ + +/* @internal */ +/* License: Ruby's */ +int +rb_w32_select_with_thread(int nfds, fd_set *rd, fd_set *wr, fd_set *ex, + struct timeval *timeout, void *th) +{ + int r; + rb_fdset_t pipe_rd; + rb_fdset_t cons_rd; + rb_fdset_t else_rd; + rb_fdset_t else_wr; + rb_fdset_t except; + int nonsock = 0; + struct timeval limit = {0, 0}; + + if (nfds < 0 || (timeout && (timeout->tv_sec < 0 || timeout->tv_usec < 0))) { + errno = EINVAL; + return -1; + } + + if (timeout) { + if (timeout->tv_sec < 0 || + timeout->tv_usec < 0 || + timeout->tv_usec >= 1000000) { + errno = EINVAL; + return -1; + } + gettimeofday(&limit, NULL); + limit.tv_sec += timeout->tv_sec; + limit.tv_usec += timeout->tv_usec; + if (limit.tv_usec >= 1000000) { + limit.tv_usec -= 1000000; + limit.tv_sec++; + } + } + + // assume else_{rd,wr} (other than socket, pipe reader, console reader) + // are always readable/writable. but this implementation still has + // problem. if pipe's buffer is full, writing to pipe will block + // until some data is read from pipe. but ruby is single threaded system, + // so whole system will be blocked forever. + + rb_fd_init(&else_rd); + nonsock += extract_fd(&else_rd, rd, is_not_socket); + + rb_fd_init(&else_wr); + nonsock += extract_fd(&else_wr, wr, is_not_socket); + + // check invalid handles + if (extract_fd(NULL, else_rd.fdset, is_invalid_handle) > 0 || + extract_fd(NULL, else_wr.fdset, is_invalid_handle) > 0) { + rb_fd_term(&else_wr); + rb_fd_term(&else_rd); + errno = EBADF; + return -1; + } + + rb_fd_init(&pipe_rd); + extract_fd(&pipe_rd, else_rd.fdset, is_pipe); // should not call is_pipe for socket + + rb_fd_init(&cons_rd); + extract_fd(&cons_rd, else_rd.fdset, is_console); // ditto + + rb_fd_init(&except); + extract_fd(&except, ex, is_not_socket); // drop only + + r = 0; + if (rd && (int)rd->fd_count > r) r = (int)rd->fd_count; + if (wr && (int)wr->fd_count > r) r = (int)wr->fd_count; + if (ex && (int)ex->fd_count > r) r = (int)ex->fd_count; + if (nfds > r) nfds = r; + + { + struct timeval rest; + const struct timeval wait = {0, 10 * 1000}; // 10ms + struct timeval zero = {0, 0}; // 0ms + for (;;) { + if (th && rb_w32_check_interrupt(th) != WAIT_TIMEOUT) { + r = -1; + break; + } + if (nonsock) { + // modifying {else,pipe,cons}_rd is safe because + // if they are modified, function returns immediately. + extract_fd(&else_rd, pipe_rd.fdset, is_readable_pipe); + extract_fd(&else_rd, cons_rd.fdset, is_readable_console); + } + + if (else_rd.fdset->fd_count || else_wr.fdset->fd_count) { + r = do_select(nfds, rd, wr, ex, &zero); // polling + if (r < 0) break; // XXX: should I ignore error and return signaled handles? + r += copy_fd(rd, else_rd.fdset); + r += copy_fd(wr, else_wr.fdset); + if (ex) + r += ex->fd_count; + break; + } + else { + const struct timeval *dowait = &wait; + + fd_set orig_rd; + fd_set orig_wr; + fd_set orig_ex; + + FD_ZERO(&orig_rd); + FD_ZERO(&orig_wr); + FD_ZERO(&orig_ex); + + if (rd) copy_fd(&orig_rd, rd); + if (wr) copy_fd(&orig_wr, wr); + if (ex) copy_fd(&orig_ex, ex); + r = do_select(nfds, rd, wr, ex, &zero); // polling + if (r != 0) break; // signaled or error + if (rd) copy_fd(rd, &orig_rd); + if (wr) copy_fd(wr, &orig_wr); + if (ex) copy_fd(ex, &orig_ex); + + if (timeout) { + struct timeval now; + gettimeofday(&now, NULL); + rest = limit; + if (!rb_w32_time_subtract(&rest, &now)) break; + if (compare(&rest, &wait) < 0) dowait = &rest; + } + Sleep(dowait->tv_sec * 1000 + (dowait->tv_usec + 999) / 1000); + } + } + } + + rb_fd_term(&except); + rb_fd_term(&cons_rd); + rb_fd_term(&pipe_rd); + rb_fd_term(&else_wr); + rb_fd_term(&else_rd); + + return r; +} + +/* License: Ruby's */ +int WSAAPI +rb_w32_select(int nfds, fd_set *rd, fd_set *wr, fd_set *ex, + struct timeval *timeout) +{ + return rb_w32_select_with_thread(nfds, rd, wr, ex, timeout, 0); +} + +/* License: Ruby's */ +static FARPROC +get_wsa_extension_function(SOCKET s, GUID *guid) +{ + DWORD dmy; + FARPROC ptr = NULL; + + WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, guid, sizeof(*guid), + &ptr, sizeof(ptr), &dmy, NULL, NULL); + if (!ptr) + errno = ENOSYS; + return ptr; +} + +#undef accept + +/* License: Artistic or GPL */ +int WSAAPI +rb_w32_accept(int s, struct sockaddr *addr, int *addrlen) +{ + SOCKET r; + int fd; + + 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) { + SetHandleInformation((HANDLE)r, HANDLE_FLAG_INHERIT, 0); + MTHREAD_ONLY(EnterCriticalSection(&(_pioinfo(fd)->lock))); + _set_osfhnd(fd, r); + MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock)); + CloseHandle(h); + socklist_insert(r, 0); + } + else { + errno = map_errno(WSAGetLastError()); + close(fd); + fd = -1; + } + } + else + CloseHandle(h); + }); + return fd; +} + +#undef bind + +/* License: Artistic or GPL */ +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 + +/* License: Artistic or GPL */ +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) { + int err = WSAGetLastError(); + if (err != WSAEWOULDBLOCK) + errno = map_errno(err); + else + errno = EINPROGRESS; + } + }); + return r; +} + + +#undef getpeername + +/* License: Artistic or GPL */ +int WSAAPI +rb_w32_getpeername(int s, struct sockaddr *addr, int *addrlen) +{ + int r; + if (!NtSocketsInitialized) { + StartSockets(); + } + RUBY_CRITICAL({ + r = getpeername(TO_SOCKET(s), addr, addrlen); + if (r == SOCKET_ERROR) + errno = map_errno(WSAGetLastError()); + }); + return r; +} + +#undef getsockname + +/* License: Artistic or GPL */ +int WSAAPI +rb_w32_getsockname(int fd, struct sockaddr *addr, int *addrlen) +{ + int sock; + int r; + if (!NtSocketsInitialized) { + StartSockets(); + } + RUBY_CRITICAL({ + sock = TO_SOCKET(fd); + r = getsockname(sock, addr, addrlen); + if (r == SOCKET_ERROR) { + DWORD wsaerror = WSAGetLastError(); + if (wsaerror == WSAEINVAL) { + int flags; + if (socklist_lookup(sock, &flags)) { + int af = GET_FAMILY(flags); + if (af) { + memset(addr, 0, *addrlen); + addr->sa_family = af; + return 0; + } + } + } + errno = map_errno(wsaerror); + } + }); + return r; +} + +#undef getsockopt + +/* License: Artistic or GPL */ +int WSAAPI +rb_w32_getsockopt(int s, int level, int optname, char *optval, int *optlen) +{ + int r; + 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 + +/* License: Artistic or GPL */ +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 + +/* License: Artistic or GPL */ +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 + +/* License: Ruby's */ +static int +finish_overlapped_socket(BOOL input, SOCKET s, WSAOVERLAPPED *wol, int result, DWORD *len, DWORD size) +{ + DWORD flg; + int err; + + if (result != SOCKET_ERROR) + *len = size; + else if ((err = WSAGetLastError()) == WSA_IO_PENDING) { + switch (rb_w32_wait_events_blocking(&wol->hEvent, 1, INFINITE)) { + case WAIT_OBJECT_0: + RUBY_CRITICAL( + result = WSAGetOverlappedResult(s, wol, &size, TRUE, &flg) + ); + if (result) { + *len = size; + break; + } + /* thru */ + default: + if ((err = WSAGetLastError()) == WSAECONNABORTED && !input) + errno = EPIPE; + else + errno = map_errno(WSAGetLastError()); + /* thru */ + case WAIT_OBJECT_0 + 1: + /* interrupted */ + *len = -1; + cancel_io((HANDLE)s); + break; + } + } + else { + if (err == WSAECONNABORTED && !input) + errno = EPIPE; + else + errno = map_errno(err); + *len = -1; + } + CloseHandle(wol->hEvent); + + return result; +} + +/* License: Artistic or GPL */ +static int +overlapped_socket_io(BOOL input, int fd, char *buf, int len, int flags, + struct sockaddr *addr, int *addrlen) +{ + int r; + int ret; + int mode = 0; + DWORD flg; + WSAOVERLAPPED wol; + WSABUF wbuf; + SOCKET s; + + if (!NtSocketsInitialized) + StartSockets(); + + s = TO_SOCKET(fd); + socklist_lookup(s, &mode); + if (!cancel_io || (GET_FLAGS(mode) & O_NONBLOCK)) { + RUBY_CRITICAL({ + if (input) { + if (addr && addrlen) + r = recvfrom(s, buf, len, flags, addr, addrlen); + else + r = recv(s, buf, len, flags); + if (r == SOCKET_ERROR) + errno = map_errno(WSAGetLastError()); + } + else { + if (addr && addrlen) + r = sendto(s, buf, len, flags, addr, *addrlen); + else + r = send(s, buf, len, flags); + if (r == SOCKET_ERROR) { + DWORD err = WSAGetLastError(); + if (err == WSAECONNABORTED) + errno = EPIPE; + else + errno = map_errno(err); + } + } + }); + } + else { + DWORD size; + DWORD rlen; + wbuf.len = len; + wbuf.buf = buf; + memset(&wol, 0, sizeof(wol)); + RUBY_CRITICAL({ + wol.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); + if (input) { + flg = flags; + if (addr && addrlen) + ret = WSARecvFrom(s, &wbuf, 1, &size, &flg, addr, addrlen, + &wol, NULL); + else + ret = WSARecv(s, &wbuf, 1, &size, &flg, &wol, NULL); + } + else { + if (addr && addrlen) + ret = WSASendTo(s, &wbuf, 1, &size, flags, addr, *addrlen, + &wol, NULL); + else + ret = WSASend(s, &wbuf, 1, &size, flags, &wol, NULL); + } + }); + + finish_overlapped_socket(input, s, &wol, ret, &rlen, size); + r = (int)rlen; + } + + return r; +} + +/* License: Ruby's */ +int WSAAPI +rb_w32_recv(int fd, char *buf, int len, int flags) +{ + return overlapped_socket_io(TRUE, fd, buf, len, flags, NULL, NULL); +} + +/* License: Ruby's */ +int WSAAPI +rb_w32_recvfrom(int fd, char *buf, int len, int flags, + struct sockaddr *from, int *fromlen) +{ + return overlapped_socket_io(TRUE, fd, buf, len, flags, from, fromlen); +} + +/* License: Ruby's */ +int WSAAPI +rb_w32_send(int fd, const char *buf, int len, int flags) +{ + return overlapped_socket_io(FALSE, fd, (char *)buf, len, flags, NULL, NULL); +} + +/* License: Ruby's */ +int WSAAPI +rb_w32_sendto(int fd, const char *buf, int len, int flags, + const struct sockaddr *to, int tolen) +{ + return overlapped_socket_io(FALSE, fd, (char *)buf, len, flags, + (struct sockaddr *)to, &tolen); +} + +#if !defined(MSG_TRUNC) && !defined(__MINGW32__) +/* License: Ruby's */ +typedef struct { + SOCKADDR *name; + int namelen; + WSABUF *lpBuffers; + DWORD dwBufferCount; + WSABUF Control; + DWORD dwFlags; +} WSAMSG; +#endif +#ifndef WSAID_WSARECVMSG +#define WSAID_WSARECVMSG {0xf689d7c8,0x6f1f,0x436b,{0x8a,0x53,0xe5,0x4f,0xe3,0x51,0xc3,0x22}} +#endif +#ifndef WSAID_WSASENDMSG +#define WSAID_WSASENDMSG {0xa441e712,0x754f,0x43ca,{0x84,0xa7,0x0d,0xee,0x44,0xcf,0x60,0x6d}} +#endif + +/* License: Ruby's */ +#define msghdr_to_wsamsg(msg, wsamsg) \ + do { \ + int i; \ + (wsamsg)->name = (msg)->msg_name; \ + (wsamsg)->namelen = (msg)->msg_namelen; \ + (wsamsg)->lpBuffers = ALLOCA_N(WSABUF, (msg)->msg_iovlen); \ + (wsamsg)->dwBufferCount = (msg)->msg_iovlen; \ + for (i = 0; i < (msg)->msg_iovlen; ++i) { \ + (wsamsg)->lpBuffers[i].buf = (msg)->msg_iov[i].iov_base; \ + (wsamsg)->lpBuffers[i].len = (msg)->msg_iov[i].iov_len; \ + } \ + (wsamsg)->Control.buf = (msg)->msg_control; \ + (wsamsg)->Control.len = (msg)->msg_controllen; \ + (wsamsg)->dwFlags = (msg)->msg_flags; \ + } while (0) + +/* License: Ruby's */ +int +recvmsg(int fd, struct msghdr *msg, int flags) +{ + typedef int (WSAAPI *WSARecvMsg_t)(SOCKET, WSAMSG *, DWORD *, WSAOVERLAPPED *, LPWSAOVERLAPPED_COMPLETION_ROUTINE); + static WSARecvMsg_t pWSARecvMsg = NULL; + WSAMSG wsamsg; + SOCKET s; + int mode = 0; + DWORD len; + int ret; + + if (!NtSocketsInitialized) + StartSockets(); + + s = TO_SOCKET(fd); + + if (!pWSARecvMsg) { + static GUID guid = WSAID_WSARECVMSG; + pWSARecvMsg = (WSARecvMsg_t)get_wsa_extension_function(s, &guid); + if (!pWSARecvMsg) + return -1; + } + + msghdr_to_wsamsg(msg, &wsamsg); + wsamsg.dwFlags |= flags; + + socklist_lookup(s, &mode); + if (!cancel_io || (GET_FLAGS(mode) & O_NONBLOCK)) { + RUBY_CRITICAL({ + if ((ret = pWSARecvMsg(s, &wsamsg, &len, NULL, NULL)) == SOCKET_ERROR) { + errno = map_errno(WSAGetLastError()); + len = -1; + } + }); + } + else { + DWORD size; + WSAOVERLAPPED wol; + memset(&wol, 0, sizeof(wol)); + RUBY_CRITICAL({ + wol.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); + ret = pWSARecvMsg(s, &wsamsg, &size, &wol, NULL); + }); + + ret = finish_overlapped_socket(TRUE, s, &wol, ret, &len, size); + } + if (ret == SOCKET_ERROR) + return -1; + + /* WSAMSG to msghdr */ + msg->msg_name = wsamsg.name; + msg->msg_namelen = wsamsg.namelen; + msg->msg_flags = wsamsg.dwFlags; + + return len; +} + +/* License: Ruby's */ +int +sendmsg(int fd, const struct msghdr *msg, int flags) +{ + typedef int (WSAAPI *WSASendMsg_t)(SOCKET, const WSAMSG *, DWORD, DWORD *, WSAOVERLAPPED *, LPWSAOVERLAPPED_COMPLETION_ROUTINE); + static WSASendMsg_t pWSASendMsg = NULL; + WSAMSG wsamsg; + SOCKET s; + int mode = 0; + DWORD len; + int ret; + + if (!NtSocketsInitialized) + StartSockets(); + + s = TO_SOCKET(fd); + + if (!pWSASendMsg) { + static GUID guid = WSAID_WSASENDMSG; + pWSASendMsg = (WSASendMsg_t)get_wsa_extension_function(s, &guid); + if (!pWSASendMsg) + return -1; + } + + msghdr_to_wsamsg(msg, &wsamsg); + + socklist_lookup(s, &mode); + if (!cancel_io || (GET_FLAGS(mode) & O_NONBLOCK)) { + RUBY_CRITICAL({ + if ((ret = pWSASendMsg(s, &wsamsg, flags, &len, NULL, NULL)) == SOCKET_ERROR) { + errno = map_errno(WSAGetLastError()); + len = -1; + } + }); + } + else { + DWORD size; + WSAOVERLAPPED wol; + memset(&wol, 0, sizeof(wol)); + RUBY_CRITICAL({ + wol.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); + ret = pWSASendMsg(s, &wsamsg, flags, &size, &wol, NULL); + }); + + finish_overlapped_socket(FALSE, s, &wol, ret, &len, size); + } + + return len; +} + +#undef setsockopt + +/* License: Artistic or GPL */ +int WSAAPI +rb_w32_setsockopt(int s, int level, int optname, const char *optval, int optlen) +{ + int r; + 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 + +/* License: Artistic or GPL */ +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; +} + +/* License: Ruby's */ +static SOCKET +open_ifs_socket(int af, int type, int protocol) +{ + unsigned long proto_buffers_len = 0; + int error_code; + SOCKET out = INVALID_SOCKET; + + if (WSAEnumProtocols(NULL, NULL, &proto_buffers_len) == SOCKET_ERROR) { + error_code = WSAGetLastError(); + if (error_code == WSAENOBUFS) { + WSAPROTOCOL_INFO *proto_buffers; + int protocols_available = 0; + + proto_buffers = (WSAPROTOCOL_INFO *)malloc(proto_buffers_len); + if (!proto_buffers) { + WSASetLastError(WSA_NOT_ENOUGH_MEMORY); + return INVALID_SOCKET; + } + + protocols_available = + WSAEnumProtocols(NULL, proto_buffers, &proto_buffers_len); + if (protocols_available != SOCKET_ERROR) { + int i; + for (i = 0; i < protocols_available; i++) { + if ((af != AF_UNSPEC && af != proto_buffers[i].iAddressFamily) || + (type != proto_buffers[i].iSocketType) || + (protocol != 0 && protocol != proto_buffers[i].iProtocol)) + continue; + + if ((proto_buffers[i].dwServiceFlags1 & XP1_IFS_HANDLES) == 0) + continue; + + out = WSASocket(af, type, protocol, &(proto_buffers[i]), 0, + WSA_FLAG_OVERLAPPED); + break; + } + if (out == INVALID_SOCKET) + out = WSASocket(af, type, protocol, NULL, 0, 0); + if (out != INVALID_SOCKET) + SetHandleInformation((HANDLE)out, HANDLE_FLAG_INHERIT, 0); + } + + free(proto_buffers); + } + } + + return out; +} + +#undef socket + +/* License: Artistic or GPL */ +int WSAAPI +rb_w32_socket(int af, int type, int protocol) +{ + SOCKET s; + int fd; + + 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) + socklist_insert(s, MAKE_SOCKDATA(af, 0)); + else + closesocket(s); + } + }); + return fd; +} + +#undef gethostbyaddr + +/* License: Artistic or GPL */ +struct hostent * WSAAPI +rb_w32_gethostbyaddr(const char *addr, int len, int type) +{ + struct hostent *r; + if (!NtSocketsInitialized) { + StartSockets(); + } + RUBY_CRITICAL({ + r = gethostbyaddr(addr, len, type); + if (r == NULL) + errno = map_errno(WSAGetLastError()); + }); + return r; +} + +#undef gethostbyname + +/* License: Artistic or GPL */ +struct hostent * WSAAPI +rb_w32_gethostbyname(const char *name) +{ + struct hostent *r; + if (!NtSocketsInitialized) { + StartSockets(); + } + RUBY_CRITICAL({ + r = gethostbyname(name); + if (r == NULL) + errno = map_errno(WSAGetLastError()); + }); + return r; +} + +#undef gethostname + +/* License: Artistic or GPL */ +int WSAAPI +rb_w32_gethostname(char *name, int len) +{ + int r; + if (!NtSocketsInitialized) { + StartSockets(); + } + RUBY_CRITICAL({ + r = gethostname(name, len); + if (r == SOCKET_ERROR) + errno = map_errno(WSAGetLastError()); + }); + return r; +} + +#undef getprotobyname + +/* License: Artistic or GPL */ +struct protoent * WSAAPI +rb_w32_getprotobyname(const char *name) +{ + struct protoent *r; + if (!NtSocketsInitialized) { + StartSockets(); + } + RUBY_CRITICAL({ + r = getprotobyname(name); + if (r == NULL) + errno = map_errno(WSAGetLastError()); + }); + return r; +} + +#undef getprotobynumber + +/* License: Artistic or GPL */ +struct protoent * WSAAPI +rb_w32_getprotobynumber(int num) +{ + struct protoent *r; + if (!NtSocketsInitialized) { + StartSockets(); + } + RUBY_CRITICAL({ + r = getprotobynumber(num); + if (r == NULL) + errno = map_errno(WSAGetLastError()); + }); + return r; +} + +#undef getservbyname + +/* License: Artistic or GPL */ +struct servent * WSAAPI +rb_w32_getservbyname(const char *name, const char *proto) +{ + struct servent *r; + if (!NtSocketsInitialized) { + StartSockets(); + } + RUBY_CRITICAL({ + r = getservbyname(name, proto); + if (r == NULL) + errno = map_errno(WSAGetLastError()); + }); + return r; +} + +#undef getservbyport + +/* License: Artistic or GPL */ +struct servent * WSAAPI +rb_w32_getservbyport(int port, const char *proto) +{ + struct servent *r; + if (!NtSocketsInitialized) { + StartSockets(); + } + RUBY_CRITICAL({ + r = getservbyport(port, proto); + if (r == NULL) + errno = map_errno(WSAGetLastError()); + }); + return r; +} + +/* License: Ruby's */ +static int +socketpair_internal(int af, int type, int protocol, SOCKET *sv) +{ + SOCKET svr = INVALID_SOCKET, r = INVALID_SOCKET, w = INVALID_SOCKET; + struct sockaddr_in sock_in4; +#ifdef INET6 + struct sockaddr_in6 sock_in6; +#endif + 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; + } + + sv[0] = (SOCKET)INVALID_HANDLE_VALUE; + sv[1] = (SOCKET)INVALID_HANDLE_VALUE; + RUBY_CRITICAL({ + do { + svr = open_ifs_socket(af, type, protocol); + if (svr == INVALID_SOCKET) + break; + if (bind(svr, addr, len) < 0) + break; + if (getsockname(svr, addr, &len) < 0) + break; + if (type == SOCK_STREAM) + listen(svr, 5); + + w = open_ifs_socket(af, type, protocol); + if (w == INVALID_SOCKET) + break; + if (connect(w, addr, len) < 0) + break; + + r = accept(svr, addr, &len); + if (r == INVALID_SOCKET) + break; + SetHandleInformation((HANDLE)r, HANDLE_FLAG_INHERIT, 0); + + ret = 0; + } while (0); + + if (ret < 0) { + errno = map_errno(WSAGetLastError()); + if (r != INVALID_SOCKET) + closesocket(r); + if (w != INVALID_SOCKET) + closesocket(w); + } + else { + sv[0] = r; + sv[1] = w; + } + if (svr != INVALID_SOCKET) + closesocket(svr); + }); + + return ret; +} + +/* License: Ruby's */ +int +socketpair(int af, int type, int protocol, int *sv) +{ + SOCKET pair[2]; + + if (socketpair_internal(af, type, protocol, pair) < 0) + return -1; + sv[0] = rb_w32_open_osfhandle(pair[0], O_RDWR|O_BINARY|O_NOINHERIT); + if (sv[0] == -1) { + closesocket(pair[0]); + closesocket(pair[1]); + return -1; + } + sv[1] = rb_w32_open_osfhandle(pair[1], O_RDWR|O_BINARY|O_NOINHERIT); + if (sv[1] == -1) { + rb_w32_close(sv[0]); + closesocket(pair[1]); + return -1; + } + socklist_insert(pair[0], MAKE_SOCKDATA(af, 0)); + socklist_insert(pair[1], MAKE_SOCKDATA(af, 0)); + + return 0; +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1400 +/* License: Ruby's */ +static void +str2guid(const char *str, GUID *guid) +{ +#define hex2byte(str) \ + ((isdigit(*(str)) ? *(str) - '0' : toupper(*(str)) - 'A' + 10) << 4 | (isdigit(*((str) + 1)) ? *((str) + 1) - '0' : toupper(*((str) + 1)) - 'A' + 10)) + char *end; + int i; + if (*str == '{') str++; + guid->Data1 = (long)strtoul(str, &end, 16); + str += 9; + guid->Data2 = (unsigned short)strtoul(str, &end, 16); + str += 5; + guid->Data3 = (unsigned short)strtoul(str, &end, 16); + str += 5; + guid->Data4[0] = hex2byte(str); + str += 2; + guid->Data4[1] = hex2byte(str); + str += 3; + for (i = 0; i < 6; i++) { + guid->Data4[i + 2] = hex2byte(str); + str += 2; + } +} + +/* License: Ruby's */ +#ifndef HAVE_TYPE_NET_LUID + typedef struct { + uint64_t Value; + struct { + uint64_t Reserved :24; + uint64_t NetLuidIndex :24; + uint64_t IfType :16; + } Info; + } NET_LUID; +#endif +typedef DWORD (WINAPI *cigl_t)(const GUID *, NET_LUID *); +typedef DWORD (WINAPI *cilnA_t)(const NET_LUID *, char *, size_t); +static cigl_t pConvertInterfaceGuidToLuid = NULL; +static cilnA_t pConvertInterfaceLuidToNameA = NULL; + +int +getifaddrs(struct ifaddrs **ifap) +{ + ULONG size = 0; + ULONG ret; + IP_ADAPTER_ADDRESSES *root, *addr; + struct ifaddrs *prev; + + ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size); + if (ret != ERROR_BUFFER_OVERFLOW) { + errno = map_errno(ret); + return -1; + } + root = ruby_xmalloc(size); + ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, root, &size); + if (ret != ERROR_SUCCESS) { + errno = map_errno(ret); + ruby_xfree(root); + return -1; + } + + if (!pConvertInterfaceGuidToLuid) + pConvertInterfaceGuidToLuid = + (cigl_t)get_proc_address("iphlpapi.dll", + "ConvertInterfaceGuidToLuid", NULL); + if (!pConvertInterfaceLuidToNameA) + pConvertInterfaceLuidToNameA = + (cilnA_t)get_proc_address("iphlpapi.dll", + "ConvertInterfaceLuidToNameA", NULL); + + for (prev = NULL, addr = root; addr; addr = addr->Next) { + struct ifaddrs *ifa = ruby_xcalloc(1, sizeof(*ifa)); + char name[IFNAMSIZ]; + GUID guid; + NET_LUID luid; + + if (prev) + prev->ifa_next = ifa; + else + *ifap = ifa; + + str2guid(addr->AdapterName, &guid); + if (pConvertInterfaceGuidToLuid && pConvertInterfaceLuidToNameA && + pConvertInterfaceGuidToLuid(&guid, &luid) == NO_ERROR && + pConvertInterfaceLuidToNameA(&luid, name, sizeof(name)) == NO_ERROR) { + ifa->ifa_name = ruby_xmalloc(lstrlen(name) + 1); + lstrcpy(ifa->ifa_name, name); + } + else { + ifa->ifa_name = ruby_xmalloc(lstrlen(addr->AdapterName) + 1); + lstrcpy(ifa->ifa_name, addr->AdapterName); + } + + if (addr->IfType & IF_TYPE_SOFTWARE_LOOPBACK) + ifa->ifa_flags |= IFF_LOOPBACK; + if (addr->OperStatus == IfOperStatusUp) { + ifa->ifa_flags |= IFF_UP; + + if (addr->FirstUnicastAddress) { + IP_ADAPTER_UNICAST_ADDRESS *cur; + int added = 0; + for (cur = addr->FirstUnicastAddress; cur; cur = cur->Next) { + if (cur->Flags & IP_ADAPTER_ADDRESS_TRANSIENT || + cur->DadState == IpDadStateDeprecated) { + continue; + } + if (added) { + prev = ifa; + ifa = ruby_xcalloc(1, sizeof(*ifa)); + prev->ifa_next = ifa; + ifa->ifa_name = + ruby_xmalloc(lstrlen(prev->ifa_name) + 1); + lstrcpy(ifa->ifa_name, prev->ifa_name); + ifa->ifa_flags = prev->ifa_flags; + } + ifa->ifa_addr = ruby_xmalloc(cur->Address.iSockaddrLength); + memcpy(ifa->ifa_addr, cur->Address.lpSockaddr, + cur->Address.iSockaddrLength); + added = 1; + } + } + } + + prev = ifa; + } + + ruby_xfree(root); + return 0; +} + +/* License: Ruby's */ +void +freeifaddrs(struct ifaddrs *ifp) +{ + while (ifp) { + struct ifaddrs *next = ifp->ifa_next; + if (ifp->ifa_addr) ruby_xfree(ifp->ifa_addr); + if (ifp->ifa_name) ruby_xfree(ifp->ifa_name); + ruby_xfree(ifp); + ifp = next; + } +} +#endif + +// +// 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) {} + +/* License: Ruby's */ +static int +setfl(SOCKET sock, int arg) +{ + int ret; + int af = 0; + int flag = 0; + u_long ioctlArg; + + socklist_lookup(sock, &flag); + af = GET_FAMILY(flag); + flag = GET_FLAGS(flag); + if (arg & O_NONBLOCK) { + flag |= O_NONBLOCK; + ioctlArg = 1; + } + else { + flag &= ~O_NONBLOCK; + ioctlArg = 0; + } + RUBY_CRITICAL({ + ret = ioctlsocket(sock, FIONBIO, &ioctlArg); + if (ret == 0) + socklist_insert(sock, MAKE_SOCKDATA(af, flag)); + else + errno = map_errno(WSAGetLastError()); + }); + + return ret; +} + +/* License: Ruby's */ +static int +dupfd(HANDLE hDup, char flags, int minfd) +{ + int save_errno; + int ret; + int fds[32]; + int filled = 0; + + do { + ret = _open_osfhandle((intptr_t)hDup, flags | FOPEN); + if (ret == -1) { + goto close_fds_and_return; + } + if (ret >= minfd) { + goto close_fds_and_return; + } + fds[filled++] = ret; + } while (filled < (int)numberof(fds)); + + ret = dupfd(hDup, flags, minfd); + + close_fds_and_return: + save_errno = errno; + while (filled > 0) { + int fd = fds[--filled]; + _osfhnd(fd) = (intptr_t)INVALID_HANDLE_VALUE; + close(fd); + } + errno = save_errno; + + return ret; +} + +/* License: Ruby's */ +int +fcntl(int fd, int cmd, ...) +{ + va_list va; + int arg; + + if (cmd == F_SETFL) { + SOCKET sock = TO_SOCKET(fd); + if (!is_socket(sock)) { + errno = EBADF; + return -1; + } + + va_start(va, cmd); + arg = va_arg(va, int); + va_end(va); + return setfl(sock, arg); + } + else if (cmd == F_DUPFD) { + int ret; + HANDLE hDup; + if (!(DuplicateHandle(GetCurrentProcess(), (HANDLE)_get_osfhandle(fd), + GetCurrentProcess(), &hDup, 0L, + !(_osfile(fd) & FNOINHERIT), + DUPLICATE_SAME_ACCESS))) { + errno = map_errno(GetLastError()); + return -1; + } + + va_start(va, cmd); + arg = va_arg(va, int); + va_end(va); + + if ((ret = dupfd(hDup, _osfile(fd), arg)) == -1) + CloseHandle(hDup); + return ret; + } + else { + errno = EINVAL; + return -1; + } +} + +/* License: Ruby's */ +int +rb_w32_set_nonblock(int fd) +{ + SOCKET sock = TO_SOCKET(fd); + if (is_socket(sock)) { + return setfl(sock, O_NONBLOCK); + } + else if (is_pipe(sock)) { + DWORD state; + if (!GetNamedPipeHandleState((HANDLE)sock, &state, NULL, NULL, NULL, NULL, 0)) { + errno = map_errno(GetLastError()); + return -1; + } + state |= PIPE_NOWAIT; + if (!SetNamedPipeHandleState((HANDLE)sock, &state, NULL, NULL)) { + errno = map_errno(GetLastError()); + return -1; + } + return 0; + } + else { + errno = EBADF; + return -1; + } +} + +#ifndef WNOHANG +#define WNOHANG -1 +#endif + +/* License: Ruby's */ +static rb_pid_t +poll_child_status(struct ChildRecord *child, int *stat_loc) +{ + DWORD exitcode; + DWORD err; + + if (!GetExitCodeProcess(child->hProcess, &exitcode)) { + /* If an error occurred, return immediately. */ + error_exit: + err = GetLastError(); + switch (err) { + case ERROR_INVALID_PARAMETER: + errno = ECHILD; + break; + case ERROR_INVALID_HANDLE: + errno = EINVAL; + break; + default: + errno = map_errno(err); + break; + } + CloseChildHandle(child); + return -1; + } + if (exitcode != STILL_ACTIVE) { + rb_pid_t pid; + /* If already died, wait process's real termination. */ + if (rb_w32_wait_events_blocking(&child->hProcess, 1, INFINITE) != WAIT_OBJECT_0) { + goto error_exit; + } + pid = child->pid; + CloseChildHandle(child); + if (stat_loc) { + *stat_loc = exitcode << 8; + if (exitcode & 0xC0000000) { + static const struct { + DWORD status; + int sig; + } table[] = { + {STATUS_ACCESS_VIOLATION, SIGSEGV}, + {STATUS_ILLEGAL_INSTRUCTION, SIGILL}, + {STATUS_PRIVILEGED_INSTRUCTION, SIGILL}, + {STATUS_FLOAT_DENORMAL_OPERAND, SIGFPE}, + {STATUS_FLOAT_DIVIDE_BY_ZERO, SIGFPE}, + {STATUS_FLOAT_INEXACT_RESULT, SIGFPE}, + {STATUS_FLOAT_INVALID_OPERATION, SIGFPE}, + {STATUS_FLOAT_OVERFLOW, SIGFPE}, + {STATUS_FLOAT_STACK_CHECK, SIGFPE}, + {STATUS_FLOAT_UNDERFLOW, SIGFPE}, +#ifdef STATUS_FLOAT_MULTIPLE_FAULTS + {STATUS_FLOAT_MULTIPLE_FAULTS, SIGFPE}, +#endif +#ifdef STATUS_FLOAT_MULTIPLE_TRAPS + {STATUS_FLOAT_MULTIPLE_TRAPS, SIGFPE}, +#endif + {STATUS_CONTROL_C_EXIT, SIGINT}, + }; + int i; + for (i = 0; i < (int)numberof(table); i++) { + if (table[i].status == exitcode) { + *stat_loc |= table[i].sig; + break; + } + } + // if unknown status, assume SEGV + if (i >= (int)numberof(table)) + *stat_loc |= SIGSEGV; + } + } + return pid; + } + return 0; +} + +/* License: Artistic or GPL */ +rb_pid_t +waitpid(rb_pid_t pid, int *stat_loc, int options) +{ + DWORD timeout; + + /* Artistic or GPL part start */ + if (options == WNOHANG) { + timeout = 0; + } + else { + timeout = INFINITE; + } + /* Artistic or GPL part end */ + + if (pid == -1) { + int count = 0; + int ret; + HANDLE events[MAXCHILDNUM]; + struct ChildRecord* cause; + + FOREACH_CHILD(child) { + if (!child->pid || child->pid < 0) continue; + if ((pid = poll_child_status(child, stat_loc))) return pid; + events[count++] = child->hProcess; + } END_FOREACH_CHILD; + if (!count) { + errno = ECHILD; + return -1; + } + + ret = rb_w32_wait_events_blocking(events, count, timeout); + if (ret == WAIT_TIMEOUT) return 0; + if ((ret -= WAIT_OBJECT_0) == count) { + return -1; + } + if (ret > count) { + errno = map_errno(GetLastError()); + return -1; + } + + cause = FindChildSlotByHandle(events[ret]); + if (!cause) { + errno = ECHILD; + return -1; + } + return poll_child_status(cause, stat_loc); + } + else { + struct ChildRecord* child = FindChildSlot(pid); + int retried = 0; + if (!child) { + errno = ECHILD; + return -1; + } + + while (!(pid = poll_child_status(child, stat_loc))) { + /* wait... */ + int ret = rb_w32_wait_events_blocking(&child->hProcess, 1, timeout); + if (ret == WAIT_OBJECT_0 + 1) return -1; /* maybe EINTR */ + if (ret != WAIT_OBJECT_0) { + /* still active */ + if (options & WNOHANG) { + pid = 0; + break; + } + ++retried; + } + } + if (pid == -1 && retried) pid = 0; + } + + return pid; +} + +#include + +/* License: Ruby's */ +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 = (long)(lt / (1000 * 1000)); + tv->tv_usec = (long)(lt % (1000 * 1000)); + + return tv->tv_sec > 0 ? 0 : -1; +} + +/* License: Ruby's */ +int __cdecl +gettimeofday(struct timeval *tv, struct timezone *tz) +{ + FILETIME ft; + + GetSystemTimeAsFileTime(&ft); + filetime_to_timeval(&ft, tv); + + return 0; +} + +/* License: Ruby's */ +int +clock_gettime(clockid_t clock_id, struct timespec *sp) +{ + switch (clock_id) { + case CLOCK_REALTIME: + { + struct timeval tv; + gettimeofday(&tv, NULL); + sp->tv_sec = tv.tv_sec; + sp->tv_nsec = tv.tv_usec * 1000; + return 0; + } + case CLOCK_MONOTONIC: + { + LARGE_INTEGER freq; + LARGE_INTEGER count; + if (!QueryPerformanceFrequency(&freq)) { + errno = map_errno(GetLastError()); + return -1; + } + if (!QueryPerformanceCounter(&count)) { + errno = map_errno(GetLastError()); + return -1; + } + sp->tv_sec = count.QuadPart / freq.QuadPart; + if (freq.QuadPart < 1000000000) + sp->tv_nsec = (count.QuadPart % freq.QuadPart) * 1000000000 / freq.QuadPart; + else + sp->tv_nsec = (long)((count.QuadPart % freq.QuadPart) * (1000000000.0 / freq.QuadPart)); + return 0; + } + default: + errno = EINVAL; + return -1; + } +} + +/* License: Ruby's */ +int +clock_getres(clockid_t clock_id, struct timespec *sp) +{ + switch (clock_id) { + case CLOCK_REALTIME: + { + sp->tv_sec = 0; + sp->tv_nsec = 1000; + return 0; + } + case CLOCK_MONOTONIC: + { + LARGE_INTEGER freq; + if (!QueryPerformanceFrequency(&freq)) { + errno = map_errno(GetLastError()); + return -1; + } + sp->tv_sec = 0; + sp->tv_nsec = (long)(1000000000.0 / freq.QuadPart); + return 0; + } + default: + errno = EINVAL; + return -1; + } +} + +/* License: Ruby's */ +char * +rb_w32_getcwd(char *buffer, int size) +{ + char *p = buffer; + 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; + } + + translate_char(p, '\\', '/', filecp()); + + return p; +} + +/* License: Artistic or GPL */ +int +chown(const char *path, int owner, int group) +{ + return 0; +} + +/* License: Artistic or GPL */ +int +rb_w32_uchown(const char *path, int owner, int group) +{ + return 0; +} + +/* License: Ruby's */ +int +kill(int pid, int sig) +{ + int ret = 0; + DWORD err; + + if (pid < 0 || (pid == 0 && sig != SIGINT)) { + errno = EINVAL; + return -1; + } + + if ((unsigned int)pid == GetCurrentProcessId() && + (sig != 0 && sig != SIGKILL)) { + if ((ret = raise(sig)) != 0) { + /* MSVCRT doesn't set errno... */ + errno = EINVAL; + } + return ret; + } + + switch (sig) { + case 0: + RUBY_CRITICAL({ + HANDLE hProc = + OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, (DWORD)pid); + if (hProc == NULL || hProc == INVALID_HANDLE_VALUE) { + if (GetLastError() == ERROR_INVALID_PARAMETER) { + errno = ESRCH; + } + else { + errno = EPERM; + } + ret = -1; + } + else { + CloseHandle(hProc); + } + }); + break; + + case SIGINT: + RUBY_CRITICAL({ + DWORD ctrlEvent = CTRL_C_EVENT; + if (pid != 0) { + /* CTRL+C signal cannot be generated for process groups. + * Instead, we use CTRL+BREAK signal. */ + ctrlEvent = CTRL_BREAK_EVENT; + } + if (!GenerateConsoleCtrlEvent(ctrlEvent, (DWORD)pid)) { + if ((err = GetLastError()) == 0) + errno = EPERM; + else + errno = map_errno(GetLastError()); + ret = -1; + } + }); + break; + + case SIGKILL: + RUBY_CRITICAL({ + HANDLE hProc; + struct ChildRecord* child = FindChildSlot(pid); + if (child) { + hProc = child->hProcess; + } + else { + hProc = OpenProcess(PROCESS_TERMINATE | PROCESS_QUERY_INFORMATION, FALSE, (DWORD)pid); + } + if (hProc == NULL || hProc == INVALID_HANDLE_VALUE) { + if (GetLastError() == ERROR_INVALID_PARAMETER) { + errno = ESRCH; + } + else { + errno = EPERM; + } + ret = -1; + } + else { + DWORD status; + if (!GetExitCodeProcess(hProc, &status)) { + errno = map_errno(GetLastError()); + ret = -1; + } + else if (status == STILL_ACTIVE) { + if (!TerminateProcess(hProc, 0)) { + errno = EPERM; + ret = -1; + } + } + else { + errno = ESRCH; + ret = -1; + } + if (!child) { + CloseHandle(hProc); + } + } + }); + break; + + default: + errno = EINVAL; + ret = -1; + break; + } + + return ret; +} + +/* License: Ruby's */ +static int +wlink(const WCHAR *from, const WCHAR *to) +{ + typedef BOOL (WINAPI link_func)(LPCWSTR, LPCWSTR, LPSECURITY_ATTRIBUTES); + static link_func *pCreateHardLinkW = NULL; + static int myerrno = 0; + + if (!pCreateHardLinkW && !myerrno) { + pCreateHardLinkW = (link_func *)get_proc_address("kernel32", "CreateHardLinkW", NULL); + if (!pCreateHardLinkW) + myerrno = ENOSYS; + } + if (!pCreateHardLinkW) { + errno = myerrno; + return -1; + } + + if (!pCreateHardLinkW(to, from, NULL)) { + errno = map_errno(GetLastError()); + return -1; + } + + return 0; +} + +/* License: Ruby's */ +int +rb_w32_ulink(const char *from, const char *to) +{ + WCHAR *wfrom; + WCHAR *wto; + int ret; + + if (!(wfrom = utf8_to_wstr(from, NULL))) + return -1; + if (!(wto = utf8_to_wstr(to, NULL))) { + free(wfrom); + return -1; + } + ret = wlink(wfrom, wto); + free(wto); + free(wfrom); + return ret; +} + +/* License: Ruby's */ +int +link(const char *from, const char *to) +{ + WCHAR *wfrom; + WCHAR *wto; + int ret; + + if (!(wfrom = filecp_to_wstr(from, NULL))) + return -1; + if (!(wto = filecp_to_wstr(to, NULL))) { + free(wfrom); + return -1; + } + ret = wlink(wfrom, wto); + free(wto); + free(wfrom); + return ret; +} + +/* License: Ruby's */ +int +wait(int *status) +{ + return waitpid(-1, status, 0); +} + +/* License: Ruby's */ +static char * +w32_getenv(const char *name, UINT cp) +{ + WCHAR *wenvarea, *wenv; + int len = strlen(name); + char *env; + int wlen; + + if (len == 0) return NULL; + + if (uenvarea) { + free(uenvarea); + uenvarea = NULL; + } + wenvarea = GetEnvironmentStringsW(); + if (!wenvarea) { + map_errno(GetLastError()); + return NULL; + } + for (wenv = wenvarea, wlen = 1; *wenv; wenv += lstrlenW(wenv) + 1) + wlen += lstrlenW(wenv) + 1; + uenvarea = wstr_to_mbstr(cp, wenvarea, wlen, NULL); + FreeEnvironmentStringsW(wenvarea); + if (!uenvarea) + return NULL; + + for (env = uenvarea; *env; env += strlen(env) + 1) + if (strncasecmp(env, name, len) == 0 && *(env + len) == '=') + return env + len + 1; + + return NULL; +} + +/* License: Ruby's */ +char * +rb_w32_ugetenv(const char *name) +{ + return w32_getenv(name, CP_UTF8); +} + +/* License: Ruby's */ +char * +rb_w32_getenv(const char *name) +{ + return w32_getenv(name, CP_ACP); +} + +/* License: Ruby's */ +static DWORD +get_volume_serial_number(const WCHAR *path) +{ + const DWORD share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE; + const DWORD creation = OPEN_EXISTING; + const DWORD flags = FILE_FLAG_BACKUP_SEMANTICS; + BY_HANDLE_FILE_INFORMATION st = {0}; + HANDLE h = CreateFileW(path, 0, share_mode, NULL, creation, flags, NULL); + BOOL ret; + + if (h == INVALID_HANDLE_VALUE) return 0; + ret = GetFileInformationByHandle(h, &st); + CloseHandle(h); + if (!ret) return 0; + return st.dwVolumeSerialNumber; +} + +/* License: Ruby's */ +static int +different_device_p(const WCHAR *oldpath, const WCHAR *newpath) +{ + return get_volume_serial_number(oldpath) != get_volume_serial_number(newpath); +} + +/* License: Artistic or GPL */ +static int +wrename(const WCHAR *oldpath, const WCHAR *newpath) +{ + int res = 0; + int oldatts; + int newatts; + + oldatts = GetFileAttributesW(oldpath); + newatts = GetFileAttributesW(newpath); + + if (oldatts == -1) { + errno = map_errno(GetLastError()); + return -1; + } + + RUBY_CRITICAL({ + if (newatts != -1 && newatts & FILE_ATTRIBUTE_READONLY) + SetFileAttributesW(newpath, newatts & ~ FILE_ATTRIBUTE_READONLY); + + if (!MoveFileExW(oldpath, newpath, MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED)) + res = -1; + + if (res) { + DWORD e = GetLastError(); + if ((e == ERROR_ACCESS_DENIED) && (oldatts & FILE_ATTRIBUTE_DIRECTORY) && + different_device_p(oldpath, newpath)) + errno = EXDEV; + else + errno = map_errno(e); + } + else + SetFileAttributesW(newpath, oldatts); + }); + + return res; +} + +/* License: Ruby's */ +int rb_w32_urename(const char *from, const char *to) +{ + WCHAR *wfrom; + WCHAR *wto; + int ret = -1; + + if (!(wfrom = utf8_to_wstr(from, NULL))) + return -1; + if (!(wto = utf8_to_wstr(to, NULL))) { + free(wfrom); + return -1; + } + ret = wrename(wfrom, wto); + free(wto); + free(wfrom); + return ret; +} + +/* License: Ruby's */ +int rb_w32_rename(const char *from, const char *to) +{ + WCHAR *wfrom; + WCHAR *wto; + int ret = -1; + + if (!(wfrom = filecp_to_wstr(from, NULL))) + return -1; + if (!(wto = filecp_to_wstr(to, NULL))) { + free(wfrom); + return -1; + } + ret = wrename(wfrom, wto); + free(wto); + free(wfrom); + return ret; +} + +/* License: Ruby's */ +static int +isUNCRoot(const WCHAR *path) +{ + if (path[0] == L'\\' && path[1] == L'\\') { + const WCHAR *p = path + 2; + if (p[0] == L'?' && p[1] == L'\\') { + p += 2; + } + for (; *p; p++) { + if (*p == L'\\') + break; + } + if (p[0] && p[1]) { + for (p++; *p; p++) { + if (*p == L'\\') + break; + } + if (!p[0] || !p[1] || (p[1] == L'.' && !p[2])) + return 1; + } + } + return 0; +} + +#define COPY_STAT(src, dest, size_cast) do { \ + (dest).st_dev = (src).st_dev; \ + (dest).st_ino = (src).st_ino; \ + (dest).st_mode = (src).st_mode; \ + (dest).st_nlink = (src).st_nlink; \ + (dest).st_uid = (src).st_uid; \ + (dest).st_gid = (src).st_gid; \ + (dest).st_rdev = (src).st_rdev; \ + (dest).st_size = size_cast(src).st_size; \ + (dest).st_atime = (src).st_atime; \ + (dest).st_mtime = (src).st_mtime; \ + (dest).st_ctime = (src).st_ctime; \ + } while (0) + +static time_t filetime_to_unixtime(const FILETIME *ft); + +#undef fstat +/* License: Ruby's */ +int +rb_w32_fstat(int fd, struct stat *st) +{ + BY_HANDLE_FILE_INFORMATION info; + int ret = fstat(fd, st); + + if (ret) return ret; +#ifdef __BORLANDC__ + st->st_mode &= ~(S_IWGRP | S_IWOTH); +#else + if (GetEnvironmentVariableW(L"TZ", NULL, 0) == 0 && GetLastError() == ERROR_ENVVAR_NOT_FOUND) return ret; +#endif + if (GetFileInformationByHandle((HANDLE)_get_osfhandle(fd), &info)) { +#ifdef __BORLANDC__ + if (!(info.dwFileAttributes & FILE_ATTRIBUTE_READONLY)) { + st->st_mode |= S_IWUSR; + } +#endif + st->st_atime = filetime_to_unixtime(&info.ftLastAccessTime); + st->st_mtime = filetime_to_unixtime(&info.ftLastWriteTime); + st->st_ctime = filetime_to_unixtime(&info.ftCreationTime); + } + return ret; +} + +/* License: Ruby's */ +int +rb_w32_fstati64(int fd, struct stati64 *st) +{ + BY_HANDLE_FILE_INFORMATION info; + struct stat tmp; + int ret; + +#ifndef __BORLANDC__ + if (GetEnvironmentVariableW(L"TZ", NULL, 0) == 0 && GetLastError() == ERROR_ENVVAR_NOT_FOUND) return _fstati64(fd, st); +#endif + ret = fstat(fd, &tmp); + + if (ret) return ret; +#ifdef __BORLANDC__ + tmp.st_mode &= ~(S_IWGRP | S_IWOTH); +#endif + COPY_STAT(tmp, *st, +); + if (GetFileInformationByHandle((HANDLE)_get_osfhandle(fd), &info)) { +#ifdef __BORLANDC__ + if (!(info.dwFileAttributes & FILE_ATTRIBUTE_READONLY)) { + st->st_mode |= S_IWUSR; + } +#endif + st->st_size = ((__int64)info.nFileSizeHigh << 32) | info.nFileSizeLow; + st->st_atime = filetime_to_unixtime(&info.ftLastAccessTime); + st->st_mtime = filetime_to_unixtime(&info.ftLastWriteTime); + st->st_ctime = filetime_to_unixtime(&info.ftCreationTime); + } + return ret; +} + +/* License: Ruby's */ +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; +} + +/* License: Ruby's */ +static unsigned +fileattr_to_unixmode(DWORD attr, const WCHAR *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 WCHAR *end = path + lstrlenW(path); + while (path < end) { + end = CharPrevW(path, end); + if (*end == L'.') { + if ((_wcsicmp(end, L".bat") == 0) || + (_wcsicmp(end, L".cmd") == 0) || + (_wcsicmp(end, L".com") == 0) || + (_wcsicmp(end, L".exe") == 0)) { + mode |= S_IEXEC; + } + break; + } + } + } + + mode |= (mode & 0700) >> 3; + mode |= (mode & 0700) >> 6; + + return mode; +} + +/* License: Ruby's */ +static int +check_valid_dir(const WCHAR *path) +{ + WIN32_FIND_DATAW fd; + HANDLE fh; + WCHAR full[MAX_PATH]; + WCHAR *dmy; + WCHAR *p, *q; + + /* GetFileAttributes() determines "..." as directory. */ + /* We recheck it by FindFirstFile(). */ + if (!(p = wcsstr(path, L"..."))) + return 0; + q = p + wcsspn(p, L"."); + if ((p == path || wcschr(L":/\\", *(p - 1))) && + (!*q || wcschr(L":/\\", *q))) { + errno = ENOENT; + return -1; + } + + /* if the specified path is the root of a drive and the drive is empty, */ + /* FindFirstFile() returns INVALID_HANDLE_VALUE. */ + if (!GetFullPathNameW(path, sizeof(full) / sizeof(WCHAR), full, &dmy)) { + errno = map_errno(GetLastError()); + return -1; + } + if (full[1] == L':' && !full[3] && GetDriveTypeW(full) != DRIVE_NO_ROOT_DIR) + return 0; + + fh = open_dir_handle(path, &fd); + if (fh == INVALID_HANDLE_VALUE) + return -1; + FindClose(fh); + return 0; +} + +/* License: Ruby's */ +static int +winnt_stat(const WCHAR *path, struct stati64 *st) +{ + HANDLE h; + WIN32_FIND_DATAW wfd; + WIN32_FILE_ATTRIBUTE_DATA wfa; + const WCHAR *p = path; + + memset(st, 0, sizeof(*st)); + st->st_nlink = 1; + + if (wcsncmp(p, L"\\\\?\\", 4) == 0) p += 4; + if (wcspbrk(p, L"?*")) { + errno = ENOENT; + return -1; + } + if (GetFileAttributesExW(path, GetFileExInfoStandard, (void*)&wfa)) { + if (wfa.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { + if (check_valid_dir(path)) return -1; + st->st_size = 0; + } + else { + st->st_size = ((__int64)wfa.nFileSizeHigh << 32) | wfa.nFileSizeLow; + } + st->st_mode = fileattr_to_unixmode(wfa.dwFileAttributes, path); + st->st_atime = filetime_to_unixtime(&wfa.ftLastAccessTime); + st->st_mtime = filetime_to_unixtime(&wfa.ftLastWriteTime); + st->st_ctime = filetime_to_unixtime(&wfa.ftCreationTime); + } + else { + /* GetFileAttributesEx failed; check why. */ + int e = GetLastError(); + + if ((e == ERROR_FILE_NOT_FOUND) || (e == ERROR_INVALID_NAME) + || (e == ERROR_PATH_NOT_FOUND || (e == ERROR_BAD_NETPATH))) { + errno = map_errno(e); + return -1; + } + + /* Fall back to FindFirstFile for ERROR_SHARING_VIOLATION */ + h = FindFirstFileW(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 { + errno = map_errno(GetLastError()); + return -1; + } + } + + st->st_dev = st->st_rdev = (iswalpha(path[0]) && path[1] == L':') ? + towupper(path[0]) - L'A' : _getdrive() - 1; + + return 0; +} + +/* License: Ruby's */ +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, (_off_t)); + return 0; +} + +/* License: Ruby's */ +static int +wstati64(const WCHAR *path, struct stati64 *st) +{ + const WCHAR *p; + WCHAR *buf1, *s, *end; + int len, size; + int ret; + VALUE v; + + if (!path || !st) { + errno = EFAULT; + return -1; + } + size = lstrlenW(path) + 2; + buf1 = ALLOCV_N(WCHAR, v, size); + for (p = path, s = buf1; *p; p++, s++) { + if (*p == L'/') + *s = L'\\'; + else + *s = *p; + } + *s = '\0'; + len = s - buf1; + if (!len || L'\"' == *(--s)) { + errno = ENOENT; + return -1; + } + end = buf1 + len - 1; + + if (isUNCRoot(buf1)) { + if (*end == L'.') + *end = L'\0'; + else if (*end != L'\\') + lstrcatW(buf1, L"\\"); + } + else if (*end == L'\\' || (buf1 + 1 == end && *end == L':')) + lstrcatW(buf1, L"."); + + ret = winnt_stat(buf1, st); + if (ret == 0) { + st->st_mode &= ~(S_IWGRP | S_IWOTH); + } + if (v) + ALLOCV_END(v); + + return ret; +} + +/* License: Ruby's */ +int +rb_w32_ustati64(const char *path, struct stati64 *st) +{ + return w32_stati64(path, st, CP_UTF8); +} + +/* License: Ruby's */ +int +rb_w32_stati64(const char *path, struct stati64 *st) +{ + return w32_stati64(path, st, filecp()); +} + +/* License: Ruby's */ +static int +w32_stati64(const char *path, struct stati64 *st, UINT cp) +{ + WCHAR *wpath; + int ret; + + if (!(wpath = mbstr_to_wstr(cp, path, -1, NULL))) + return -1; + ret = wstati64(wpath, st); + free(wpath); + return ret; +} + +/* License: Ruby's */ +int +rb_w32_access(const char *path, int mode) +{ + struct stati64 stat; + if (rb_w32_stati64(path, &stat) != 0) + return -1; + mode <<= 6; + if ((stat.st_mode & mode) != mode) { + errno = EACCES; + return -1; + } + return 0; +} + +/* License: Ruby's */ +int +rb_w32_uaccess(const char *path, int mode) +{ + struct stati64 stat; + if (rb_w32_ustati64(path, &stat) != 0) + return -1; + mode <<= 6; + if ((stat.st_mode & mode) != mode) { + errno = EACCES; + return -1; + } + return 0; +} + +/* License: Ruby's */ +static int +rb_chsize(HANDLE h, off_t size) +{ + long upos, lpos, usize, lsize; + int ret = -1; + DWORD e; + + if ((lpos = SetFilePointer(h, 0, (upos = 0, &upos), SEEK_CUR)) == -1L && + (e = GetLastError())) { + errno = map_errno(e); + return -1; + } + usize = (long)(size >> 32); + lsize = (long)size; + if (SetFilePointer(h, lsize, &usize, SEEK_SET) == (DWORD)-1L && + (e = GetLastError())) { + errno = map_errno(e); + } + else if (!SetEndOfFile(h)) { + errno = map_errno(GetLastError()); + } + else { + ret = 0; + } + SetFilePointer(h, lpos, &upos, SEEK_SET); + return ret; +} + +/* License: Ruby's */ +int +rb_w32_truncate(const char *path, off_t length) +{ + HANDLE h; + int 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; +} + +/* License: Ruby's */ +int +rb_w32_ftruncate(int fd, off_t length) +{ + HANDLE h; + + h = (HANDLE)_get_osfhandle(fd); + if (h == (HANDLE)-1) return -1; + return rb_chsize(h, length); +} + +#ifdef __BORLANDC__ +/* License: Ruby's */ +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; +} + +/* License: Ruby's */ +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 + +/* License: Ruby's */ +static long +filetime_to_clock(FILETIME *ft) +{ + __int64 qw = ft->dwHighDateTime; + qw <<= 32; + qw |= ft->dwLowDateTime; + qw /= 10000; /* File time ticks at 0.1uS, clock at 1mS */ + return (long) qw; +} + +/* License: Ruby's */ +int +rb_w32_times(struct tms *tmbuf) +{ + FILETIME create, exit, kernel, user; + + if (GetProcessTimes(GetCurrentProcess(),&create, &exit, &kernel, &user)) { + tmbuf->tms_utime = filetime_to_clock(&user); + tmbuf->tms_stime = filetime_to_clock(&kernel); + tmbuf->tms_cutime = 0; + tmbuf->tms_cstime = 0; + } + else { + tmbuf->tms_utime = clock(); + tmbuf->tms_stime = 0; + tmbuf->tms_cutime = 0; + tmbuf->tms_cstime = 0; + } + return 0; +} + +#define yield_once() Sleep(0) +#define yield_until(condition) do yield_once(); while (!(condition)) + +/* License: Ruby's */ +static void +catch_interrupt(void) +{ + yield_once(); + RUBY_CRITICAL(rb_w32_wait_events(NULL, 0, 0)); +} + +#if defined __BORLANDC__ +#undef read +/* License: Ruby's */ +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 + + +#define FILE_COUNT _cnt +#define FILE_READPTR _ptr + +#undef fgetc +/* License: Ruby's */ +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 +/* License: Ruby's */ +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; +} + +/* License: Ruby's */ +struct asynchronous_arg_t { + /* output field */ + void* stackaddr; + int errnum; + + /* input field */ + uintptr_t (*func)(uintptr_t self, int argc, uintptr_t* argv); + uintptr_t self; + int argc; + uintptr_t* argv; +}; + +/* License: Ruby's */ +static DWORD WINAPI +call_asynchronous(PVOID argp) +{ + DWORD ret; + struct asynchronous_arg_t *arg = argp; + arg->stackaddr = &argp; + ret = (DWORD)arg->func(arg->self, arg->argc, arg->argv); + arg->errnum = errno; + return ret; +} + +/* License: Ruby's */ +uintptr_t +rb_w32_asynchronize(asynchronous_func_t func, uintptr_t self, + int argc, uintptr_t* argv, uintptr_t intrval) +{ + DWORD val; + BOOL interrupted = FALSE; + HANDLE thr; + + RUBY_CRITICAL({ + struct asynchronous_arg_t arg; + + arg.stackaddr = NULL; + arg.errnum = 0; + arg.func = func; + arg.self = self; + arg.argc = argc; + arg.argv = argv; + + thr = CreateThread(NULL, 0, call_asynchronous, &arg, 0, &val); + + if (thr) { + yield_until(arg.stackaddr); + + if (rb_w32_wait_events_blocking(&thr, 1, INFINITE) != WAIT_OBJECT_0) { + interrupted = TRUE; + + if (TerminateThread(thr, intrval)) { + yield_once(); + } + } + + GetExitCodeThread(thr, &val); + CloseHandle(thr); + + if (interrupted) { + /* must release stack of killed thread, why doesn't Windows? */ + MEMORY_BASIC_INFORMATION m; + + memset(&m, 0, sizeof(m)); + if (!VirtualQuery(arg.stackaddr, &m, sizeof(m))) { + Debug(fprintf(stderr, "couldn't get stack base:%p:%d\n", + arg.stackaddr, GetLastError())); + } + else if (!VirtualFree(m.AllocationBase, 0, MEM_RELEASE)) { + Debug(fprintf(stderr, "couldn't release stack:%p:%d\n", + m.AllocationBase, GetLastError())); + } + errno = EINTR; + } + else { + errno = arg.errnum; + } + } + }); + + if (!thr) { + rb_fatal("failed to launch waiter thread:%ld", GetLastError()); + } + + return val; +} + +/* License: Ruby's */ +char ** +rb_w32_get_environ(void) +{ + WCHAR *envtop, *env; + char **myenvtop, **myenv; + int num; + + /* + * We avoid values started with `='. If you want to deal those values, + * change this function, and some functions in hash.c which recognize + * `=' as delimiter or rb_w32_getenv() and ruby_setenv(). + * CygWin deals these values by changing first `=' to '!'. But we don't + * use such trick and follow cmd.exe's way that just doesn't show these + * values. + * + * This function returns UTF-8 strings. + */ + envtop = GetEnvironmentStringsW(); + for (env = envtop, num = 0; *env; env += lstrlenW(env) + 1) + if (*env != '=') num++; + + myenvtop = (char **)malloc(sizeof(char *) * (num + 1)); + for (env = envtop, myenv = myenvtop; *env; env += lstrlenW(env) + 1) { + if (*env != '=') { + if (!(*myenv = wstr_to_utf8(env, NULL))) { + break; + } + myenv++; + } + } + *myenv = NULL; + FreeEnvironmentStringsW(envtop); + + return myenvtop; +} + +/* License: Ruby's */ +void +rb_w32_free_environ(char **env) +{ + char **t = env; + + while (*t) free(*t++); + free(env); +} + +/* License: Ruby's */ +rb_pid_t +rb_w32_getpid(void) +{ + return GetCurrentProcessId(); +} + + +/* License: Ruby's */ +rb_pid_t +rb_w32_getppid(void) +{ + typedef long (WINAPI query_func)(HANDLE, int, void *, ULONG, ULONG *); + static query_func *pNtQueryInformationProcess = NULL; + rb_pid_t ppid = 0; + + if (rb_w32_osver() >= 5) { + if (!pNtQueryInformationProcess) + pNtQueryInformationProcess = (query_func *)get_proc_address("ntdll.dll", "NtQueryInformationProcess", NULL); + if (pNtQueryInformationProcess) { + struct { + long ExitStatus; + void* PebBaseAddress; + uintptr_t AffinityMask; + uintptr_t BasePriority; + uintptr_t UniqueProcessId; + uintptr_t ParentProcessId; + } pbi; + ULONG len; + long ret = pNtQueryInformationProcess(GetCurrentProcess(), 0, &pbi, sizeof(pbi), &len); + if (!ret) { + ppid = pbi.ParentProcessId; + } + } + } + + return ppid; +} + +STATIC_ASSERT(std_handle, (STD_OUTPUT_HANDLE-STD_INPUT_HANDLE)==(STD_ERROR_HANDLE-STD_OUTPUT_HANDLE)); + +/* License: Ruby's */ +#define set_new_std_handle(newfd, handle) do { \ + if ((unsigned)(newfd) > 2) break; \ + SetStdHandle(STD_INPUT_HANDLE+(STD_OUTPUT_HANDLE-STD_INPUT_HANDLE)*(newfd), \ + (handle)); \ + } while (0) +#define set_new_std_fd(newfd) set_new_std_handle(newfd, (HANDLE)rb_w32_get_osfhandle(newfd)) + +/* License: Ruby's */ +int +rb_w32_dup2(int oldfd, int newfd) +{ + int ret; + + if (oldfd == newfd) return newfd; + ret = dup2(oldfd, newfd); + set_new_std_fd(newfd); + return ret; +} + +/* License: Ruby's */ +int +rb_w32_uopen(const char *file, int oflag, ...) +{ + WCHAR *wfile; + int ret; + int pmode; + + va_list arg; + va_start(arg, oflag); + pmode = va_arg(arg, int); + va_end(arg); + + if (!(wfile = utf8_to_wstr(file, NULL))) + return -1; + ret = rb_w32_wopen(wfile, oflag, pmode); + free(wfile); + return ret; +} + +/* License: Ruby's */ +static int +check_if_wdir(const WCHAR *wfile) +{ + DWORD attr = GetFileAttributesW(wfile); + if (attr == (DWORD)-1L || + !(attr & FILE_ATTRIBUTE_DIRECTORY) || + check_valid_dir(wfile)) { + return FALSE; + } + errno = EISDIR; + return TRUE; +} + +/* License: Ruby's */ +static int +check_if_dir(const char *file) +{ + WCHAR *wfile; + int ret; + + if (!(wfile = filecp_to_wstr(file, NULL))) + return FALSE; + ret = check_if_wdir(wfile); + free(wfile); + return ret; +} + +/* License: Ruby's */ +int +rb_w32_open(const char *file, int oflag, ...) +{ + WCHAR *wfile; + int ret; + int pmode; + + va_list arg; + va_start(arg, oflag); + pmode = va_arg(arg, int); + va_end(arg); + + if ((oflag & O_TEXT) || !(oflag & O_BINARY)) { + ret = _open(file, oflag, pmode); + if (ret == -1 && errno == EACCES) check_if_dir(file); + return ret; + } + + if (!(wfile = filecp_to_wstr(file, NULL))) + return -1; + ret = rb_w32_wopen(wfile, oflag, pmode); + free(wfile); + return ret; +} + +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); + fd = _wopen(file, oflag, pmode); + if (fd == -1 && errno == EACCES) check_if_wdir(file); + return fd; + } + + sec.nLength = sizeof(sec); + sec.lpSecurityDescriptor = NULL; + if (oflag & O_NOINHERIT) { + sec.bInheritHandle = FALSE; + flags |= FNOINHERIT; + } + else { + sec.bInheritHandle = TRUE; + } + oflag &= ~O_NOINHERIT; + + /* always open with binary mode */ + oflag &= ~(O_BINARY | O_TEXT); + + switch (oflag & (O_RDWR | O_RDONLY | O_WRONLY)) { + case O_RDWR: + access = GENERIC_READ | GENERIC_WRITE; + break; + case O_RDONLY: + access = GENERIC_READ; + break; + case O_WRONLY: + access = GENERIC_WRITE; + break; + default: + errno = EINVAL; + return -1; + } + oflag &= ~(O_RDWR | O_RDONLY | O_WRONLY); + + switch (oflag & (O_CREAT | O_EXCL | O_TRUNC)) { + case O_CREAT: + create = OPEN_ALWAYS; + break; + case 0: + case O_EXCL: + create = OPEN_EXISTING; + break; + case O_CREAT | O_EXCL: + case O_CREAT | O_EXCL | O_TRUNC: + create = CREATE_NEW; + break; + case O_TRUNC: + case O_TRUNC | O_EXCL: + create = TRUNCATE_EXISTING; + break; + case O_CREAT | O_TRUNC: + create = CREATE_ALWAYS; + break; + default: + errno = EINVAL; + return -1; + } + if (oflag & O_CREAT) { + 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((intptr_t)h, 0); + CloseHandle(h); + }); + if (fd == -1) { + errno = EMFILE; + return -1; + } + RUBY_CRITICAL({ + MTHREAD_ONLY(EnterCriticalSection(&(_pioinfo(fd)->lock))); + _set_osfhnd(fd, (intptr_t)INVALID_HANDLE_VALUE); + _set_osflags(fd, 0); + + h = CreateFileW(file, access, FILE_SHARE_READ | FILE_SHARE_WRITE, &sec, + create, attr, NULL); + if (h == INVALID_HANDLE_VALUE) { + DWORD e = GetLastError(); + if (e != ERROR_ACCESS_DENIED || !check_if_wdir(file)) + errno = map_errno(e); + 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, (intptr_t)h); + _osfile(fd) = flags | FOPEN; + + MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock)); + quit: + ; + }); + + return fd; +} + +/* License: Ruby's */ +int +rb_w32_fclose(FILE *fp) +{ + int fd = fileno(fp); + SOCKET sock = TO_SOCKET(fd); + int save_errno = errno; + + if (fflush(fp)) return -1; + if (!is_socket(sock)) { + UnlockFile((HANDLE)sock, 0, 0, LK_LEN, LK_LEN); + return fclose(fp); + } + _set_osfhnd(fd, (SOCKET)INVALID_HANDLE_VALUE); + fclose(fp); + errno = save_errno; + if (closesocket(sock) == SOCKET_ERROR) { + errno = map_errno(WSAGetLastError()); + return -1; + } + return 0; +} + +/* License: Ruby's */ +int +rb_w32_pipe(int fds[2]) +{ + static DWORD serial = 0; + static const char prefix[] = "\\\\.\\pipe\\ruby"; + enum { + width_of_prefix = (int)sizeof(prefix) - 1, + width_of_pid = (int)sizeof(rb_pid_t) * 2, + width_of_serial = (int)sizeof(serial) * 2, + width_of_ids = width_of_pid + 1 + width_of_serial + 1 + }; + char name[sizeof(prefix) + width_of_ids]; + SECURITY_ATTRIBUTES sec; + HANDLE hRead, hWrite, h; + int fdRead, fdWrite; + int ret; + + /* if doesn't have CancelIo, use default pipe function */ + if (!cancel_io) + return _pipe(fds, 65536L, _O_NOINHERIT); + + memcpy(name, prefix, width_of_prefix); + snprintf(name + width_of_prefix, width_of_ids, "%.*"PRI_PIDT_PREFIX"x-%.*lx", + width_of_pid, rb_w32_getpid(), width_of_serial, 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((intptr_t)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, (intptr_t)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((intptr_t)h, 0); + CloseHandle(h); + if (fdWrite == -1) { + errno = EMFILE; + CloseHandle(hWrite); + ret = -1; + break; + } + MTHREAD_ONLY(EnterCriticalSection(&(_pioinfo(fdWrite)->lock))); + _set_osfhnd(fdWrite, (intptr_t)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; +} + +/* License: Ruby's */ +static int +console_emulator_p(void) +{ +#ifdef _WIN32_WCE + return FALSE; +#else + const void *const func = WriteConsoleW; + HMODULE k; + MEMORY_BASIC_INFORMATION m; + + memset(&m, 0, sizeof(m)); + if (!VirtualQuery(func, &m, sizeof(m))) { + return FALSE; + } + k = GetModuleHandle("kernel32.dll"); + if (!k) return FALSE; + return (HMODULE)m.AllocationBase != k; +#endif +} + +/* License: Ruby's */ +static struct constat * +constat_handle(HANDLE h) +{ + st_data_t data; + struct constat *p; + if (!conlist) { + if (console_emulator_p()) { + conlist = conlist_disabled; + return NULL; + } + conlist = st_init_numtable(); + } + else if (conlist == conlist_disabled) { + return NULL; + } + if (st_lookup(conlist, (st_data_t)h, &data)) { + p = (struct constat *)data; + } + else { + CONSOLE_SCREEN_BUFFER_INFO csbi; + p = ALLOC(struct constat); + p->vt100.state = constat_init; + p->vt100.attr = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED; + p->vt100.reverse = 0; + p->vt100.saved.X = p->vt100.saved.Y = 0; + if (GetConsoleScreenBufferInfo(h, &csbi)) { + p->vt100.attr = csbi.wAttributes; + } + st_insert(conlist, (st_data_t)h, (st_data_t)p); + } + return p; +} + +/* License: Ruby's */ +static void +constat_reset(HANDLE h) +{ + st_data_t data; + struct constat *p; + if (!conlist || conlist == conlist_disabled) return; + if (!st_lookup(conlist, (st_data_t)h, &data)) return; + p = (struct constat *)data; + p->vt100.state = constat_init; +} + +#define FOREGROUND_MASK (FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY) +#define BACKGROUND_MASK (BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_INTENSITY) + +#define constat_attr_color_reverse(attr) \ + ((attr) & ~(FOREGROUND_MASK | BACKGROUND_MASK)) | \ + (((attr) & FOREGROUND_MASK) << 4) | \ + (((attr) & BACKGROUND_MASK) >> 4) + +/* License: Ruby's */ +static WORD +constat_attr(int count, const int *seq, WORD attr, WORD default_attr, int *reverse) +{ + int rev = *reverse; + WORD bold; + + if (!count) return attr; + if (rev) attr = constat_attr_color_reverse(attr); + bold = attr & FOREGROUND_INTENSITY; + attr &= ~(FOREGROUND_INTENSITY | BACKGROUND_INTENSITY); + + while (count-- > 0) { + switch (*seq++) { + case 0: + attr = default_attr; + rev = 0; + bold = 0; + break; + case 1: + bold = FOREGROUND_INTENSITY; + break; + case 4: +#ifndef COMMON_LVB_UNDERSCORE +#define COMMON_LVB_UNDERSCORE 0x8000 +#endif + attr |= COMMON_LVB_UNDERSCORE; + break; + case 7: + rev = 1; + break; + + case 30: + attr &= ~(FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED); + break; + case 17: + case 31: + attr = (attr & ~(FOREGROUND_BLUE | FOREGROUND_GREEN)) | FOREGROUND_RED; + break; + case 18: + case 32: + attr = (attr & ~(FOREGROUND_BLUE | FOREGROUND_RED)) | FOREGROUND_GREEN; + break; + case 19: + case 33: + attr = (attr & ~FOREGROUND_BLUE) | FOREGROUND_GREEN | FOREGROUND_RED; + break; + case 20: + case 34: + attr = (attr & ~(FOREGROUND_GREEN | FOREGROUND_RED)) | FOREGROUND_BLUE; + break; + case 21: + case 35: + attr = (attr & ~FOREGROUND_GREEN) | FOREGROUND_BLUE | FOREGROUND_RED; + break; + case 22: + case 36: + attr = (attr & ~FOREGROUND_RED) | FOREGROUND_BLUE | FOREGROUND_GREEN; + break; + case 23: + case 37: + attr |= FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED; + break; + + case 40: + attr &= ~(BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_RED); + break; + case 41: + attr = (attr & ~(BACKGROUND_BLUE | BACKGROUND_GREEN)) | BACKGROUND_RED; + break; + case 42: + attr = (attr & ~(BACKGROUND_BLUE | BACKGROUND_RED)) | BACKGROUND_GREEN; + break; + case 43: + attr = (attr & ~BACKGROUND_BLUE) | BACKGROUND_GREEN | BACKGROUND_RED; + break; + case 44: + attr = (attr & ~(BACKGROUND_GREEN | BACKGROUND_RED)) | BACKGROUND_BLUE; + break; + case 45: + attr = (attr & ~BACKGROUND_GREEN) | BACKGROUND_BLUE | BACKGROUND_RED; + break; + case 46: + attr = (attr & ~BACKGROUND_RED) | BACKGROUND_BLUE | BACKGROUND_GREEN; + break; + case 47: + attr |= BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_RED; + break; + } + } + attr |= bold; + if (rev) attr = constat_attr_color_reverse(attr); + *reverse = rev; + return attr; +} + +/* License: Ruby's */ +static void +constat_apply(HANDLE handle, struct constat *s, WCHAR w) +{ + CONSOLE_SCREEN_BUFFER_INFO csbi; + const int *seq = s->vt100.seq; + int count = s->vt100.state; + int arg1 = 1; + COORD pos; + DWORD written; + + if (!GetConsoleScreenBufferInfo(handle, &csbi)) return; + if (count > 0 && seq[0] > 0) arg1 = seq[0]; + switch (w) { + case L'm': + SetConsoleTextAttribute(handle, constat_attr(count, seq, csbi.wAttributes, s->vt100.attr, &s->vt100.reverse)); + break; + case L'F': + csbi.dwCursorPosition.X = 0; + case L'A': + csbi.dwCursorPosition.Y -= arg1; + if (csbi.dwCursorPosition.Y < 0) + csbi.dwCursorPosition.Y = 0; + SetConsoleCursorPosition(handle, csbi.dwCursorPosition); + break; + case L'E': + csbi.dwCursorPosition.X = 0; + case L'B': + case L'e': + csbi.dwCursorPosition.Y += arg1; + if (csbi.dwCursorPosition.Y >= csbi.dwSize.Y) + csbi.dwCursorPosition.Y = csbi.dwSize.Y; + SetConsoleCursorPosition(handle, csbi.dwCursorPosition); + break; + case L'C': + csbi.dwCursorPosition.X += arg1; + if (csbi.dwCursorPosition.X >= csbi.dwSize.X) + csbi.dwCursorPosition.X = csbi.dwSize.X; + SetConsoleCursorPosition(handle, csbi.dwCursorPosition); + break; + case L'D': + csbi.dwCursorPosition.X -= arg1; + if (csbi.dwCursorPosition.X < 0) + csbi.dwCursorPosition.X = 0; + SetConsoleCursorPosition(handle, csbi.dwCursorPosition); + break; + case L'G': + case L'`': + csbi.dwCursorPosition.X = (arg1 > csbi.dwSize.X ? csbi.dwSize.X : arg1) - 1; + SetConsoleCursorPosition(handle, csbi.dwCursorPosition); + break; + case L'd': + csbi.dwCursorPosition.Y = (arg1 > csbi.dwSize.Y ? csbi.dwSize.Y : arg1) - 1; + SetConsoleCursorPosition(handle, csbi.dwCursorPosition); + break; + case L'H': + case L'f': + pos.Y = (arg1 > csbi.dwSize.Y ? csbi.dwSize.Y : arg1) - 1; + if (count < 2 || (arg1 = seq[1]) <= 0) arg1 = 1; + pos.X = (arg1 > csbi.dwSize.X ? csbi.dwSize.X : arg1) - 1; + SetConsoleCursorPosition(handle, pos); + break; + case L'J': + switch (arg1) { + case 0: /* erase after cursor */ + FillConsoleOutputCharacterW(handle, L' ', + csbi.dwSize.X * (csbi.dwSize.Y - csbi.dwCursorPosition.Y) - csbi.dwCursorPosition.X, + csbi.dwCursorPosition, &written); + break; + case 1: /* erase before cursor */ + pos.X = 0; + pos.Y = csbi.dwCursorPosition.Y; + FillConsoleOutputCharacterW(handle, L' ', + csbi.dwSize.X * csbi.dwCursorPosition.Y + csbi.dwCursorPosition.X, + pos, &written); + break; + case 2: /* erase entire line */ + pos.X = 0; + pos.Y = 0; + FillConsoleOutputCharacterW(handle, L' ', csbi.dwSize.X * csbi.dwSize.Y, pos, &written); + break; + } + break; + case L'K': + switch (arg1) { + case 0: /* erase after cursor */ + FillConsoleOutputCharacterW(handle, L' ', csbi.dwSize.X - csbi.dwCursorPosition.X, csbi.dwCursorPosition, &written); + break; + case 1: /* erase before cursor */ + pos.X = 0; + pos.Y = csbi.dwCursorPosition.Y; + FillConsoleOutputCharacterW(handle, L' ', csbi.dwCursorPosition.X, pos, &written); + break; + case 2: /* erase entire line */ + pos.X = 0; + pos.Y = csbi.dwCursorPosition.Y; + FillConsoleOutputCharacterW(handle, L' ', csbi.dwSize.X, pos, &written); + break; + } + break; + case L's': + s->vt100.saved = csbi.dwCursorPosition; + break; + case L'u': + SetConsoleCursorPosition(handle, s->vt100.saved); + break; + case L'h': + if (count >= 2 && seq[0] == -1 && seq[1] == 25) { + CONSOLE_CURSOR_INFO cci; + GetConsoleCursorInfo(handle, &cci); + cci.bVisible = TRUE; + SetConsoleCursorInfo(handle, &cci); + } + break; + case L'l': + if (count >= 2 && seq[0] == -1 && seq[1] == 25) { + CONSOLE_CURSOR_INFO cci; + GetConsoleCursorInfo(handle, &cci); + cci.bVisible = FALSE; + SetConsoleCursorInfo(handle, &cci); + } + break; + } +} + +/* License: Ruby's */ +static long +constat_parse(HANDLE h, struct constat *s, const WCHAR **ptrp, long *lenp) +{ + const WCHAR *ptr = *ptrp; + long rest, len = *lenp; + while (len-- > 0) { + WCHAR wc = *ptr++; + if (wc == 0x1b) { + rest = *lenp - len - 1; + if (s->vt100.state == constat_esc) { + rest++; /* reuse this ESC */ + } + s->vt100.state = constat_init; + if (len > 0 && *ptr != L'[') continue; + s->vt100.state = constat_esc; + } + else if (s->vt100.state == constat_esc) { + if (wc != L'[') { + /* TODO: supply dropped ESC at beginning */ + s->vt100.state = constat_init; + continue; + } + rest = *lenp - len - 1; + if (rest > 0) --rest; + s->vt100.state = constat_seq; + s->vt100.seq[0] = 0; + } + else if (s->vt100.state >= constat_seq) { + if (wc >= L'0' && wc <= L'9') { + if (s->vt100.state < (int)numberof(s->vt100.seq)) { + int *seq = &s->vt100.seq[s->vt100.state]; + *seq = (*seq * 10) + (wc - L'0'); + } + } + else if (s->vt100.state == constat_seq && s->vt100.seq[0] == 0 && wc == L'?') { + s->vt100.seq[s->vt100.state++] = -1; + } + else { + do { + if (++s->vt100.state < (int)numberof(s->vt100.seq)) { + s->vt100.seq[s->vt100.state] = 0; + } + else { + s->vt100.state = (int)numberof(s->vt100.seq); + } + } while (0); + if (wc != L';') { + constat_apply(h, s, wc); + s->vt100.state = constat_init; + } + } + rest = 0; + } + else { + continue; + } + *ptrp = ptr; + *lenp = len; + return rest; + } + len = *lenp; + *ptrp = ptr; + *lenp = 0; + return len; +} + + +/* License: Ruby's */ +int +rb_w32_close(int fd) +{ + SOCKET sock = TO_SOCKET(fd); + int save_errno = errno; + + if (!is_socket(sock)) { + UnlockFile((HANDLE)sock, 0, 0, LK_LEN, LK_LEN); + constat_delete((HANDLE)sock); + return _close(fd); + } + _set_osfhnd(fd, (SOCKET)INVALID_HANDLE_VALUE); + socklist_delete(&sock, NULL); + _close(fd); + errno = save_errno; + if (closesocket(sock) == SOCKET_ERROR) { + errno = map_errno(WSAGetLastError()); + return -1; + } + return 0; +} + +static int +setup_overlapped(OVERLAPPED *ol, int fd, int iswrite) +{ + memset(ol, 0, sizeof(*ol)); + if (!(_osfile(fd) & (FDEV | FPIPE))) { + LONG high = 0; + /* On mode:a, it can write only FILE_END. + * On mode:a+, though it can write only FILE_END, + * it can read from everywhere. + */ + DWORD method = ((_osfile(fd) & FAPPEND) && iswrite) ? 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) { + DWORD err = GetLastError(); + if (err != NO_ERROR) { + errno = map_errno(err); + return -1; + } + } + ol->Offset = low; + ol->OffsetHigh = high; + } + ol->hEvent = CreateEvent(NULL, TRUE, TRUE, NULL); + if (!ol->hEvent) { + errno = map_errno(GetLastError()); + return -1; + } + return 0; +} + +static void +finish_overlapped(OVERLAPPED *ol, int fd, DWORD size) +{ + CloseHandle(ol->hEvent); + + if (!(_osfile(fd) & (FDEV | FPIPE))) { + LONG high = ol->OffsetHigh; + DWORD low = ol->Offset + size; + if (low < ol->Offset) + ++high; + SetFilePointer((HANDLE)_osfhnd(fd), low, &high, FILE_BEGIN); + } +} + +#undef read +/* License: Ruby's */ +ssize_t +rb_w32_read(int fd, void *buf, size_t size) +{ + SOCKET sock = TO_SOCKET(fd); + DWORD read; + DWORD wait; + DWORD err; + size_t len; + size_t ret; + OVERLAPPED ol, *pol = NULL; + BOOL isconsole; + BOOL islineinput = FALSE; + int start = 0; + + 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) { + _set_osflags(fd, _osfile(fd) & ~FEOFLAG); + MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock)); + return 0; + } + + ret = 0; + isconsole = is_console(_osfhnd(fd)) && (osver.dwMajorVersion < 6 || (osver.dwMajorVersion == 6 && osver.dwMinorVersion < 2)); + if (isconsole) { + DWORD mode; + GetConsoleMode((HANDLE)_osfhnd(fd),&mode); + islineinput = (mode & ENABLE_LINE_INPUT) != 0; + } + retry: + /* get rid of console reading bug */ + if (isconsole) { + constat_reset((HANDLE)_osfhnd(fd)); + if (start) + len = 1; + else { + len = 0; + start = 1; + } + } + else + len = size; + size -= len; + + /* if have cancel_io, use Overlapped I/O */ + if (cancel_io) { + if (setup_overlapped(&ol, fd, FALSE)) { + MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock)); + return -1; + } + + pol = &ol; + } + + if (!ReadFile((HANDLE)_osfhnd(fd), buf, len, &read, pol)) { + err = GetLastError(); + if (err == ERROR_NO_DATA && (_osfile(fd) & FPIPE)) { + DWORD state; + if (GetNamedPipeHandleState((HANDLE)_osfhnd(fd), &state, NULL, NULL, NULL, NULL, 0) && (state & PIPE_NOWAIT)) { + errno = EWOULDBLOCK; + } + else { + errno = map_errno(err); + } + MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock)); + return -1; + } + else if (err != ERROR_IO_PENDING) { + if (pol) CloseHandle(ol.hEvent); + 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; + } + } + } + else { + err = GetLastError(); + errno = map_errno(err); + } + + if (pol) { + finish_overlapped(&ol, fd, read); + } + + ret += read; + if (read >= len) { + buf = (char *)buf + read; + if (err != ERROR_OPERATION_ABORTED && + !(isconsole && len == 1 && (!islineinput || *((char *)buf - 1) == '\n')) && size > 0) + goto retry; + } + if (read == 0) + _set_osflags(fd, _osfile(fd) | FEOFLAG); + + + MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock)); + + return ret; +} + +#undef write +/* License: Ruby's */ +ssize_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) && + (!(_osfile(fd) & FPIPE) || fd == fileno(stdout) || fd == fileno(stderr))) { + 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; + retry2: + + /* if have cancel_io, use Overlapped I/O */ + if (cancel_io) { + if (setup_overlapped(&ol, fd, TRUE)) { + 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 (pol) CloseHandle(ol.hEvent); + 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(GetLastError()); + CloseHandle(ol.hEvent); + cancel_io((HANDLE)_osfhnd(fd)); + MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock)); + return -1; + } + } + } + + if (pol) { + finish_overlapped(&ol, fd, written); + } + + ret += written; + if (written == len) { + buf = (const char *)buf + len; + if (size > 0) + goto retry; + } + if (ret == 0) { + size_t newlen = len / 2; + if (newlen > 0) { + size += len - newlen; + len = newlen; + goto retry2; + } + ret = -1; + errno = EWOULDBLOCK; + } + + MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock)); + + return ret; +} + +/* License: Ruby's */ +long +rb_w32_write_console(uintptr_t strarg, int fd) +{ + static int disable; + HANDLE handle; + DWORD dwMode, reslen; + VALUE str = strarg; + int encindex; + WCHAR *wbuffer = 0; + const WCHAR *ptr, *next; + struct constat *s; + long len; + + if (disable) return -1L; + handle = (HANDLE)_osfhnd(fd); + if (!GetConsoleMode(handle, &dwMode)) + return -1L; + + s = constat_handle(handle); + if (!s) return -1L; + encindex = ENCODING_GET(str); + switch (encindex) { + default: + if (!rb_econv_has_convpath_p(rb_enc_name(rb_enc_from_index(encindex)), "UTF-8")) + return -1L; + str = rb_str_conv_enc_opts(str, NULL, rb_enc_from_index(ENCINDEX_UTF_8), + ECONV_INVALID_REPLACE|ECONV_UNDEF_REPLACE, Qnil); + /* fall through */ + case ENCINDEX_US_ASCII: + case ENCINDEX_ASCII: + /* assume UTF-8 */ + case ENCINDEX_UTF_8: + ptr = wbuffer = mbstr_to_wstr(CP_UTF8, RSTRING_PTR(str), RSTRING_LEN(str), &len); + if (!ptr) return -1L; + break; + case ENCINDEX_UTF_16LE: + ptr = (const WCHAR *)RSTRING_PTR(str); + len = RSTRING_LEN(str) / sizeof(WCHAR); + break; + } + while (len > 0) { + long curlen = constat_parse(handle, s, (next = ptr, &next), &len); + if (curlen > 0) { + if (!WriteConsoleW(handle, ptr, curlen, &reslen, NULL)) { + if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) + disable = TRUE; + reslen = (DWORD)-1L; + break; + } + } + ptr = next; + } + RB_GC_GUARD(str); + if (wbuffer) free(wbuffer); + return (long)reslen; +} + +/* License: Ruby's */ +static int +unixtime_to_filetime(time_t time, FILETIME *ft) +{ + ULARGE_INTEGER tmp; + + tmp.QuadPart = ((LONG_LONG)time + (LONG_LONG)((1970-1601)*365.2425) * 24 * 60 * 60) * 10 * 1000 * 1000; + ft->dwLowDateTime = tmp.LowPart; + ft->dwHighDateTime = tmp.HighPart; + return 0; +} + +/* License: Ruby's */ +static int +wutime(const WCHAR *path, const struct utimbuf *times) +{ + HANDLE hFile; + FILETIME atime, mtime; + struct stati64 stat; + int ret = 0; + + if (wstati64(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 = GetFileAttributesW(path); + if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY)) + SetFileAttributesW(path, attr & ~FILE_ATTRIBUTE_READONLY); + hFile = CreateFileW(path, GENERIC_WRITE, 0, 0, OPEN_EXISTING, + 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)) + SetFileAttributesW(path, attr); + }); + + return ret; +} + +/* License: Ruby's */ +int +rb_w32_uutime(const char *path, const struct utimbuf *times) +{ + WCHAR *wpath; + int ret; + + if (!(wpath = utf8_to_wstr(path, NULL))) + return -1; + ret = wutime(wpath, times); + free(wpath); + return ret; +} + +/* License: Ruby's */ +int +rb_w32_utime(const char *path, const struct utimbuf *times) +{ + WCHAR *wpath; + int ret; + + if (!(wpath = filecp_to_wstr(path, NULL))) + return -1; + ret = wutime(wpath, times); + free(wpath); + return ret; +} + +/* License: Ruby's */ +int +rb_w32_uchdir(const char *path) +{ + WCHAR *wpath; + int ret; + + if (!(wpath = utf8_to_wstr(path, NULL))) + return -1; + ret = _wchdir(wpath); + free(wpath); + return ret; +} + +/* License: Ruby's */ +static int +wmkdir(const WCHAR *wpath, int mode) +{ + int ret = -1; + + RUBY_CRITICAL(do { + if (CreateDirectoryW(wpath, NULL) == FALSE) { + errno = map_errno(GetLastError()); + break; + } + if (_wchmod(wpath, mode) == -1) { + RemoveDirectoryW(wpath); + break; + } + ret = 0; + } while (0)); + return ret; +} + +/* License: Ruby's */ +int +rb_w32_umkdir(const char *path, int mode) +{ + WCHAR *wpath; + int ret; + + if (!(wpath = utf8_to_wstr(path, NULL))) + return -1; + ret = wmkdir(wpath, mode); + free(wpath); + return ret; +} + +/* License: Ruby's */ +int +rb_w32_mkdir(const char *path, int mode) +{ + WCHAR *wpath; + int ret; + + if (!(wpath = filecp_to_wstr(path, NULL))) + return -1; + ret = wmkdir(wpath, mode); + free(wpath); + return ret; +} + +/* License: Ruby's */ +static int +wrmdir(const WCHAR *wpath) +{ + int ret = 0; + RUBY_CRITICAL({ + const DWORD attr = GetFileAttributesW(wpath); + if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY)) { + SetFileAttributesW(wpath, attr & ~FILE_ATTRIBUTE_READONLY); + } + if (RemoveDirectoryW(wpath) == FALSE) { + errno = map_errno(GetLastError()); + ret = -1; + if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY)) { + SetFileAttributesW(wpath, attr); + } + } + }); + return ret; +} + +/* License: Ruby's */ +int +rb_w32_rmdir(const char *path) +{ + WCHAR *wpath; + int ret; + + if (!(wpath = filecp_to_wstr(path, NULL))) + return -1; + ret = wrmdir(wpath); + free(wpath); + return ret; +} + +/* License: Ruby's */ +int +rb_w32_urmdir(const char *path) +{ + WCHAR *wpath; + int ret; + + if (!(wpath = utf8_to_wstr(path, NULL))) + return -1; + ret = wrmdir(wpath); + free(wpath); + return ret; +} + +/* License: Ruby's */ +static int +wunlink(const WCHAR *path) +{ + int ret = 0; + RUBY_CRITICAL({ + const DWORD attr = GetFileAttributesW(path); + if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY)) { + SetFileAttributesW(path, attr & ~FILE_ATTRIBUTE_READONLY); + } + if (!DeleteFileW(path)) { + errno = map_errno(GetLastError()); + ret = -1; + if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY)) { + SetFileAttributesW(path, attr); + } + } + }); + return ret; +} + +/* License: Ruby's */ +int +rb_w32_uunlink(const char *path) +{ + WCHAR *wpath; + int ret; + + if (!(wpath = utf8_to_wstr(path, NULL))) + return -1; + ret = wunlink(wpath); + free(wpath); + return ret; +} + +/* License: Ruby's */ +int +rb_w32_unlink(const char *path) +{ + WCHAR *wpath; + int ret; + + if (!(wpath = filecp_to_wstr(path, NULL))) + return -1; + ret = wunlink(wpath); + free(wpath); + return ret; +} + +/* License: Ruby's */ +int +rb_w32_uchmod(const char *path, int mode) +{ + WCHAR *wpath; + int ret; + + if (!(wpath = utf8_to_wstr(path, NULL))) + return -1; + ret = _wchmod(wpath, mode); + free(wpath); + return ret; +} + +#if !defined(__BORLANDC__) +/* License: Ruby's */ +int +rb_w32_isatty(int fd) +{ + DWORD mode; + + // validate fd by using _get_osfhandle() because we cannot access _nhandle + if (_get_osfhandle(fd) == -1) { + return 0; + } + if (!GetConsoleMode((HANDLE)_osfhnd(fd), &mode)) { + errno = ENOTTY; + return 0; + } + return 1; +} +#endif + +// +// Fix bcc32's stdio bug +// + +#ifdef __BORLANDC__ +/* License: Ruby's */ +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 +/* License: Ruby's */ +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; +} + +/* License: Ruby's */ +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; +} + +/* License: Ruby's */ +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 + +#if defined(_MSC_VER) && RUBY_MSVCRT_VERSION <= 60 +extern long _ftol(double); +/* License: Ruby's */ +long +_ftol2(double d) +{ + return _ftol(d); +} + +/* License: Ruby's */ +long +_ftol2_sse(double d) +{ + return _ftol(d); +} +#endif + +#ifndef signbit +/* License: Ruby's */ +int +signbit(double x) +{ + int *ip = (int *)(&x + 1) - 1; + return *ip < 0; +} +#endif + +/* License: Ruby's */ +const char * WSAAPI +rb_w32_inet_ntop(int af, const void *addr, char *numaddr, size_t numaddr_len) +{ + typedef char *(WSAAPI inet_ntop_t)(int, void *, char *, size_t); + inet_ntop_t *pInetNtop; + pInetNtop = (inet_ntop_t *)get_proc_address("ws2_32", "inet_ntop", NULL); + if (pInetNtop) { + return pInetNtop(af, (void *)addr, numaddr, numaddr_len); + } + else { + struct in_addr in; + memcpy(&in.s_addr, addr, sizeof(in.s_addr)); + snprintf(numaddr, numaddr_len, "%s", inet_ntoa(in)); + } + return numaddr; +} + +/* License: Ruby's */ +int WSAAPI +rb_w32_inet_pton(int af, const char *src, void *dst) +{ + typedef int (WSAAPI inet_pton_t)(int, const char*, void *); + inet_pton_t *pInetPton; + pInetPton = (inet_pton_t *)get_proc_address("ws2_32", "inet_pton", NULL); + if (pInetPton) { + return pInetPton(af, src, dst); + } + return 0; +} + +/* License: Ruby's */ +char +rb_w32_fd_is_text(int fd) +{ + return _osfile(fd) & FTEXT; +} + +#if RUBY_MSVCRT_VERSION < 80 && !defined(HAVE__GMTIME64_S) +/* License: Ruby's */ +static int +unixtime_to_systemtime(const time_t t, SYSTEMTIME *st) +{ + FILETIME ft; + if (unixtime_to_filetime(t, &ft)) return -1; + if (!FileTimeToSystemTime(&ft, st)) return -1; + return 0; +} + +/* License: Ruby's */ +static void +systemtime_to_tm(const SYSTEMTIME *st, struct tm *t) +{ + int y = st->wYear, m = st->wMonth, d = st->wDay; + t->tm_sec = st->wSecond; + t->tm_min = st->wMinute; + t->tm_hour = st->wHour; + t->tm_mday = st->wDay; + t->tm_mon = st->wMonth - 1; + t->tm_year = y - 1900; + t->tm_wday = st->wDayOfWeek; + switch (m) { + case 1: + break; + case 2: + d += 31; + break; + default: + d += 31 + 28 + (!(y % 4) && ((y % 100) || !(y % 400))); + d += ((m - 3) * 153 + 2) / 5; + break; + } + t->tm_yday = d - 1; +} + +/* License: Ruby's */ +static int +systemtime_to_localtime(TIME_ZONE_INFORMATION *tz, SYSTEMTIME *gst, SYSTEMTIME *lst) +{ + TIME_ZONE_INFORMATION stdtz; + SYSTEMTIME sst; + + if (!SystemTimeToTzSpecificLocalTime(tz, gst, lst)) return -1; + if (!tz) { + GetTimeZoneInformation(&stdtz); + tz = &stdtz; + } + if (tz->StandardBias == tz->DaylightBias) return 0; + if (!tz->StandardDate.wMonth) return 0; + if (!tz->DaylightDate.wMonth) return 0; + if (tz != &stdtz) stdtz = *tz; + + stdtz.StandardDate.wMonth = stdtz.DaylightDate.wMonth = 0; + if (!SystemTimeToTzSpecificLocalTime(&stdtz, gst, &sst)) return 0; + if (lst->wMinute == sst.wMinute && lst->wHour == sst.wHour) + return 0; + return 1; +} +#endif + +#ifdef HAVE__GMTIME64_S +# ifndef HAVE__LOCALTIME64_S +/* assume same as _gmtime64_s() */ +# define HAVE__LOCALTIME64_S 1 +# endif +# ifndef MINGW_HAS_SECURE_API + _CRTIMP errno_t __cdecl _gmtime64_s(struct tm* tm, const __time64_t *time); + _CRTIMP errno_t __cdecl _localtime64_s(struct tm* tm, const __time64_t *time); +# endif +# define gmtime_s _gmtime64_s +# define localtime_s _localtime64_s +#endif + +/* License: Ruby's */ +struct tm * +gmtime_r(const time_t *tp, struct tm *rp) +{ + int e = EINVAL; + if (!tp || !rp) { + error: + errno = e; + return NULL; + } +#if RUBY_MSVCRT_VERSION >= 80 || defined(HAVE__GMTIME64_S) + e = gmtime_s(rp, tp); + if (e != 0) goto error; +#else + { + SYSTEMTIME st; + if (unixtime_to_systemtime(*tp, &st)) goto error; + rp->tm_isdst = 0; + systemtime_to_tm(&st, rp); + } +#endif + return rp; +} + +/* License: Ruby's */ +struct tm * +localtime_r(const time_t *tp, struct tm *rp) +{ + int e = EINVAL; + if (!tp || !rp) { + error: + errno = e; + return NULL; + } +#if RUBY_MSVCRT_VERSION >= 80 || defined(HAVE__LOCALTIME64_S) + e = localtime_s(rp, tp); + if (e) goto error; +#else + { + SYSTEMTIME gst, lst; + if (unixtime_to_systemtime(*tp, &gst)) goto error; + rp->tm_isdst = systemtime_to_localtime(NULL, &gst, &lst); + systemtime_to_tm(&lst, rp); + } +#endif + return rp; +} + +/* License: Ruby's */ +int +rb_w32_wrap_io_handle(HANDLE h, int flags) +{ + BOOL tmp; + int len = sizeof(tmp); + int r = getsockopt((SOCKET)h, SOL_SOCKET, SO_DEBUG, (char *)&tmp, &len); + if (r != SOCKET_ERROR || WSAGetLastError() != WSAENOTSOCK) { + int f = 0; + if (flags & O_NONBLOCK) { + flags &= ~O_NONBLOCK; + f = O_NONBLOCK; + } + socklist_insert((SOCKET)h, f); + } + else if (flags & O_NONBLOCK) { + errno = EINVAL; + return -1; + } + return rb_w32_open_osfhandle((intptr_t)h, flags); +} + +/* License: Ruby's */ +int +rb_w32_unwrap_io_handle(int fd) +{ + SOCKET sock = TO_SOCKET(fd); + _set_osfhnd(fd, (SOCKET)INVALID_HANDLE_VALUE); + if (!is_socket(sock)) { + UnlockFile((HANDLE)sock, 0, 0, LK_LEN, LK_LEN); + constat_delete((HANDLE)sock); + } + else { + socklist_delete(&sock, NULL); + } + return _close(fd); +} + +#if !defined(__MINGW64__) && defined(__MINGW64_VERSION_MAJOR) +/* + * Set floating point precision for pow() of mingw-w64 x86. + * With default precision the result is not proper on WinXP. + */ +double +rb_w32_pow(double x, double y) +{ +#undef pow + double r; + unsigned int default_control = _controlfp(0, 0); + _controlfp(_PC_64, _MCW_PC); + r = pow(x, y); + /* Restore setting */ + _controlfp(default_control, _MCW_PC); + return r; +} +#endif + +#if RUBY_MSVCRT_VERSION < 120 +#include "missing/nextafter.c" +#endif diff --git a/jni/ruby/win32/winmain.c b/jni/ruby/win32/winmain.c new file mode 100644 index 0000000..467a835 --- /dev/null +++ b/jni/ruby/win32/winmain.c @@ -0,0 +1,10 @@ +#include +#include + +extern int main(int, char**); + +int WINAPI +WinMain(HINSTANCE current, HINSTANCE prev, LPSTR cmdline, int showcmd) +{ + return main(0, NULL); +} -- cgit v1.2.3