subspawn-win32 0.2.0.pre1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4824ace4f995314f87c68497af9b0ab8e45154b383221d9d35a0acd804efd09f
+  data.tar.gz: 332afa90e72b124d99482e67144ae8c06f239c3258ddd2038ed540b12ea84e99
+SHA512:
+  metadata.gz: 7cc966c090bcd70e901abdc55a3f7ae2dad2590f9ac74f9917dc3f4b2eb1b34da2d89f6022afa4d21e4f7717c63795d4e07187cf2fc4c58649d566b254c39294
+  data.tar.gz: fa38824ce6dc9b5891ab72cd59e6e376680ddc5bc60c4f77e3dd293dc5449065a6cc98897359bd287e5e37e0d6c8363b0f61c55381fdee752ec4a3458ab05d23

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in process-wrapper-mid.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"
+gem "ffi", "~> 1.0"

data/README.md

@@ -0,0 +1,27 @@
+# SubSpawn Native Win32 API
+
+SubSpawn wrapper over the Win32 process API. Should work on all recent 32 and 64-bit Windows releases
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add subspawn-win32
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install subspawn-win32
+
+## Usage
+
+```rb
+require 'subspawn/win32'
+```
+
+See SubSpawn for more details.
+
+An RBS file exists for this gem.
+
+## Development
+
+See parent SubSpawn readme

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :build

data/lib/subspawn/win32/ffi.rb

@@ -0,0 +1,252 @@
+require 'ffi'
+module SubSpawn::Win32::FFI
+	extend FFI::Library
+
+	W = SubSpawn::Win32::FFI
+
+	# Common types
+
+	# uintptr or :pointer ?
+	typedef :intptr_t, :shandle
+	typedef :uintptr_t, :handle
+	typedef :int, :hresult
+
+	# TODO: I think this is corect?
+	typedef :uint, :dword
+	typedef :ushort, :word
+
+	module MMHelper
+		# from https://github.com/ffi/ffi/wiki/Structs
+
+		# Use the symbol passed from the method for accessing the analogous field.
+		# This method can also take a &block, but we would not use it.
+		def method_missing( sym, *args )
+		  # convert symbol to a string to allow regex checks
+		  str = sym.to_s
+		  
+		  # derive the member's symbolic name
+		  member = str.match( /^([a-z0-9_]+)/i )[1].to_sym
+	  
+		  # raise an exception via the default behavior if that symbol isn't a member!
+		  super unless members.include? member
+	  
+		  # this ternary checks for the presence of an equals sign (=) to indicate an
+		  # assignment operation and changes which method we invoke and whether or not
+		  # to send the splatted arguments as well.
+		  (str =~ /=$/) ? send( :[]=, member, *args ) : send( :[], member )
+		end
+	end
+
+	class ProcInfo < FFI::Struct
+		include MMHelper
+	   #_PROCESS_INFORMATION
+	   layout		:hProcess, :handle,
+		:hThread, :handle,
+		:dwProcessId, :dword,
+		:dwThreadId, :dword
+
+		# TODO: if this is a managed struct, we could autofree the handles. Do we want to?
+		# def self.release ptr
+		# 	W.free(ptr.hThread)
+		# 	W.free(ptr.hProcess)
+		# end
+	end
+	   
+	   
+	class StartupInfo < FFI::Struct
+		include MMHelper
+	   #_STARTUPINFOEXW
+	   layout  :cb, :dword,
+		:lpReserved, :pointer,
+		:lpDesktop, :pointer,
+		:lpTitle, :pointer,
+		:dwX, :dword,
+		:dwY, :dword,
+		:dwXSize, :dword,
+		:dwYSize, :dword,
+		:dwXCountChars, :dword,
+		:dwYCountChars, :dword,
+		:dwFillAttribute, :dword,
+		:dwFlags, :dword,
+		:wShowWindow, :word,
+		:cbReserved2, :word,
+		:lpReserved2, :pointer,
+		:hStdInput, :handle,
+		:hStdOutput, :handle,
+		:hStdError, :handle,
+		:lpAttributeList, :pointer
+
+		def initialize()
+			super
+			self[:cb] = self.class.size
+		end
+	end
+
+	class SecurityAttributes < FFI::Struct
+		include MMHelper
+		# _SECURITY_ATTRIBUTES
+		layout :nLength, :dword,
+			:lpSecurityDescriptor, :pointer,
+			:bInheritHandle, :bool
+
+		def initialize()
+			super
+			self[:nLength] = self.class.size
+		end
+	end
+
+	class Coord < FFI::Struct
+		include MMHelper
+		# _COORD
+		layout :x, :short,
+			:y, :short
+
+		def initialize(x=0,y=0)
+			super()
+			self[:x] = x
+			self[:y] = y
+		end
+		def to_a
+			[x, y]
+		end
+		def to_ary
+			[x, y]
+		end
+		def self.[](*keys)
+			self.new(*keys.flatten)
+		end
+	end
+  
+	ffi_lib :kernel32
+
+	attach_function :GetLastError, [], :dword
+	attach_function :WaitForSingleObject, [:handle, :dword], :dword
+	attach_function :GetExitCodeProcess, [:handle, :buffer_out], :bool
+	attach_function :OpenProcess, [:dword, :bool, :dword], :handle
+  
+	attach_function :CloseHandle, [:handle], :bool
+	attach_function :CreateProcess, :CreateProcessW, %i{buffer_in buffer_inout pointer pointer bool dword buffer_in buffer_in pointer pointer}, :bool # TODO: specify the types, not just pointers?
+	attach_function :GetStdHandle, [:dword], :handle
+
+	attach_function :InitializeProcThreadAttributeList, %i{buffer_out dword dword buffer_inout}, :bool
+
+	# the first pointer/handle should really be a pointer, but we use it as a pointer
+	attach_function :UpdateProcThreadAttribute, %i{buffer_inout dword handle handle size_t pointer pointer}, :bool
+	attach_function :DeleteProcThreadAttributeList, [:buffer_inout], :void
+
+	attach_function :SetHandleInformation, [:handle, :dword, :dword], :bool
+	
+	# PTY
+	# HPCON == handle
+	attach_function :ClosePseudoConsole, [:handle], :void
+	attach_function :ResizePseudoConsole, [:handle, :pointer], :int
+	attach_function :CreatePseudoConsole, %i{buffer_in handle handle dword buffer_out}, :int
+
+
+	ffi_lib FFI::Library::LIBC
+
+	attach_function :get_osfhandle, :_get_osfhandle, [:int], :shandle
+	attach_function :get_errno, :_get_errno, [:buffer_inout], :int
+
+	# Constants
+	# TODO: are these already somewhere?
+
+	SIZEOF_HPCON = FFI::Pointer::SIZE
+	
+	INFINITE = 0xFFFFFFFF
+	INVALID_HANDLE_VALUE = -1 # unsure if signed or unsigned is better
+	HANDLE_NEGATIVE_TWO = -2
+	HANDLE_FLAG_INHERIT = 1
+
+	# Process flags
+	DEBUG_PROCESS					= 0x00000001
+	DEBUG_ONLY_THIS_PROCESS			= 0x00000002
+	CREATE_SUSPENDED				= 0x00000004
+	DETACHED_PROCESS				= 0x00000008
+	CREATE_NEW_CONSOLE				= 0x00000010
+	NORMAL_PRIORITY_CLASS			= 0x00000020 # TODO: where is this listed on MSDN?
+	CREATE_NEW_PROCESS_GROUP		= 0x00000200
+	CREATE_UNICODE_ENVIRONMENT		= 0x00000400
+	CREATE_SEPARATE_WOW_VDM			= 0x00000800
+	CREATE_SHARED_WOW_VDM			= 0x00001000
+	INHERIT_PARENT_AFFINITY			= 0x00010000
+	CREATE_PROTECTED_PROCESS		= 0x00040000
+	EXTENDED_STARTUPINFO_PRESENT	= 0x00080000
+	CREATE_SECURE_PROCESS			= 0x00400000
+	CREATE_BREAKAWAY_FROM_JOB		= 0x01000000
+	CREATE_PRESERVE_CODE_AUTHZ_LEVEL= 0x02000000
+	CREATE_DEFAULT_ERROR_MODE		= 0x04000000
+	CREATE_NO_WINDOW				= 0x08000000
+
+	STARTF_USESHOWWINDOW	= 0x00000001
+	STARTF_USESIZE		 	= 0x00000002
+	STARTF_USEPOSITION		= 0x00000004
+	STARTF_USECOUNTCHARS	= 0x00000008
+	STARTF_USEFILLATTRIBUTE	= 0x00000010
+	STARTF_RUNFULLSCREEN	= 0x00000020
+	STARTF_FORCEONFEEDBACK	= 0x00000040
+	STARTF_FORCEOFFFEEDBACK	= 0x00000080
+	STARTF_USESTDHANDLES	= 0x00000100
+	STARTF_USEHOTKEY		= 0x00000200
+	#
+	STARTF_TITLEISLINKNAME	= 0x00000800
+	STARTF_TITLEISAPPID		= 0x00001000
+	STARTF_PREVENTPINNING	= 0x00002000
+	#
+	STARTF_UNTRUSTEDSOURCE	= 0x00008000
+
+	# Status/errors, and mapping to posix errors. Note we only map what CRuby maps
+
+	STATUS_ACCESS_VIOLATION			= 0xC0000005
+	STATUS_ILLEGAL_INSTRUCTION		= 0xC000001D
+	STATUS_FLOAT_DENORMAL_OPERAND	= 0xC000008D
+	STATUS_FLOAT_DIVIDE_BY_ZERO		= 0xC000008E
+	STATUS_FLOAT_INEXACT_RESULT		= 0xC000008F
+	STATUS_FLOAT_INVALID_OPERATION	= 0xC0000090
+	STATUS_FLOAT_OVERFLOW			= 0xC0000091
+	STATUS_FLOAT_STACK_CHECK		= 0xC0000092
+	STATUS_FLOAT_UNDERFLOW			= 0xC0000093
+	STATUS_PRIVILEGED_INSTRUCTION	= 0xC0000096
+	STATUS_CONTROL_C_EXIT			= 0xC000013A
+	STATUS_FLOAT_MULTIPLE_FAULTS	= 0xC00002B4
+	STATUS_FLOAT_MULTIPLE_TRAPS		= 0xC00002B5
+
+	StatusPosixMap = {
+		STATUS_ACCESS_VIOLATION => "SEGV",
+		STATUS_ILLEGAL_INSTRUCTION => "ILL",
+		STATUS_PRIVILEGED_INSTRUCTION => "ILL",
+		STATUS_FLOAT_DENORMAL_OPERAND => "FPE",
+		STATUS_FLOAT_DIVIDE_BY_ZERO => "FPE",
+		STATUS_FLOAT_INEXACT_RESULT => "FPE",
+		STATUS_FLOAT_INVALID_OPERATION => "FPE",
+		STATUS_FLOAT_OVERFLOW => "FPE",
+		STATUS_FLOAT_STACK_CHECK => "FPE",
+		STATUS_FLOAT_UNDERFLOW => "FPE",
+		STATUS_FLOAT_MULTIPLE_FAULTS => "FPE",
+		STATUS_FLOAT_MULTIPLE_TRAPS => "FPE",
+		STATUS_CONTROL_C_EXIT => "INT",
+	}
+	StatusPosixMap.default = "SEGV"
+
+	# TODO: expose other values for the proc thread list
+	PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE = 0x00020016
+
+	# Also unsigned, but this is convienent, and ffi takes care of the rest
+	STD_HANDLE = {
+		0 => -10,
+		1 => -11,
+		2 => -12,
+	}
+
+	#PTY
+	PSEUDOCONSOLE_INHERIT_CURSOR = 1
+
+	# waiting
+	STILL_ACTIVE = 259
+	PROCESS_QUERY_INFORMATION = 0x00000400
+	
+	# TODO: error reporting?
+	def self.free hwnd
+		W.CloseHandle(hwnd) unless hwnd.nil?
+	end
+end

data/lib/subspawn/win32/lazy-hndl.rb

@@ -0,0 +1,16 @@
+class SubSpawn::Win32::LazyHndl
+	def self.closer(hndl)
+		lambda do |obj_id|
+			SubSpawn::Win32::W.CloseHandle(hndl)
+		end
+	end
+
+	def initialize(pid, hndl)
+		ObjectSpace.define_finalizer(self, self.class.closer(hndl))
+		@hndl = hndl
+		@pid = pid
+	end
+
+	attr_reader :hndl
+	attr_reader :pid
+end

data/lib/subspawn/win32/pty.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require 'subspawn/win32'
+require 'subspawn/common'
+
+module SubSpawn
+class Win32
+module PtyHelper
+
+	W = SubSpawn::Win32::FFI
+
+	class MasterPtyIO < SubSpawn::Common::BidiMergedIO
+		def initialize(read, write, pty)
+			super(read, write)
+			read.sync = true
+			write.sync = true
+			@con_pty = pty
+		end
+
+		def inspect
+			"#<masterpty:#{@con_pty}>"
+		end
+
+		def winsize
+			@conpty.winsize
+		end
+
+		def winsize= arg
+			@conpty.winsize = arg
+		end
+		def tty?
+			true
+		end
+		def isatty
+			true
+		end
+
+		# Subspawn-specific feature
+		attr_reader :con_pty
+	end
+	class SlavePtyIO < SubSpawn::Common::BidiMergedIO
+		def initialize(read, write, pty)
+			super(read, write)
+			read.sync = true
+			write.sync = true
+			@con_pty = pty
+		end
+
+		def winsize
+			@conpty.winsize
+		end
+
+		def winsize= arg
+			@conpty.winsize = arg
+		end
+		def tty?
+			true
+		end
+		def isatty
+			true
+		end
+
+		def inspect
+			"#<winpty:#{@con_pty}>"
+		end
+
+		# Subspawn-specific feature
+		attr_reader :con_pty
+	end
+
+	# TODO: ensure all handles/resources are cleaned up properly
+	class ConPTYHelper
+		def initialize(hpc, pipes, size)
+			@hpc = hpc
+			@close = true
+			@pipes = pipes
+			@lastsize = size
+		end
+		def winsize
+			@lastsize
+		end
+		def winsize=(size)
+			if W::ResizePseudoConsole(@hpc, W::Coord[size]) < 0
+				raise "ConPTY Resize failure"
+			else
+				@lastsize = size
+			end
+		end
+		def con_pty
+			self
+		end
+		def raw_handle
+			@hpc
+		end
+		def no_gc!
+			@close=false
+		end
+		def close
+			if @close
+				W::ClosePseudoConsole(@hpc) # TODO!
+				@hpc = nil
+				@pipes.reject(&:closed?).each(&:close)
+			end
+		end
+		def closed?
+			if @close
+				@hpc.nil? && @pipes.all?(&:closed?)
+			else
+				nil # falsy
+			end
+		end
+	end
+	module IoHelper
+		refine IO do
+			def to_hndl
+				hndl = if RUBY_ENGINE == "jruby"
+					self.fileno # jruby returns the raw handle, not the fd
+				else
+					W.get_osfhandle(self.fileno)
+				end
+
+				if hndl == W::INVALID_HANDLE_VALUE || hndl == W::HANDLE_NEGATIVE_TWO
+					raise SystemCallError.new("Invalid FD/handle for input fd #{self}", FFI.errno)
+				end
+				hndl
+			end
+		end
+	end
+	using IoHelper
+
+	def self.open_internal(chmod_for_open = false, initial_size: [40,80], flags: 0)
+		# TODO: does windows care about permissions? I'm going to assume no for now
+
+		child_r, us_w = IO.pipe
+		us_r, child_w = IO.pipe
+		size = W::Coord[initial_size]
+		hpc = nil
+		::FFI::MemoryPointer.new(:uintptr_t, 1) do |ptyref|
+			hr = W::CreatePseudoConsole(size, child_r.to_hndl, child_w.to_hndl, flags, ptyref)
+			if hr < 0 # failure
+				raise "ConPTY failure: #{hr}"
+			end
+			hpc = ptyref.read(:uintptr_t)
+		end
+
+		pty = ConPTYHelper.new(hpc, [child_r, child_w, us_r, us_w], initial_size.flatten)
+		master = MasterPtyIO.new(us_r, us_w, pty)
+
+		slave = SlavePtyIO.new(child_r, child_w, pty)
+
+		#child_r.close
+		#child_w.close
+
+		[master, slave, pty]
+	end
+
+	def self.open
+		*files, pty = open_internal(true)
+		return files unless block_given?
+
+		begin
+			return yield files.dup # Array, not splatted
+		ensure
+			pty.close
+			files.reject(&:closed?).each(&:close)
+		end
+	end
+
+end
+end
+end

data/lib/subspawn/win32/raw_status.rb

@@ -0,0 +1,92 @@
+# JRuby and CRuby both do internal things to build the status, so I think we can mostly just override it
+# without checking
+module Process
+	class Status
+		def initialize(pid, status=nil, termsig=nil)
+			@pid = pid
+			@stat = status
+			@termsig = termsig
+		end
+	
+		private :initialize
+
+		# Public API (it's weird!)
+
+		def & num
+			@stat & num
+		end
+
+		def == other
+			if other.is_a? Process::Status
+				@stat == other.exitstatus
+				# Very weird that we don't compare pids or termination options
+				# but the doc says we only need to do this.
+			else
+				false
+			end
+		end
+
+		def >> num
+		  @stat >> num
+		end
+
+		# no coredumps on windows
+		def coredump?
+			false
+		end
+
+		def exited?
+			!@stat.nil?
+		end
+
+		def exitstatus
+			@stat
+		end
+
+		def inspect
+			"#<Process::Status: #{to_s}>"
+		end
+
+		attr_reader :pid
+
+		def signaled?
+			!@termsig.nil?
+		end
+
+		# No stopped condition on windows
+		def stopped?
+			false
+		end
+
+		def stopsig
+			nil
+		end
+
+		def success?
+			return nil unless exited?
+			return exitstatus == 0
+		end
+
+		attr_reader :termsig
+	
+		def to_i
+			# a deeply unsettling API here, but it's platform-dependent, so lets make it slightly saner
+			((@stat || 0)) | ((@termsig || 0) << 8)
+		end
+	
+		def to_s
+			tail = if exited?
+				"exit #{exitstatus}"
+			else # stopped or signaled, probably
+				mid = "signal #{termsig}"
+				name = Signal.signame(termsig)
+				if name
+					"SIG#{name} (#{mid})"
+				else
+					mid
+				end
+			end
+			"pid #{@pid} #{tail}"
+		end
+	end
+end

data/lib/subspawn/win32/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module SubSpawn
+	class Win32
+		VERSION = "0.2.0.pre1"
+	end
+end

data/lib/subspawn/win32.rb

@@ -0,0 +1,579 @@
+require 'subspawn/win32/version'
+require 'subspawn/win32/ffi'
+require 'subspawn/win32/raw_status'
+require 'engine-hacks'
+module SubSpawn
+class SpawnError < RuntimeError
+end
+class UnimplementedError < RuntimeError
+end
+class Win32
+	W = SubSpawn::Win32::FFI
+
+	module WinStr
+		refine Object do
+			def to_wstr
+				"#{self.to_str}\0".encode("UTF-16LE")
+			end
+			def to_wstrp
+				::FFI::MemoryPointer.from_string(to_wstr)
+			end
+		end
+		refine NilClass do
+			def to_wstr
+				nil
+			end
+			def to_wstrp
+				nil
+			end
+		end
+	end
+	using WinStr
+
+	
+	OpenFD = Struct.new(:fd, :path, :mode, :flags, :ref)
+	def initialize(command, *args, arg0: command)
+		@path = command
+		#raise SpawnError, "Command not found: #{command}" unless @path
+		# TODO: we use envp, so can't check this now
+		@argv = [arg0, *args.map(&:to_str)]
+		@fd_map = {}
+		@fd_keeps = []
+		@fd_closes = []
+		@fd_opens = []
+		@cwd = nil
+		@pgroup = nil
+		@env = :default
+		@ctty = nil
+
+		@win = {
+			reqflags: 0,
+			flags: 0,
+			title: nil,
+			desktop: nil,
+			show: 0,
+			confil: 0,
+		}
+
+	end
+	attr_writer :cwd, :ctty
+	
+	StdIn = 0
+	StdOut= 1
+	StdErr = 2
+	Std = {in: StdIn, out: StdOut, err: StdErr}.freeze
+	
+	def validate!
+		@argv.map!(&:to_str) # By spec
+		raise SpawnError, "Invalid argv" unless @argv.length > 0
+		@fd_map = @fd_map.map do |number, source|
+			raise SpawnError, "Invalid FD map: Not a number: #{number.inspect}" unless number.is_a? Integer
+			[number, fd_check(source)]
+		end.to_h
+		@fd_keeps.each{|x| fd_check(x)}
+		@fd_closes.each{|x| fd_check(x)}
+		@fd_opens.each{|x|
+			fd_check(x.fd)
+			raise SpawnError, "Invalid FD open: Not a number: #{x.mode.inspect}" unless x.mode.is_a? Integer
+			raise SpawnError, "Invalid FD open: Not a flag: #{x.flags.inspect}" unless x.flags.is_a? Integer
+			raise SpawnError, "Invalid FD open: Not a file: #{x.file.inspect}" unless File.exist? x.path or Dir.exist?(File.dirname(x.path))
+			raise SpawnError, "Invalid FD open: overwrites existing mapping #{x.file.inspect}" unless @fd_map[fd_number(x.fd)].nil?
+			@fd_map[fd_number(x.fd)] = x
+		}
+
+		@path = @path.gsub("/", "\\")
+		@cwd = @cwd.gsub("/", "\\") unless @cwd.nil?
+		
+		raise SpawnError, "Invalid cwd path" unless @cwd.nil? or Dir.exist?(@cwd = ensure_file_string(@cwd))
+
+		argv_str = build_argstr
+		raise SpawnError, "Argument string is too long. #{argv_str.size} must be less than (1 << 15)" if argv_str.size >= (1 << 15)
+		
+		raise SpawnError, "Invalid controlling tty" unless @ctty.nil? or @ctty.respond_to? :con_pty
+		
+		true
+	end
+
+	def spawn!
+		validate!
+		startupinfo = W::StartupInfo.new # ffi gem zeros memory for us
+		proc_info = W::ProcInfo.new
+		out_pid = nil
+		# set up file descriptors
+		
+		@fd_keeps.each {|fd| process_handle(fd, true) }
+		@fd_closes.each {|fd| process_handle(fd, false) }
+
+		# startup info
+		use_stdio = W::STARTF_USESTDHANDLES
+		startupinfo.dwFlags = use_stdio | @win[:reqflags] | @win[:flags]
+		if use_stdio != 0
+			startupinfo.hStdInput = handle_for(StdIn)
+			startupinfo.hStdOutput = handle_for(StdOut)
+			startupinfo.hStdError = handle_for(StdErr)
+		end
+		cap1 = startupinfo.lpDesktop = @win[:desktop].to_wstrp if @win[:desktop]
+		cap2 = startupinfo.lpTitle = @win[:title].to_wstrp if @win[:title]
+		startupinfo.wShowWindow = @win[:show] if @win[:show]
+		startupinfo.dwFillAttribute = @win[:confill] if @win[:confill]
+		if @win[:consize]
+			startupinfo.dwXCountChars, startupinfo.dwYCountChars = *@win[:consize]
+		end
+		if @win[:winsize]
+			startupinfo.dwXSize, startupinfo.dwYSize = *@win[:winsize]
+		end
+		if @win[:winpos]
+			startupinfo.dwX, startupinfo.dwY = *@win[:winpos]
+		end
+
+		# TODO: does windows have rlimits?
+
+		# TODO: allow configuring inherit handles. CRuby force this to true, so we will copy that for now
+		hndl_inheritance = true
+		sa = W::SecurityAttributes.new
+		sa.bInheritHandle = hndl_inheritance
+		
+		flags = 0
+		flags |= W::CREATE_UNICODE_ENVIRONMENT if @env != :default # ENVP
+		flags |= W::NORMAL_PRIORITY_CLASS # TODO: allow configuring priority
+		flags |= W::CREATE_NEW_PROCESS_GROUP if @pgroup
+
+
+
+		# ARGV
+		argv_str = build_argstr
+		# TODO: move this validation to validate!
+		raise SpawnError, "Argument string is too long. #{argv_str.size} must be less than (1 << 15)" if argv_str.size >= (1 << 15)
+
+		# Add extra attributes (pty)
+		numAttribs = 0
+		numAttribs +=1 if @ctty != nil
+
+		::FFI::MemoryPointer.new(:size_t, 1) do |sizeref|
+			if numAttribs == 0
+				sizeref.write(:size_t, 5)
+			else
+				W::InitializeProcThreadAttributeList(nil, numAttribs, 0, sizeref)
+			end
+			::FFI::MemoryPointer.new(:uint8_t, sizeref.read(:size_t)) do |attribList|
+
+				if numAttribs > 0 && !W::InitializeProcThreadAttributeList(attribList, numAttribs,0, sizeref)
+					raise SpawnError, "Couldn't initialize attribute list"
+				end
+				startupinfo.lpAttributeList = nil
+				if numAttribs > 0
+					flags |= W::EXTENDED_STARTUPINFO_PRESENT
+					startupinfo.lpAttributeList = attribList
+				end
+				unless @ctty.nil?
+					if !W::UpdateProcThreadAttribute(attribList, 0, W::PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE, @ctty.con_pty.raw_handle, W::SIZEOF_HPCON, nil, nil)
+						raise SpawnError, "Couldn't add pty to list"
+					end
+				end
+				# ARGP/ENV
+				envp_holder = make_envp
+					# Launch!
+					# Note that @path can be null on windows, but we will always enforce otherwise
+					ret = W.CreateProcess(
+						@path.to_wstr, # DONE
+						argv_str,  #DONE
+						sa, # proc_sec, DONE, but unexposed
+						sa, # thread_sec, DONE, but unexposed
+						hndl_inheritance, # DONE, but unexposed
+						flags, # DONE, but unexposed
+						envp_holder, # DONE
+						@cwd.to_wstr, # DONE
+						startupinfo,
+						proc_info # DONE
+					)
+					if !ret
+						# TODO: CRuby does map_errno(GetLastError()) Do we need to do that for does FFI.errno do that already?
+						raise SystemCallError.new("Spawn Error: CreateProcess: #{self.class.errno}", self.class.errno[:win])
+						# TODO: come up with a better errno
+					end
+					# Don't close the handle now, but save it in a thread-local for waitpid
+					# in case it's a quick exit
+					#W.CloseHandle(proc_info.hProcess)
+					Thread.current[:subspawn_win32hndl] = LazyHndl.new(proc_info.dwProcessId, proc_info.hProcess)
+
+					W.CloseHandle(proc_info.hThread)
+					# being a spawn clone, we don't normally expose the thread, but assign it if anyone wants it
+					@out_thread = proc_info.dwThreadId
+					out_pid = proc_info.dwProcessId
+
+					# close our half of the files
+					@fd_map.values.select{|x|x.is_a? OpenFD}.map{|x|x.ref.close; x.ref = nil}
+
+				if numAttribs > 0
+					W::DeleteProcThreadAttributeList(attribList)
+				end
+			end
+		end
+		out_pid
+	end
+	
+	# TODO: allow io on left?
+	def fd(number, io_or_fd)
+		num = number.is_a?(Symbol) ? Std[number] : number.to_i
+		raise ArgumentError, "Invalid file descriptor number: #{number}. Supported values = 0, 1, 2" unless [0,1,2].include? num
+		@fd_map[num] = io_or_fd
+		self
+	end
+
+	def fd_open(number, path, flags = 0, mode=0o666) # umask will remove bits
+		num = number.is_a?(Symbol) ? Std[number] : number.to_i
+		raise ArgumentError, "Invalid file descriptor number: #{number}. Supported values = 0.. or #{std.keys.inspect}" if num.nil?
+		@fd_opens << OpenFD.new(number, path, mode, flags)
+		self
+	end
+	def fd_keep(io_or_fd)
+		@fd_keep << io_or_fd
+		self
+	end
+	def fd_close(io_or_fd)
+		@fd_closes << io_or_fd
+		self
+	end
+	def name(string)
+		@argv[0] = string.to_s
+		self
+	end
+	alias :name= :name
+
+	def args(args)
+		@argv = [@argv[0], *args.map(&:to_str)]
+		self
+	end
+	alias :args= :args
+	def command(cmd)
+		@path = cmd
+		self
+	end
+	alias :command= :command
+
+	def env_reset!
+		@env = :default
+		self
+	end
+	def env(key, value)
+		@env = ENV.to_h.dup if @env == :default
+		@env[key.to_s] = value.to_s
+		self
+	end
+	def env=(hash)
+		@env = hash.to_h
+		self
+	end
+
+	def desktop(str)
+		@win[:desktop] = str
+		self
+	end
+	def title(str)
+		@win[:title] = str
+		self
+	end
+	def show_window(show) # TODO: translate ruby to flags
+		@win[:show] = show
+		@win[:reqflags] |= W::STARTF_USESHOWWINDOW
+		self
+	end
+	def window_pos(x,y)
+		@win[:winpos] = [x,y]
+		@win[:reqflags] |= W::STARTF_USEPOSITION
+		self
+	end
+	def window_size(w,h)
+		@win[:winsize] = [w,h]
+		@win[:reqflags] |= W::STARTF_USESIZE
+		self
+	end
+	def console_size(x,y)
+		@win[:conpos] = [x,y]
+		@win[:reqflags] |= W::STARTF_USECOUNTCHARS
+		self
+	end
+	def window_fill(attrib)
+		@win[:confill] = attrib
+		@win[:reqflags] |= W::STARTF_USEFILLATTRIBUTE
+		self
+	end
+	def start_flags(flags)
+		@win[:flags] = flags
+		self
+	end
+
+	# TODO: I don't think windows has a umask equivalent?
+#	alias :umask :umask=
+
+	def pwd(path)
+		@cwd = path
+		self
+	end
+	alias :cwd :pwd
+	alias :pwd= :cwd=
+	alias :chdir :pwd
+	alias :chdir= :cwd=
+	
+	def pgroup(isnew)
+		raise ArgumentError, "Invalid new_pgroup: #{isnew} (expecting boolean)" unless [true, false, nil, 0].include? isnew
+		@pgroup = !!isnew
+		self
+	end
+	alias :pgroup= :pgroup
+	
+	def ctty(path)
+		@ctty = path
+		self
+	end
+	alias :tty= :ctty=
+	alias :tty :ctty
+	
+	
+	def validate
+		validate! rescue false
+	end
+	
+	
+
+	# generator for candidates for an executable name
+	# usage:
+	# SubSpawn::Win32.each_which("ls", ENV) {|path| ...}
+	# SubSpawn::Win32.each_which("ls", ENV).to_a
+	# TODO: fix this!
+	def self.expand_which(name, env=ENV)
+		name = name.gsub("/","\\") # windows-ify the name
+		return self.to_enum(:expand_which, name, env) unless block_given?
+		extensions = ["", *(ENV['PATHEXT'] || "").split(';')]
+		# only allow relative paths if they traverse, and if they traverse, only allow relative paths
+		if name.include? "/"
+			extensions.each do |ext|
+				yield File.absolute_path(name + ext)
+			end
+		else
+			# If we were to follow
+			# https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessw
+			# in the path search process, we should look in CWD and dirname($0) first,
+			# and possibly the app paths registry key. Ignore for now
+			env['PATH'].split(File::PATH_SEPARATOR).each do |path|
+				extensions.each do |ext|
+					yield File.join(path, name+ext)
+				end
+			end
+		end
+	end
+
+	def self.shell_command(string)
+		# MRI scans for "basic" commands and if so, just un-expands the shell
+		# we could do that too, and there are 2 tests about that in rubyspec
+		# but we shall ignore them for now
+		# TODO: implement that
+		# https://learn.microsoft.com/en-us/archive/blogs/twistylittlepassagesallalike/everyone-quotes-command-line-arguments-the-wrong-way
+		# I think this should work, maybe?
+		["cmd.exe", "/c", string.to_str]#.gsub(/([)(%!^"><&|)])/, "^\\1")]
+	end
+
+	def self.errno
+		errno = 0
+		::FFI::MemoryPointer.new(:int, 1) do |errnoholder|
+			W.get_errno(errnoholder)
+			errno = errnoholder.read_int
+		end
+		return {win: W.GetLastError(), c: errno}
+	end
+
+	# Ruby raises EChild, so we have to reimplement wait/waitpid2
+	def self.waitpid2(pid, options=0)
+		# only support pid == -1 (any of our children), and pid > 0 for windows
+		# TODO: -1 requres keeping a list of our children that could grow to 4GiB
+		# TODO: Think that through
+		raise SubSpawn::UnimplementedError("PID <= 0 not yet implemented in subspawn-win32") if pid <= 0
+
+		# TODO: allow cross-thread support
+		last = Thread.current[:subspawn_win32hndl]
+		hndl = if last.nil? or last.pid != pid
+			last = Thread.current[:subspawn_win32hndl] = nil
+			# TODO: process_limited_information maybe?
+			W.OpenProcess(W::PROCESS_QUERY_INFORMATION, false, pid)
+		else
+			last.hndl
+		end
+		raise Errno::ECHILD.new("No child processes") if hndl == 0 || hndl == W::INVALID_HANDLE_VALUE
+
+		timeout = (options & Process::WNOHANG) != 0 ? 0 : W::INFINITE
+
+		begin
+			tmp = _single_exit_poll hndl
+			while tmp.nil? and (options & Process::WNOHANG) == 0
+				sleep 0.01 # Somehow, this still loops sometimes
+				W.WaitForSingleObject(hndl, timeout)
+				tmp = _single_exit_poll hndl
+			end
+			_set_status(if tmp.nil?
+				nil
+			else
+				if (tmp & 0xC000_0000) != 0 # if it was a windows exception
+					Process::Status.send :new, pid, nil, Signal.list[W::StatusPosixMap[tmp]]
+				else
+					Process::Status.send :new, pid, tmp, nil
+				end
+			end)
+		ensure
+			W.CloseHandle(hndl) if last.nil?
+		end
+	end
+	def self.last_status
+		@last_status
+	end
+
+	COMPLETE_VERSION = {
+		subspawn_win32: SubSpawn::Win32::VERSION,
+	}
+
+	private
+
+	def self._single_exit_poll hndl
+		# TODO: cleanup error messages
+		::FFI::MemoryPointer.new(:int, 1) do |buf|
+			# TODO: This should parsee the errno, I think?
+			raise SystemCallError.new("Waitpid Polling Failure", W::GetLastError()) unless W::GetExitCodeProcess(hndl, buf)
+			tmp = buf.read(:int)
+			return tmp == W::STILL_ACTIVE ? nil : tmp
+		end
+	end
+	def self._set_status status
+		EngineHacks.child_status = status
+		@last_status = status
+		return status.nil? ? nil : [status.pid, status]
+	end
+
+	def none
+		@@none ||= Object.new
+	end
+
+	def make_envp
+		if @env == :default
+			return nil # weirdly easy on windows
+		else
+			strings = @env.select{|k, v|
+				!k.nil? and !v.nil?
+			}.map{|k,v|
+				k = k.to_str
+				str = "#{k}=#{v.to_str}"  # rubyspec says to convert to_str
+				raise ArgumentError, "Nulls not allowed in environment variable: #{str.inspect}" if str.include? "\0" # By Spec
+				raise ArgumentError, "Variable key cannot include '=': #{str.inspect}" if k.include? "=" # By Spec
+				"#{str}\0"
+			}.join("") + "\0" # null end of argp
+			return strings.to_wstr
+		end
+	end
+	def build_argstr
+		# TODO: quote this way, or are other characters 
+		@argv.map{|a|
+			raise ArgumentError, "Nulls not allowed in command: #{a.inspect}" if a.include? "\0"
+			quote_arg(a)
+		}.join(" ").to_wstr
+	end
+	# windows quoting is horrible and not consistent
+	# TODO: test this throughly
+	# https://stackoverflow.com/questions/31838469/how-do-i-convert-argv-to-lpcommandline-parameter-of-createprocess
+	def quote_arg(str)
+		# if no whitespace or quote characters, this is a "simple" argument
+		return str unless str =~ /[ \t\n\v"]/ # TODO: no \r?
+		backslashes = nil
+		base = str.each_char.map do |c|
+			if c != "\\"
+				if backslashes.nil? # we are just a lone character
+					c
+				else # we are terminating a backslash sequence
+					if c == '"'
+						backslashes + backslashes + "\\" + c # double escape
+					else
+						backslashes + c # no escaping necessary (UNC path, etc)
+					end.tap{ backslashes = nil } # clear saved escapes
+				end
+			else
+				backslashes << c
+			end
+		end.join("")
+		%Q{"#{base}#{backslashes}#{backslashes}"} # A quote goes next, so double escape again
+	end
+	def handle_for(fdi)
+		mapped = @fd_map[fdi] || fdi
+		if mapped.is_a? OpenFD
+			mapped.ref = File.new(mapped.path, mapped.flags, mapped.mode)
+			mapped = mapped.ref.fileno
+		end
+		hndl = fd2handle(mapped)
+
+		if hndl == W::INVALID_HANDLE_VALUE || hndl == W::HANDLE_NEGATIVE_TWO
+			if @fd_map.nil?
+				hndl = W.GetStdHandle(W::STD_HANDLE[fdi])
+			else
+				raise SystemCallError.new("Invalid FD/handle for input fd #{fdi}", FFI.errno)
+			end
+		end
+		# ensure the handle is inheritable
+		res = W.SetHandleInformation(hndl, W::HANDLE_FLAG_INHERIT, W::HANDLE_FLAG_INHERIT)
+		raise SystemCallError.new("Non-inheritable handle for input fd #{fdi} (#{self.class.errno})") unless res
+
+		#puts "stdio[#{fdi}] = #{@fd_map[fdi]} => #{fd} => #{hndl} (#{res})"
+		hndl
+	end
+
+	def process_handle(fdo, share)
+		hndl = fd2handle(fdo)
+
+		if hndl == W::INVALID_HANDLE_VALUE || hndl == W::HANDLE_NEGATIVE_TWO
+			raise SystemCallError.new("Invalid FD/handle for keep/close")
+		end
+		# ensure the handle is inheritable
+		res = W.SetHandleInformation(hndl, W::HANDLE_FLAG_INHERIT, share ? W::HANDLE_FLAG_INHERIT : 0)
+		raise SystemCallError.new("Couldn't change handle inheritance (#{self.class.errno})") unless res
+		hndl
+	end
+
+	def ensure_file_string(path)
+		if defined? JRUBY_VERSION # accept File and Path java objects
+			path = path.to_file if path.respond_to? :to_file
+			if path.respond_to? :absolute_path
+				path.absoloute_path
+			else
+				path.to_s
+			end
+		else
+			path.to_s
+		end
+	end
+	def fd_check(source)
+		case source
+		when Integer then source
+		when IO then source
+		when :in, :out, :err
+			Std[source]
+		else
+			raise SpawnError, "Invalid FD map: Not a io or number: #{source.inspect}"
+		end
+	end
+	def fd_number(source)
+		case source
+		when Integer then source
+		when IO then source.fileno
+		when :in, :out, :err
+			Std[source]
+		else
+			raise SpawnError, "Invalid FD map: Not a io or number: #{source.inspect}"
+		end
+	end
+	def fd2handle(fdo)
+		if RUBY_ENGINE == "jruby" && ((fdo.is_a?(IO) && !fdo.is_a?(File)) || (fdo.is_a? Integer and fdo > 9)) # handles are (usually?) greater than 9
+			tmp = fd_number(fdo) # JRuby IO.pipe.fileno returns a proper handle!
+		else
+			W.get_osfhandle(fd_number(fdo))
+		end
+	end
+
+end
+end
+
+require 'subspawn/win32/lazy-hndl'

data/subspawn-win32.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "lib/subspawn/win32/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "subspawn-win32"
+  spec.version = SubSpawn::Win32::VERSION
+  spec.authors = ["Patrick Plenefisch"]
+  spec.email = ["simonpatp@gmail.com"]
+
+  spec.summary = "SubSpawn Mid-level API for Windows systems"
+  spec.description = "A SubSpawn subproject to wrap Win32 as a mid level API"
+  final_github = "https://github.com/byteit101/subspawn"
+  spec.homepage = final_github
+  spec.required_ruby_version = ">= 2.6.0"
+
+  #spec.metadata["allowed_push_host"] = "TODO: Set to your gem server 'https://example.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = final_github
+  spec.metadata["changelog_uri"] = final_github
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "subspawn-common", "~> 0.2.0.pre1"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+
+  # You can use Ruby's license, or any of the JRuby tri-license options
+  spec.licenses = ["Ruby", "EPL-2.0", "LGPL-2.1-or-later"]
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: subspawn-win32
+version: !ruby/object:Gem::Version
+  version: 0.2.0.pre1
+platform: ruby
+authors:
+- Patrick Plenefisch
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-05-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: subspawn-common
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0.pre1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0.pre1
+description: A SubSpawn subproject to wrap Win32 as a mid level API
+email:
+- simonpatp@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- Gemfile
+- README.md
+- Rakefile
+- lib/subspawn/win32.rb
+- lib/subspawn/win32/ffi.rb
+- lib/subspawn/win32/lazy-hndl.rb
+- lib/subspawn/win32/pty.rb
+- lib/subspawn/win32/raw_status.rb
+- lib/subspawn/win32/version.rb
+- subspawn-win32.gemspec
+homepage: https://github.com/byteit101/subspawn
+licenses:
+- Ruby
+- EPL-2.0
+- LGPL-2.1-or-later
+metadata:
+  homepage_uri: https://github.com/byteit101/subspawn
+  source_code_uri: https://github.com/byteit101/subspawn
+  changelog_uri: https://github.com/byteit101/subspawn
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: SubSpawn Mid-level API for Windows systems
+test_files: []