win32-process 0.6.6 → 0.7.0

data/lib/win32/process.rb

@@ -1,1143 +1,881 @@
-require 'windows/error'
-require 'windows/process'
-require 'windows/thread'
-require 'windows/synchronize'
-require 'windows/handle'
-require 'windows/library'
-require 'windows/console'
-require 'windows/window'
-require 'windows/unicode'
-require 'windows/tool_helper'
-require 'windows/security'
-require 'windows/msvcrt/string'
+require File.join(File.expand_path(File.dirname(__FILE__)), 'process', 'functions')
+require File.join(File.expand_path(File.dirname(__FILE__)), 'process', 'constants')
+require File.join(File.expand_path(File.dirname(__FILE__)), 'process', 'structs')
+require File.join(File.expand_path(File.dirname(__FILE__)), 'process', 'helper')
 
-module Process
-  # The Process::Error class is typically raised if any of the custom
-  # Process methods fail.
-  class Error < RuntimeError; end
-
-  # Eliminates redefinition warnings.
-  undef_method :getpriority, :kill, :getrlimit, :ppid, :setrlimit
-  undef_method :setpriority, :wait, :wait2, :waitpid, :waitpid2, :uid
-
-  # The version of the win32-process library
-  WIN32_PROCESS_VERSION = '0.6.6'
-
-  # Defined for interface compatibility, but not used
-
-  PRIO_PROCESS = 0
-  PRIO_PGRP    = 1
-  PRIO_USER    = 2
-
-  include Windows::Process
-  include Windows::Thread
-  include Windows::Error
-  include Windows::Library
-  include Windows::Console
-  include Windows::Handle
-  include Windows::Security
-  include Windows::Synchronize
-  include Windows::Window
-  include Windows::Unicode
-  include Windows::ToolHelper
-  include Windows::MSVCRT::String
-
-  extend Windows::Error
-  extend Windows::Process
-  extend Windows::Thread
-  extend Windows::Security
-  extend Windows::Synchronize
-  extend Windows::Handle
-  extend Windows::Library
-  extend Windows::Console
-  extend Windows::Unicode
-  extend Windows::ToolHelper
-  extend Windows::MSVCRT::String
-
-  # :stopdoc:
-
-  # Used by Process.create
-  ProcessInfo = Struct.new("ProcessInfo",
-    :process_handle,
-    :thread_handle,
-    :process_id,
-    :thread_id
-  )
-
-  @child_pids = []  # Static variable used for Process.fork
-  @i = -1           # Static variable used for Process.fork
-
-  # These are probably not defined on MS Windows by default
-  unless defined? RLIMIT_CPU
-    RLIMIT_CPU    = 0 # PerProcessUserTimeLimit
-    RLIMIT_FSIZE  = 1 # Hard coded at 4TB - 64K (assumes NTFS)
-    RLIMIT_AS     = 5 # ProcessMemoryLimit
-    RLIMIT_RSS    = 5 # ProcessMemoryLimit
-    RLIMIT_VMEM   = 5 # ProcessMemoryLimit
-  end
 
-  # :startdoc:
-
-  # Returns the process and system affinity mask for the given +pid+, or the
-  # current process if no pid is provided. The return value is a two element
-  # array, with the first containing the process affinity mask, and the second
-  # containing the system affinity mask. Both are decimal values.
-  #
-  # A process affinity mask is a bit vector indicating the processors that a
-  # process is allowed to run on. A system affinity mask is a bit vector in
-  # which each bit represents the processors that are configured into a
-  # system.
-  #
-  # Example:
-  #
-  #    # System has 4 processors, current process is allowed to run on all
-  #    Process.get_affinity # => [[15], [15]]
-  #
-  #    # System has 4 processors, current process only allowed on 1 and 4 only
-  #    Process.get_affinity # => [[9], [15]]
-  #
-  # If you want to convert a decimal bit vector into an array of 0's and 1's
-  # indicating the flag value of each processor, you can use something like
-  # this approach:
-  #
-  #    mask = Process.get_affinity.first
-  #    (0..mask).to_a.map{ |n| mask[n] }
-  #
-  def get_affinity(int = Process.pid)
-    pmask = 0.chr * 4
-    smask = 0.chr * 4
-
-    if int == Process.pid
-      unless GetProcessAffinityMask(GetCurrentProcess(), pmask, smask)
-        raise Error, get_last_error
-      end
-    else
-      begin
-        handle = OpenProcess(PROCESS_QUERY_INFORMATION, 0 , int)
-
-        if handle == INVALID_HANDLE_VALUE
-          raise Error, get_last_error
+module Process
+  include Process::Constants
+  extend Process::Functions
+  extend Process::Structs
+  extend Process::Constants
+
+  WIN32_PROCESS_VERSION = '0.7.0'
+
+  # Disable popups. This mostly affects the Process.kill method.
+  SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX)
+
+  class << self
+    # Returns whether or not the current process is part of a Job (process group).
+    def job?
+      pbool = FFI::MemoryPointer.new(:int)
+      IsProcessInJob(GetCurrentProcess(), nil, pbool)
+      pbool.read_int == 1 ? true : false
+    end
+
+    # Returns the process and system affinity mask for the given +pid+, or the
+    # current process if no pid is provided. The return value is a two element
+    # array, with the first containing the process affinity mask, and the second
+    # containing the system affinity mask. Both are decimal values.
+    #
+    # A process affinity mask is a bit vector indicating the processors that a
+    # process is allowed to run on. A system affinity mask is a bit vector in
+    # which each bit represents the processors that are configured into a
+    # system.
+    #
+    # Example:
+    #
+    #    # System has 4 processors, current process is allowed to run on all
+    #    Process.get_affinity # => [[15], [15]], where '15' is 1 + 2 + 4 + 8
+    #
+    #    # System has 4 processors, current process only allowed on 1 and 4 only
+    #    Process.get_affinity # => [[9], [15]]
+    #
+    # If you want to convert a decimal bit vector into an array of 0's and 1's
+    # indicating the flag value of each processor, you can use something like
+    # this approach:
+    #
+    #    mask = Process.get_affinity.first
+    #    (0..mask).to_a.map{ |n| mask[n] }
+    #
+    def get_affinity(int = Process.pid)
+      pmask = FFI::MemoryPointer.new(:ulong)
+      smask = FFI::MemoryPointer.new(:ulong)
+
+      if int == Process.pid
+        unless GetProcessAffinityMask(GetCurrentProcess(), pmask, smask)
+          raise SystemCallError, FFI.errno, "GetProcessAffinityMask"
         end
+      else
+        begin
+          handle = OpenProcess(PROCESS_QUERY_INFORMATION, 0 , int)
 
-        unless GetProcessAffinityMask(handle, pmask, smask)
-          raise Error, get_last_error
+          if handle == INVALID_HANDLE_VALUE
+            raise SystemCallError, FFI.errno, "OpeProcess"
+          end
+
+          unless GetProcessAffinityMask(handle, pmask, smask)
+            raise SystemCallError, FFI.errno, "GetProcessAffinityMask"
+          end
+        ensure
+          CloseHandle(handle)
         end
-      ensure
-        CloseHandle(handle) if handle != INVALID_HANDLE_VALUE
       end
+
+      [pmask.read_ulong, smask.read_ulong]
     end
 
-    pmask = pmask.unpack('L').first
-    smask = smask.unpack('L').first
+    remove_method :getpriority
 
-    [pmask, smask]
-  end
+    # Retrieves the priority class for the specified process id +int+. Unlike
+    # the default implementation, lower return values do not necessarily
+    # correspond to higher priority classes.
+    #
+    # The +kind+ parameter is ignored but required for API compatibility.
+    # You can only retrieve process information, not process group or user
+    # information, so it is effectively always Process::PRIO_PROCESS.
+    #
+    # Possible return values are:
+    #
+    # 32    => Process::NORMAL_PRIORITY_CLASS
+    # 64    => Process::IDLE_PRIORITY_CLASS
+    # 128   => Process::HIGH_PRIORITY_CLASS
+    # 256   => Process::REALTIME_PRIORITY_CLASS
+    # 16384 => Process::BELOW_NORMAL_PRIORITY_CLASS
+    # 32768 => Process::ABOVE_NORMAL_PRIORITY_CLASS
+    #
+    def getpriority(kind, int)
+      raise TypeError, kind unless kind.is_a?(Fixnum) # Match spec
+      raise TypeError, int unless int.is_a?(Fixnum)   # Match spec
+      int = Process.pid if int == 0                   # Match spec
 
-  # Returns whether or not the current process is part of a Job.
-  #
-  def job?
-    pbool = 0.chr * 4
-    IsProcessInJob(GetCurrentProcess(), nil, pbool)
-    pbool.unpack('L').first == 0 ? false : true
-  end
+      handle = OpenProcess(PROCESS_QUERY_INFORMATION, false, int)
 
-  # Gets the resource limit of the current process. Only a limited number
-  # of flags are supported.
-  #
-  # Process::RLIMIT_CPU
-  # Process::RLIMIT_FSIZE
-  # Process::RLIMIT_AS
-  # Process::RLIMIT_RSS
-  # Process::RLIMIT_VMEM
-  #
-  # The Process:RLIMIT_AS, Process::RLIMIT_RSS and Process::VMEM constants
-  # all refer to the Process memory limit. The Process::RLIMIT_CPU constant
-  # refers to the per process user time limit. The Process::RLIMIT_FSIZE
-  # constant is hard coded to the maximum file size on an NTFS filesystem,
-  # approximately 4TB (or 4GB if not NTFS).
-  #
-  # While a two element array is returned in order to comply with the spec,
-  # there is no separate hard and soft limit. The values will always be the
-  # same.
-  #
-  # If [0,0] is returned then it means no limit has been set.
-  #
-  # Example:
-  #
-  #   Process.getrlimit(Process::RLIMIT_VMEM) # => [0, 0]
-  #--
-  # NOTE: Both the getrlimit and setrlimit method use an at_exit handler
-  # to close a job handle. This is necessary because simply calling it
-  # at the end of the block, while marking it for closure, would also make
-  # it unavailable even within the same process since it would no longer
-  # be associated with the job.
-  #
-  def getrlimit(resource)
-    if resource == RLIMIT_FSIZE
-      if get_volume_type == 'NTFS'
-        return ((1024**4) * 4) - (1024 * 64) # ~4 TB
-      else
-        return (1024**3) * 4 # 4 GB
+      if handle == INVALID_HANDLE_VALUE
+        raise SystemCallError, FFI.errno, "OpenProcess"
       end
-    end
 
-    handle = nil
-    in_job = Process.job?
-
-    # Put the current process in a job if it's not already in one
-    if in_job && defined?(@job_name)
-      handle = OpenJobObject(JOB_OBJECT_QUERY, true, @job_name)
-      raise Error, get_last_error if handle == 0
-    else
-      @job_name = 'ruby_' + Process.pid.to_s
-      handle = CreateJobObject(nil, @job_name)
-      raise Error, get_last_error if handle == 0
-    end
+      begin
+        priority = GetPriorityClass(handle)
 
-    begin
-      unless in_job
-        unless AssignProcessToJobObject(handle, GetCurrentProcess())
-          raise Error, get_last_error
+        if priority == 0
+          raise SystemCallError, FFI.errno, "GetPriorityClass"
         end
+      ensure
+        CloseHandle(handle)
       end
 
-      buf = 0.chr * 112 # sizeof(struct JOBJECT_EXTENDED_LIMIT_INFORMATION)
-      val = nil         # value returned at end of method
+      priority
+    end
 
-      # Set the LimitFlags member of the struct
-      case resource
-        when RLIMIT_CPU
-          buf[16,4] = [JOB_OBJECT_LIMIT_PROCESS_TIME].pack('L')
-        when RLIMIT_AS, RLIMIT_VMEM, RLIMIT_RSS
-          buf[16,4] = [JOB_OBJECT_LIMIT_PROCESS_MEMORY].pack('L')
-        else
-          raise Error, "unsupported resource type"
-      end
+    remove_method :setpriority
 
-      bool = QueryInformationJobObject(
-        handle,
-        JobObjectExtendedLimitInformation,
-        buf,
-        buf.size,
-        nil
-      )
+    # Sets the priority class for the specified process id +int+.
+    #
+    # The +kind+ parameter is ignored but present for API compatibility.
+    # You can only retrieve process information, not process group or user
+    # information, so it is effectively always Process::PRIO_PROCESS.
+    #
+    # Possible +int_priority+ values are:
+    #
+    # * Process::NORMAL_PRIORITY_CLASS
+    # * Process::IDLE_PRIORITY_CLASS
+    # * Process::HIGH_PRIORITY_CLASS
+    # * Process::REALTIME_PRIORITY_CLASS
+    # * Process::BELOW_NORMAL_PRIORITY_CLASS
+    # * Process::ABOVE_NORMAL_PRIORITY_CLASS
+    #
+    def setpriority(kind, int, int_priority)
+      raise TypeError unless kind.is_a?(Integer)          # Match spec
+      raise TypeError unless int.is_a?(Integer)           # Match spec
+      raise TypeError unless int_priority.is_a?(Integer)  # Match spec
+      int = Process.pid if int == 0                       # Match spec
 
-      unless bool
-        raise Error, get_last_error
+      handle = OpenProcess(PROCESS_SET_INFORMATION, false , int)
+
+      if handle == INVALID_HANDLE_VALUE
+        raise SystemCallError, FFI.errno, "OpenProcess"
       end
 
-      case resource
-        when Process::RLIMIT_CPU
-          val = buf[0,8].unpack('Q').first
-        when RLIMIT_AS, RLIMIT_VMEM, RLIMIT_RSS
-          val = buf[96,4].unpack('L').first
+      begin
+        unless SetPriorityClass(handle, int_priority)
+          raise SystemCallError, FFI.errno, "SetPriorityClass"
+        end
+      ensure
+        CloseHandle(handle)
       end
-    ensure
-      at_exit{ CloseHandle(handle) if handle }
+
+      return 0 # Match the spec
     end
 
-    [val, val] # Return an array of two values to comply with spec
-  end
+    remove_method :uid
 
-  # Sets the resource limit of the current process. Only a limited number
-  # of flags are supported.
-  #
-  # Process::RLIMIT_CPU
-  # Process::RLIMIT_AS
-  # Process::RLIMIT_RSS
-  # Process::RLIMIT_VMEM
-  #
-  # The Process:RLIMIT_AS, Process::RLIMIT_RSS and Process::VMEM constants
-  # all refer to the Process memory limit. The Process::RLIMIT_CPU constant
-  # refers to the per process user time limit.
-  #
-  # The +max_limit+ parameter is provided for interface compatibility only.
-  # It is always set to the current_limit value.
-  #
-  # Example:
-  #
-  #   Process.setrlimit(Process::RLIMIT_VMEM, 1024 * 4) # => nil
-  #   Process.getrlimit(Process::RLIMIT_VMEM) # => [4096, 4096]
-  #
-  def setrlimit(resource, current_limit, max_limit = nil)
-    max_limit = current_limit
-
-    handle = nil
-    in_job = Process.job?
-
-    # Put the current process in a job if it's not already in one
-    if in_job && defined? @job_name
-      handle = OpenJobObject(JOB_OBJECT_SET_ATTRIBUTES, true, @job_name)
-      raise Error, get_last_error if handle == 0
-    else
-      @job_name = 'ruby_' + Process.pid.to_s
-      handle = CreateJobObject(nil, job_name)
-      raise Error, get_last_error if handle == 0
-    end
+    # Returns the uid of the current process. Specifically, it returns the
+    # RID of the SID associated with the owner of the process.
+    #
+    # If +sid+ is set to true, then a binary sid is returned. Otherwise, a
+    # numeric id is returned (the default).
+    #--
+    # The Process.uid method in core Ruby always returns 0 on MS Windows.
+    #
+    def uid(sid = false)
+      token = FFI::MemoryPointer.new(:ulong)
 
-    begin
-      unless in_job
-        unless AssignProcessToJobObject(handle, GetCurrentProcess())
-          raise Error, get_last_error
-        end
-      end
+      raise TypeError unless sid.is_a?(TrueClass) || sid.is_a?(FalseClass)
 
-      # sizeof(struct JOBJECT_EXTENDED_LIMIT_INFORMATION)
-      buf = 0.chr * 112
-
-      # Set the LimitFlags and relevant members of the struct
-      case resource
-        when RLIMIT_CPU
-          buf[16,4] = [JOB_OBJECT_LIMIT_PROCESS_TIME].pack('L')
-          buf[0,8]  = [max_limit].pack('Q') # PerProcessUserTimeLimit
-        when RLIMIT_AS, RLIMIT_VMEM, RLIMIT_RSS
-          buf[16,4] = [JOB_OBJECT_LIMIT_PROCESS_MEMORY].pack('L')
-          buf[96,4] = [max_limit].pack('L') # ProcessMemoryLimit
-        else
-          raise Error, "unsupported resource type"
+      unless OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, token)
+        raise SystemCallError, FFI.errno, "OpenProcessToken"
       end
 
-      bool = SetInformationJobObject(
-        handle,
-        JobObjectExtendedLimitInformation,
-        buf,
-        buf.size
+      token   = token.read_ulong
+      rlength = FFI::MemoryPointer.new(:ulong)
+      tuser   = 0.chr * 512
+
+      bool = GetTokenInformation(
+        token,
+        TokenUser,
+        tuser,
+        tuser.size,
+        rlength
       )
 
       unless bool
-        raise Error, get_last_error
+        raise SystemCallError, FFI.errno, "GetTokenInformation"
       end
-    ensure
-      at_exit{ CloseHandle(handle) if handle }
-    end
-  end
 
-  # Retrieves the priority class for the specified process id +int+. Unlike
-  # the default implementation, lower return values do not necessarily
-  # correspond to higher priority classes.
-  #
-  # The +kind+ parameter is ignored but required for API compatibility.
-  # You can only retrieve process information, not process group or user
-  # information, so it is effectively always Process::PRIO_PROCESS.
-  #
-  # Possible return values are:
-  #
-  # 32    - Process::NORMAL_PRIORITY_CLASS
-  # 64    - Process::IDLE_PRIORITY_CLASS
-  # 128   - Process::HIGH_PRIORITY_CLASS
-  # 256   - Process::REALTIME_PRIORITY_CLASS
-  # 16384 - Process::BELOW_NORMAL_PRIORITY_CLASS
-  # 32768 - Process::ABOVE_NORMAL_PRIORITY_CLASS
-  #
-  def getpriority(kind, int)
-    raise TypeError unless kind.is_a?(Integer)
-    raise TypeError unless int.is_a?(Integer)
-
-    int = Process.pid if int == 0 # Match spec
-
-    handle = OpenProcess(PROCESS_QUERY_INFORMATION, 0 , int)
-
-    if handle == INVALID_HANDLE_VALUE
-      raise Error, get_last_error
-    end
+      string_sid = tuser[8, (rlength.read_ulong - 8)]
 
-    begin
-      priority_class = GetPriorityClass(handle)
+      if sid
+        string_sid
+      else
+        psid = FFI::MemoryPointer.new(:ulong)
 
-      if priority_class == 0
-        raise Error, get_last_error
-      end
-    ensure
-      CloseHandle(handle)
-    end
+        unless ConvertSidToStringSidA(string_sid, psid)
+          raise SystemCallError, FFI.errno, "ConvertSidToStringSid"
+        end
 
-    priority_class
-  end
+        psid.read_pointer.read_string.split('-').last.to_i
+      end
+    end
+
+    remove_method :getrlimit
+
+    # Gets the resource limit of the current process. Only a limited number
+    # of flags are supported.
+    #
+    # Process::RLIMIT_CPU
+    # Process::RLIMIT_FSIZE
+    # Process::RLIMIT_AS
+    # Process::RLIMIT_RSS
+    # Process::RLIMIT_VMEM
+    #
+    # The Process:RLIMIT_AS, Process::RLIMIT_RSS and Process::VMEM constants
+    # all refer to the Process memory limit. The Process::RLIMIT_CPU constant
+    # refers to the per process user time limit. The Process::RLIMIT_FSIZE
+    # constant is hard coded to the maximum file size on an NTFS filesystem,
+    # approximately 4TB (or 4GB if not NTFS).
+    #
+    # While a two element array is returned in order to comply with the spec,
+    # there is no separate hard and soft limit. The values will always be the
+    # same.
+    #
+    # If [0,0] is returned then it means no limit has been set.
+    #
+    # Example:
+    #
+    #   Process.getrlimit(Process::RLIMIT_VMEM) # => [0, 0]
+    #--
+    # NOTE: Both the getrlimit and setrlimit method use an at_exit handler
+    # to close a job handle. This is necessary because simply calling it
+    # at the end of the block, while marking it for closure, would also make
+    # it unavailable within the same process again since it would no longer
+    # be associated with the job. In other words, trying to call it more than
+    # once within the same program would fail.
+    #
+    def getrlimit(resource)
+      if resource == RLIMIT_FSIZE
+        if volume_type == 'NTFS'
+          return ((1024**4) * 4) - (1024 * 64) # ~ 4TB
+        else
+          return (1024**3) * 4 # 4 GB
+        end
+      end
 
-  # Sets the priority class for the specified process id +int+.
-  #
-  # The +kind+ parameter is ignored but present for API compatibility.
-  # You can only retrieve process information, not process group or user
-  # information, so it is effectively always Process::PRIO_PROCESS.
-  #
-  # Possible +int_priority+ values are:
-  #
-  # * Process::NORMAL_PRIORITY_CLASS
-  # * Process::IDLE_PRIORITY_CLASS
-  # * Process::HIGH_PRIORITY_CLASS
-  # * Process::REALTIME_PRIORITY_CLASS
-  # * Process::BELOW_NORMAL_PRIORITY_CLASS
-  # * Process::ABOVE_NORMAL_PRIORITY_CLASS
-  #
-  def setpriority(kind, int, int_priority)
-    raise TypeError unless kind.is_a?(Integer)
-    raise TypeError unless int.is_a?(Integer)
-    raise TypeError unless int_priority.is_a?(Integer)
-
-    int = Process.pid if int == 0 # Match spec
-
-    handle = OpenProcess(PROCESS_SET_INFORMATION, 0 , int)
-
-    if handle == INVALID_HANDLE_VALUE
-      raise Error, get_last_error
-    end
+      handle = nil
+      in_job = Process.job?
 
-    begin
-      unless SetPriorityClass(handle, int_priority)
-        raise Error, get_last_error
+      # Put the current process in a job if it's not already in one
+      if in_job && defined?(@win32_process_job_name)
+        handle = OpenJobObjectA(JOB_OBJECT_QUERY, true, @win32_process_job_name)
+        raise SystemCallError, FFI.errno, "OpenJobObject" if handle == 0
+      else
+        @win32_process_job_name = 'ruby_' + Process.pid.to_s
+        handle = CreateJobObjectA(nil, @win32_process_job_name)
+        raise SystemCallError, FFI.errno, "CreateJobObject" if handle == 0
       end
-    ensure
-      CloseHandle(handle)
-    end
-
-    return 0 # Match the spec
-  end
 
-  # Returns the uid of the current process. Specifically, it returns the
-  # RID of the SID associated with the owner of the process.
-  #
-  # If +sid+ is set to true, then a binary sid is returned. Otherwise, a
-  # numeric id is returned (the default).
-  #--
-  # The Process.uid method in core Ruby always returns 0 on MS Windows.
-  #
-  def uid(sid = false)
-    token = 0.chr * 4
-
-    raise TypeError unless sid.is_a?(TrueClass) || sid.is_a?(FalseClass)
-
-    unless OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, token)
-      raise Error, get_last_error
-    end
+      begin
+        unless in_job
+          unless AssignProcessToJobObject(handle, GetCurrentProcess())
+            raise Error, get_last_error
+          end
+        end
 
-    token   = token.unpack('V')[0]
-    rlength = 0.chr * 4
-    tuser   = 0.chr * 512
+        ptr = JOBJECT_EXTENDED_LIMIT_INFORMATION.new
+        val = nil
 
-    bool = GetTokenInformation(
-      token,
-      TokenUser,
-      tuser,
-      tuser.size,
-      rlength
-    )
+        # Set the LimitFlags member of the struct
+        case resource
+          when RLIMIT_CPU
+            ptr[:BasicLimitInformation][:LimitFlags] = JOB_OBJECT_LIMIT_PROCESS_TIME
+          when RLIMIT_AS, RLIMIT_VMEM, RLIMIT_RSS
+            ptr[:BasicLimitInformation][:LimitFlags] = JOB_OBJECT_LIMIT_PROCESS_MEMORY
+          else
+            raise ArgumentError, "unsupported resource type: '#{resource}'"
+        end
 
-    unless bool
-      raise Error, get_last_error
-    end
+        bool = QueryInformationJobObject(
+          handle,
+          JobObjectExtendedLimitInformation,
+          ptr,
+          ptr.size,
+          nil
+        )
 
-    lsid = tuser[8, (rlength.unpack('L').first - 8)]
+        unless bool
+          raise SystemCallError, FFI.errno, "QueryInformationJobObject"
+        end
 
-    if sid
-      lsid
-    else
-      sid_addr = [lsid].pack('p*').unpack('L')[0]
-      sid_buf  = 0.chr * 80
-      sid_ptr  = 0.chr * 4
+        case resource
+          when Process::RLIMIT_CPU
+            val = ptr[:BasicLimitInformation][:PerProcessUserTimeLimit][:QuadPart]
+          when RLIMIT_AS, RLIMIT_VMEM, RLIMIT_RSS
+            val = ptr[:ProcessMemoryLimit]
+        end
 
-      unless ConvertSidToStringSid(sid_addr, sid_ptr)
-        raise Error, get_last_error
+      ensure
+        at_exit{ CloseHandle(handle) if handle }
+      end
+
+      [val, val]
+    end
+
+    remove_method :setrlimit
+
+    # Sets the resource limit of the current process. Only a limited number
+    # of flags are supported.
+    #
+    # Process::RLIMIT_CPU
+    # Process::RLIMIT_AS
+    # Process::RLIMIT_RSS
+    # Process::RLIMIT_VMEM
+    #
+    # The Process:RLIMIT_AS, Process::RLIMIT_RSS and Process::VMEM constants
+    # all refer to the Process memory limit. The Process::RLIMIT_CPU constant
+    # refers to the per process user time limit.
+    #
+    # The +max_limit+ parameter is provided for interface compatibility only.
+    # It is always set to the current_limit value.
+    #
+    # Example:
+    #
+    #   Process.setrlimit(Process::RLIMIT_VMEM, 1024 * 4) # => nil
+    #   Process.getrlimit(Process::RLIMIT_VMEM) # => [4096, 4096]
+    #
+    def setrlimit(resource, current_limit, max_limit = nil)
+      max_limit = current_limit
+
+      handle = nil
+      in_job = Process.job?
+
+      unless [RLIMIT_AS, RLIMIT_VMEM, RLIMIT_RSS, RLIMIT_CPU].include?(resource)
+        raise ArgumentError, "unsupported resource type: '#{resource}'"
+      end
+
+      # Put the current process in a job if it's not already in one
+      if in_job && defined? @win32_process_job_name
+        handle = OpenJobObjectA(JOB_OBJECT_SET_ATTRIBUTES, true, @win32_process_job_name)
+        raise SystemCallError, FFI.errno, "OpenJobObject" if handle == 0
+      else
+        @job_name = 'ruby_' + Process.pid.to_s
+        handle = CreateJobObjectA(nil, job_name)
+        raise SystemCallError, FFI.errno, "CreateJobObject" if handle == 0
       end
 
-      strcpy(sid_buf, sid_ptr.unpack('L')[0])
-      sid_buf.strip.split('-').last.to_i
-    end
-  end
-
-  # Waits for the given child process to exit and returns that pid.
-  #
-  # The +flags+ argument is ignored at the moment. It is provided strictly
-  # for interface compatibility.
-  #
-  # Note that the $? (Process::Status) global variable is NOT set.  This
-  # may be addressed in a future release.
-  #
-  def waitpid(pid, flags = nil)
-    exit_code = [0].pack('L')
-    handle = OpenProcess(PROCESS_ALL_ACCESS, 0, pid)
-
-    if handle == INVALID_HANDLE_VALUE
-      raise Error, get_last_error
-    end
+      begin
+        unless in_job
+          unless AssignProcessToJobObject(handle, GetCurrentProcess())
+            raise SystemCallError, FFI.errno, "AssignProcessToJobObject"
+          end
+        end
 
-    # TODO: update the $? global variable (if/when possible)
-    status = WaitForSingleObject(handle, INFINITE)
+        ptr = JOBJECT_EXTENDED_LIMIT_INFORMATION.new
 
-    begin
-      unless GetExitCodeProcess(handle, exit_code)
-        raise Error, get_last_error
-      end
-    ensure
-      CloseHandle(handle)
-    end
+        # Set the LimitFlags and relevant members of the struct
+        if resource == RLIMIT_CPU
+          ptr[:BasicLimitInformation][:LimitFlags] = JOB_OBJECT_LIMIT_PROCESS_TIME
+          ptr[:BasicLimitInformation][:PerProcessUserTimeLimit][:QuadPart] = max_limit
+        else
+          ptr[:BasicLimitInformation][:LimitFlags] = JOB_OBJECT_LIMIT_PROCESS_MEMORY
+          ptr[:ProcessMemoryLimit] = max_limit
+        end
 
-    @child_pids.delete(pid)
+        bool = SetInformationJobObject(
+          handle,
+          JobObjectExtendedLimitInformation,
+          ptr,
+          ptr.size
+        )
 
-    # TODO: update the $? global variable (if/when possible)
-    exit_code = exit_code.unpack('L').first
+        unless bool
+          raise SystemCallError, FFI.errno, "SetInformationJobObject"
+        end
+      ensure
+        at_exit{ CloseHandle(handle) if handle }
+      end
+    end
+
+    # Process.create(key => value, ...) => ProcessInfo
+    #
+    # This is a wrapper for the CreateProcess() function. It executes a process,
+    # returning a ProcessInfo struct. It accepts a hash as an argument.
+    # There are several primary keys:
+    #
+    # * command_line     (this or app_name must be present)
+    # * app_name         (default: nil)
+    # * inherit          (default: false)
+    # * process_inherit  (default: false)
+    # * thread_inherit   (default: false)
+    # * creation_flags   (default: 0)
+    # * cwd              (default: Dir.pwd)
+    # * startup_info     (default: nil)
+    # * environment      (default: nil)
+    # * close_handles    (default: true)
+    # * with_logon       (default: nil)
+    # * domain           (default: nil)
+    # * password         (default: nil, mandatory if with_logon)
+    #
+    # Of these, the 'command_line' or 'app_name' must be specified or an
+    # error is raised. Both may be set individually, but 'command_line' should
+    # be preferred if only one of them is set because it does not (necessarily)
+    # require an explicit path or extension to work.
+    #
+    # The 'domain' and 'password' options are only relevent in the context
+    # of 'with_logon'. If 'with_logon' is set, then the 'password' option is
+    # mandatory.
+    #
+    # The startup_info key takes a hash. Its keys are attributes that are
+    # part of the StartupInfo struct, and are generally only meaningful for
+    # GUI or console processes. See the documentation on CreateProcess()
+    # and the StartupInfo struct on MSDN for more information.
+    #
+    # * desktop
+    # * title
+    # * x
+    # * y
+    # * x_size
+    # * y_size
+    # * x_count_chars
+    # * y_count_chars
+    # * fill_attribute
+    # * sw_flags
+    # * startf_flags
+    # * stdin
+    # * stdout
+    # * stderr
+    #
+    # Note that the 'stdin', 'stdout' and 'stderr' options can be either Ruby
+    # IO objects or file descriptors (i.e. a fileno). However, StringIO objects
+    # are not currently supported. Unfortunately, setting these is not currently
+    # an option for JRuby.
+    #
+    # If 'stdin', 'stdout' or 'stderr' are specified, then the +inherit+ value
+    # is automatically set to true and the Process::STARTF_USESTDHANDLES flag is
+    # automatically OR'd to the +startf_flags+ value.
+    #
+    # The ProcessInfo struct contains the following members:
+    #
+    # * process_handle - The handle to the newly created process.
+    # * thread_handle  - The handle to the primary thread of the process.
+    # * process_id     - Process ID.
+    # * thread_id      - Thread ID.
+    #
+    # If the 'close_handles' option is set to true (the default) then the
+    # process_handle and the thread_handle are automatically closed for you
+    # before the ProcessInfo struct is returned.
+    #
+    # If the 'with_logon' option is set, then the process runs the specified
+    # executable file in the security context of the specified credentials.
+    #
+    def create(args)
+      unless args.kind_of?(Hash)
+        raise TypeError, 'hash keyword arguments expected'
+      end
+
+      valid_keys = %w[
+        app_name command_line inherit creation_flags cwd environment
+        startup_info thread_inherit process_inherit close_handles with_logon
+        domain password
+      ]
+
+      valid_si_keys = %w[
+        startf_flags desktop title x y x_size y_size x_count_chars
+        y_count_chars fill_attribute sw_flags stdin stdout stderr
+      ]
+
+      # Set default values
+      hash = {
+        'app_name'       => nil,
+        'creation_flags' => 0,
+        'close_handles'  => true
+      }
 
-    pid
-  end
+      # Validate the keys, and convert symbols and case to lowercase strings.
+      args.each{ |key, val|
+        key = key.to_s.downcase
+        unless valid_keys.include?(key)
+          raise ArgumentError, "invalid key '#{key}'"
+        end
+        hash[key] = val
+      }
 
-  # Waits for the given child process to exit and returns an array containing
-  # the process id and the exit status.
-  #
-  # The +flags+ argument is ignored at the moment. It is provided strictly
-  # for interface compatibility.
-  #
-  # Note that the $? (Process::Status) global variable is NOT set. This
-  # may be addressed in a future release if/when possible.
-  #--
-  # Ruby does not provide a way to hook into $? so there's no way for us
-  # to set it.
-  #
-  def waitpid2(pid, flags = nil)
-    exit_code = [0].pack('L')
-    handle    = OpenProcess(PROCESS_ALL_ACCESS, 0, pid)
-
-    if handle == INVALID_HANDLE_VALUE
-      raise Error, get_last_error
-    end
+      si_hash = {}
 
-    # TODO: update the $? global variable (if/when possible)
-    status = WaitForSingleObject(handle, INFINITE)
+      # If the startup_info key is present, validate its subkeys
+      if hash['startup_info']
+        hash['startup_info'].each{ |key, val|
+          key = key.to_s.downcase
+          unless valid_si_keys.include?(key)
+            raise ArgumentError, "invalid startup_info key '#{key}'"
+          end
+          si_hash[key] = val
+        }
+      end
 
-    begin
-      unless GetExitCodeProcess(handle, exit_code)
-        raise Error, get_last_error
+      # The +command_line+ key is mandatory unless the +app_name+ key
+      # is specified.
+      unless hash['command_line']
+        if hash['app_name']
+          hash['command_line'] = hash['app_name']
+          hash['app_name'] = nil
+        else
+          raise ArgumentError, 'command_line or app_name must be specified'
+        end
       end
-    ensure
-      CloseHandle(handle)
-    end
 
-    @child_pids.delete(pid)
+      env = nil
 
-    # TODO: update the $? global variable (if/when possible)
-    exit_code = exit_code.unpack('L').first
+      # The env string should be passed as a string of ';' separated paths.
+      if hash['environment']
+        env = hash['environment']
 
-    [pid, exit_code]
-  end
+        unless env.respond_to?(:join)
+          env = hash['environment'].split(File::PATH_SEPARATOR)
+        end
 
-  # Sends the given +signal+ to an array of process id's. The +signal+ may
-  # be any value from 0 to 9, or the special strings 'SIGINT' (or 'INT'),
-  # 'SIGBRK' (or 'BRK') and 'SIGKILL' (or 'KILL'). An array of successfully
-  # killed pids is returned.
-  #
-  # Signal 0 merely tests if the process is running without killing it.
-  # Signal 2 sends a CTRL_C_EVENT to the process.
-  # Signal 3 sends a CTRL_BRK_EVENT to the process.
-  # Signal 9 kills the process in a harsh manner.
-  # Signals 1 and 4-8 kill the process in a nice manner.
-  #
-  # SIGINT/INT corresponds to signal 2
-  # SIGBRK/BRK corresponds to signal 3
-  # SIGKILL/KILL corresponds to signal 9
-  #
-  # Signals 2 and 3 only affect console processes, and then only if the
-  # process was created with the CREATE_NEW_PROCESS_GROUP flag.
-  #
-  def kill(signal, *pids)
-    case signal
-      when 'SIGINT', 'INT'
-        signal = 2
-      when 'SIGBRK', 'BRK'
-        signal = 3
-      when 'SIGKILL', 'KILL'
-        signal = 9
-      when 0..9
-        # Do nothing
-      else
-        raise Error, "Invalid signal '#{signal}'"
-    end
+        env = env.map{ |e| e + 0.chr }.join('') + 0.chr
+        env.to_wide_string! if hash['with_logon']
+      end
 
-    killed_pids = []
+      # Process SECURITY_ATTRIBUTE structure
+      process_security = nil
 
-    pids.each{ |pid|
-      # Send the signal to the current process if the pid is zero
-      if pid == 0
-        pid = Process.pid
+      if hash['process_inherit']
+        process_security = SECURITY_ATTRIBUTES.new
+        process_security[:nLength] = 12
+        process_security[:bInheritHandle] = true
       end
 
-      # No need for full access if the signal is zero
-      if signal == 0
-        access = PROCESS_QUERY_INFORMATION | PROCESS_VM_READ
-        handle = OpenProcess(access, 0 , pid)
-      else
-        handle = OpenProcess(PROCESS_ALL_ACCESS, 0, pid)
+      # Thread SECURITY_ATTRIBUTE structure
+      thread_security = nil
+
+      if hash['thread_inherit']
+        thread_security = SECURITY_ATTRIBUTES.new
+        thread_security[:nLength] = 12
+        thread_security[:bInheritHandle] = true
       end
 
-      begin
-        case signal
-          when 0
-            if handle != 0
-              killed_pids.push(pid)
-            else
-              # If ERROR_ACCESS_DENIED is returned, we know it's running
-              if GetLastError() == ERROR_ACCESS_DENIED
-                killed_pids.push(pid)
-              else
-                raise Error, get_last_error
-              end
-            end
-          when 2
-            if GenerateConsoleCtrlEvent(CTRL_C_EVENT, pid)
-              killed_pids.push(pid)
-            end
-          when 3
-            if GenerateConsoleCtrlEvent(CTRL_BREAK_EVENT, pid)
-              killed_pids.push(pid)
-            end
-          when 9
-            if TerminateProcess(handle, pid)
-              killed_pids.push(pid)
-              @child_pids.delete(pid)
-            else
-              raise Error, get_last_error
-            end
+      # Automatically handle stdin, stdout and stderr as either IO objects
+      # or file descriptors. This won't work for StringIO, however. It also
+      # will not work on JRuby because of the way it handles internal file
+      # descriptors.
+      #
+      ['stdin', 'stdout', 'stderr'].each{ |io|
+        if si_hash[io]
+          if si_hash[io].respond_to?(:fileno)
+            handle = get_osfhandle(si_hash[io].fileno)
           else
-            if handle != 0
-              thread_id = [0].pack('L')
-              begin
-                thread = CreateRemoteThread(
-                  handle,
-                  0,
-                  0,
-                  GetProcAddress(GetModuleHandle('kernel32'), 'ExitProcess'),
-                  0,
-                  0,
-                  thread_id
-                )
-
-                if thread
-                  WaitForSingleObject(thread, 5)
-                  killed_pids.push(pid)
-                  @child_pids.delete(pid)
-                else
-                  raise Error, get_last_error
-                end
-              ensure
-                CloseHandle(thread) if thread
-              end
-            else
-              raise Error, get_last_error
-            end # case
+            handle = get_osfhandle(si_hash[io])
+          end
 
-          @child_pids.delete(pid)
-        end
-      ensure
-        CloseHandle(handle) unless handle == INVALID_HANDLE_VALUE
-      end
-    }
+          if handle == INVALID_HANDLE_VALUE
+            ptr = FFI::MemoryPointer.new(:int)
 
-    killed_pids
-  end
+            if get_errno(ptr) == 0
+              errno = ptr.read_int
+            else
+              errno = FFI.errno
+            end
 
-  # Process.create(key => value, ...) => ProcessInfo
-  #
-  # This is a wrapper for the CreateProcess() function. It executes a process,
-  # returning a ProcessInfo struct. It accepts a hash as an argument.
-  # There are several primary keys:
-	#
-  # * command_line     (mandatory)
-  # * app_name         (default: nil)
-  # * inherit          (default: false)
-  # * process_inherit  (default: false)
-  # * thread_inherit   (default: false)
-  # * creation_flags   (default: 0)
-  # * cwd              (default: Dir.pwd)
-  # * startup_info     (default: nil)
-  # * environment      (default: nil)
-  # * close_handles    (default: true)
-  # * with_logon       (default: nil)
-  # * domain           (default: nil)
-  # * password         (default: nil)
-	#
-  # Of these, the 'command_line' or 'app_name' must be specified or an
-  # error is raised. Both may be set individually, but 'command_line' should
-  # be preferred if only one of them is set because it does not (necessarily)
-  # require an explicit path or extension to work.
-  #
-  # The 'domain' and 'password' options are only relevent in the context
-  # of 'with_logon'.
-	#
-  # The startup_info key takes a hash. Its keys are attributes that are
-  # part of the StartupInfo struct, and are generally only meaningful for
-  # GUI or console processes. See the documentation on CreateProcess()
-  # and the StartupInfo struct on MSDN for more information.
-	#
-  # * desktop
-  # * title
-  # * x
-  # * y
-  # * x_size
-  # * y_size
-  # * x_count_chars
-  # * y_count_chars
-  # * fill_attribute
-  # * sw_flags
-  # * startf_flags
-  # * stdin
-  # * stdout
-  # * stderr
-  #
-  # The relevant constants for 'creation_flags', 'sw_flags' and 'startf_flags'
-  # are included in the Windows::Process, Windows::Console and Windows::Window
-  # modules. These come with the windows-pr library, a prerequisite of this
-  # library. Note that the 'stdin', 'stdout' and 'stderr' options can be
-  # either Ruby IO objects or file descriptors (i.e. a fileno). However,
-  # StringIO objects are not currently supported.
-  #
-  # If 'stdin', 'stdout' or 'stderr' are specified, then the +inherit+ value
-  # is automatically set to true and the Process::STARTF_USESTDHANDLES flag is
-  # automatically OR'd to the +startf_flags+ value.
-  #
-  # The ProcessInfo struct contains the following members:
-  #
-  # * process_handle - The handle to the newly created process.
-  # * thread_handle  - The handle to the primary thread of the process.
-  # * process_id     - Process ID.
-  # * thread_id      - Thread ID.
-  #
-  # If the 'close_handles' option is set to true (the default) then the
-  # process_handle and the thread_handle are automatically closed for you
-  # before the ProcessInfo struct is returned.
-  #
-  # If the 'with_logon' option is set, then the process runs the specified
-  # executable file in the security context of the specified credentials.
-  #
-  def create(args)
-    unless args.kind_of?(Hash)
-      raise TypeError, 'Expecting hash-style keyword arguments'
-    end
+            raise SystemCallError.new("get_osfhandle", errno)
+          end
 
-    valid_keys = %w/
-      app_name command_line inherit creation_flags cwd environment
-      startup_info thread_inherit process_inherit close_handles with_logon
-      domain password
-    /
-
-    valid_si_keys = %/
-      startf_flags desktop title x y x_size y_size x_count_chars
-      y_count_chars fill_attribute sw_flags stdin stdout stderr
-    /
-
-    # Set default values
-    hash = {
-      'app_name'       => nil,
-      'creation_flags' => 0,
-      'close_handles'  => true
-    }
-
-    # Validate the keys, and convert symbols and case to lowercase strings.
-    args.each{ |key, val|
-      key = key.to_s.downcase
-      unless valid_keys.include?(key)
-        raise ArgumentError, "invalid key '#{key}'"
-      end
-      hash[key] = val
-    }
+          # Most implementations of Ruby on Windows create inheritable
+          # handles by default, but some do not. RF bug #26988.
+          bool = SetHandleInformation(
+            handle,
+            HANDLE_FLAG_INHERIT,
+            HANDLE_FLAG_INHERIT
+          )
 
-    si_hash = {}
+          raise SystemCallError.new("SetHandleInformation", FFI.errno) unless bool
 
-    # If the startup_info key is present, validate its subkeys
-    if hash['startup_info']
-      hash['startup_info'].each{ |key, val|
-        key = key.to_s.downcase
-        unless valid_si_keys.include?(key)
-          raise ArgumentError, "invalid startup_info key '#{key}'"
+          si_hash[io] = handle
+          si_hash['startf_flags'] ||= 0
+          si_hash['startf_flags'] |= STARTF_USESTDHANDLES
+          hash['inherit'] = true
         end
-        si_hash[key] = val
       }
-    end
 
-    # The +command_line+ key is mandatory unless the +app_name+ key
-    # is specified.
-    unless hash['command_line']
+      procinfo  = PROCESS_INFORMATION.new
+      startinfo = STARTUPINFO.new
+
+      unless si_hash.empty?
+        startinfo[:cb]              = startinfo.size
+        startinfo[:lpDesktop]       = si_hash['desktop'] if si_hash['desktop']
+        startinfo[:lpTitle]         = si_hash['title'] if si_hash['title']
+        startinfo[:dwX]             = si_hash['x'] if si_hash['x']
+        startinfo[:dwY]             = si_hash['y'] if si_hash['y']
+        startinfo[:dwXSize]         = si_hash['x_size'] if si_hash['x_size']
+        startinfo[:dwYSize]         = si_hash['y_size'] if si_hash['y_size']
+        startinfo[:dwXCountChars]   = si_hash['x_count_chars'] if si_hash['x_count_chars']
+        startinfo[:dwYCountChars]   = si_hash['y_count_chars'] if si_hash['y_count_chars']
+        startinfo[:dwFillAttribute] = si_hash['fill_attribute'] if si_hash['fill_attribute']
+        startinfo[:dwFlags]         = si_hash['startf_flags'] if si_hash['startf_flags']
+        startinfo[:wShowWindow]     = si_hash['sw_flags'] if si_hash['sw_flags']
+        startinfo[:cbReserved2]     = 0
+        startinfo[:hStdInput]       = si_hash['stdin'] if si_hash['stdin']
+        startinfo[:hStdOutput]      = si_hash['stdout'] if si_hash['stdout']
+        startinfo[:hStdError]       = si_hash['stderr'] if si_hash['stderr']
+      end
+
+      app = nil
+      cmd = nil
+
+      # Convert strings to wide character strings if present
       if hash['app_name']
-        hash['command_line'] = hash['app_name']
-        hash['app_name'] = nil
-      else
-        raise ArgumentError, 'command_line or app_name must be specified'
+        app = hash['app_name'].to_wide_string
       end
-    end
 
-    # The environment string should be passed as a string of ';' separated
-    # paths.
-    if hash['environment']
-      env = hash['environment'].split(File::PATH_SEPARATOR) << 0.chr
-      if hash['with_logon']
-        env = env.map{ |e| multi_to_wide(e) }
-        env = [env.join("\0\0")].pack('p*').unpack('L').first
-      else
-        env = [env.join("\0")].pack('p*').unpack('L').first
+      if hash['command_line']
+        cmd = hash['command_line'].to_wide_string
       end
-    else
-      env = nil
-    end
-
-    startinfo = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
-    startinfo = startinfo.pack('LLLLLLLLLLLLSSLLLL')
-    procinfo  = [0,0,0,0].pack('LLLL')
 
-    # Process SECURITY_ATTRIBUTE structure
-    process_security = 0
-    if hash['process_inherit']
-      process_security = [0,0,0].pack('LLL')
-      process_security[0,4] = [12].pack('L') # sizeof(SECURITY_ATTRIBUTE)
-      process_security[8,4] = [1].pack('L')  # TRUE
-    end
+      if hash['cwd']
+        cwd = hash['cwd'].to_wide_string
+      end
 
-    # Thread SECURITY_ATTRIBUTE structure
-    thread_security = 0
-    if hash['thread_inherit']
-      thread_security = [0,0,0].pack('LLL')
-      thread_security[0,4] = [12].pack('L') # sizeof(SECURITY_ATTRIBUTE)
-      thread_security[8,4] = [1].pack('L')  # TRUE
-    end
+      if hash['with_logon']
+        logon = hash['with_logon'].to_wide_string
 
-    # Automatically handle stdin, stdout and stderr as either IO objects
-    # or file descriptors.  This won't work for StringIO, however.
-    ['stdin', 'stdout', 'stderr'].each{ |io|
-      if si_hash[io]
-        if si_hash[io].respond_to?(:fileno)
-          handle = get_osfhandle(si_hash[io].fileno)
+        if hash['password']
+          passwd = hash['password'].to_wide_string
         else
-          handle = get_osfhandle(si_hash[io])
+          raise ArgumentError, 'password must be specified if with_logon is used'
         end
 
-        if handle == INVALID_HANDLE_VALUE
-          raise Error, get_last_error
+        if hash['domain']
+          domain = hash['domain'].to_wide_string
         end
 
-        # Most implementations of Ruby on Windows create inheritable
-        # handles by default, but some do not. RF bug #26988.
-        bool = SetHandleInformation(
-          handle,
-          HANDLE_FLAG_INHERIT,
-          HANDLE_FLAG_INHERIT
+        hash['creation_flags'] |= CREATE_UNICODE_ENVIRONMENT
+
+        bool = CreateProcessWithLogonW(
+          logon,                  # User
+          domain,                 # Domain
+          passwd,                 # Password
+          LOGON_WITH_PROFILE,     # Logon flags
+          app,                    # App name
+          cmd,                    # Command line
+          hash['creation_flags'], # Creation flags
+          env,                    # Environment
+          cwd,                    # Working directory
+          startinfo,              # Startup Info
+          procinfo                # Process Info
         )
 
-        raise Error, get_last_error unless bool
-
-        si_hash[io] = handle
-        si_hash['startf_flags'] ||= 0
-        si_hash['startf_flags'] |= STARTF_USESTDHANDLES
-        hash['inherit'] = true
-      end
-    }
-
-    # The bytes not covered here are reserved (null)
-    unless si_hash.empty?
-      startinfo[0,4]  = [startinfo.size].pack('L')
-      startinfo[8,4]  = [si_hash['desktop']].pack('p*') if si_hash['desktop']
-      startinfo[12,4] = [si_hash['title']].pack('p*') if si_hash['title']
-      startinfo[16,4] = [si_hash['x']].pack('L') if si_hash['x']
-      startinfo[20,4] = [si_hash['y']].pack('L') if si_hash['y']
-      startinfo[24,4] = [si_hash['x_size']].pack('L') if si_hash['x_size']
-      startinfo[28,4] = [si_hash['y_size']].pack('L') if si_hash['y_size']
-      startinfo[32,4] = [si_hash['x_count_chars']].pack('L') if si_hash['x_count_chars']
-      startinfo[36,4] = [si_hash['y_count_chars']].pack('L') if si_hash['y_count_chars']
-      startinfo[40,4] = [si_hash['fill_attribute']].pack('L') if si_hash['fill_attribute']
-      startinfo[44,4] = [si_hash['startf_flags']].pack('L') if si_hash['startf_flags']
-      startinfo[48,2] = [si_hash['sw_flags']].pack('S') if si_hash['sw_flags']
-      startinfo[56,4] = [si_hash['stdin']].pack('L') if si_hash['stdin']
-      startinfo[60,4] = [si_hash['stdout']].pack('L') if si_hash['stdout']
-      startinfo[64,4] = [si_hash['stderr']].pack('L') if si_hash['stderr']
-    end
-
-    if hash['with_logon']
-      logon  = multi_to_wide(hash['with_logon'])
-      domain = multi_to_wide(hash['domain'])
-      app    = hash['app_name'].nil? ? nil : multi_to_wide(hash['app_name'])
-      cmd    = hash['command_line'].nil? ? nil : multi_to_wide(hash['command_line'])
-      cwd    = multi_to_wide(hash['cwd'])
-      passwd = multi_to_wide(hash['password'])
-
-      hash['creation_flags'] |= CREATE_UNICODE_ENVIRONMENT
-
-      bool = CreateProcessWithLogonW(
-        logon,                  # User
-        domain,                 # Domain
-        passwd,                 # Password
-        LOGON_WITH_PROFILE,     # Logon flags
-        app,                    # App name
-        cmd,                    # Command line
-        hash['creation_flags'], # Creation flags
-        env,                    # Environment
-        cwd,                    # Working directory
-        startinfo,              # Startup Info
-        procinfo                # Process Info
-      )
-    else
-      bool = CreateProcess(
-        hash['app_name'],       # App name
-        hash['command_line'],   # Command line
-        process_security,       # Process attributes
-        thread_security,        # Thread attributes
-        hash['inherit'],        # Inherit handles?
-        hash['creation_flags'], # Creation flags
-        env,                    # Environment
-        hash['cwd'],            # Working directory
-        startinfo,              # Startup Info
-        procinfo                # Process Info
-      )
-    end
-
-    # TODO: Close stdin, stdout and stderr handles in the si_hash unless
-    # they're pointing to one of the standard handles already. [Maybe]
-    unless bool
-      raise Error, "CreateProcess() failed: " + get_last_error
-    end
-
-    # Automatically close the process and thread handles in the
-    # PROCESS_INFORMATION struct unless explicitly told not to.
-    if hash['close_handles']
-      CloseHandle(procinfo[0,4].unpack('L').first)
-      CloseHandle(procinfo[4,4].unpack('L').first)
-    end
-
-    ProcessInfo.new(
-      procinfo[0,4].unpack('L').first, # hProcess
-      procinfo[4,4].unpack('L').first, # hThread
-      procinfo[8,4].unpack('L').first, # hProcessId
-      procinfo[12,4].unpack('L').first # hThreadId
-    )
-  end
-
-  # Waits for any child process to exit and returns the process id of that
-  # child. If a pid is provided that is greater than or equal to 0, then
-  # it is the equivalent of calling Process.waitpid.
-  #
-  # The +flags+ argument is ignored at the moment. It is provided strictly
-  # for interface compatibility.
-  #
-  # Note that the $? (Process::Status) global variable is NOT set.  This
-  # may be addressed in a future release.
-  #--
-  # The GetProcessId() function is not defined in Windows 2000 or earlier
-  # so we have to do some extra work for those platforms.
-  #
-  def wait(pid = -1, flags = nil)
-    if pid && pid >= 0
-      pid, status = waitpid(pid, flags)
-      return pid
-    end
-
-    handles = []
-
-    # Windows 2000 or earlier
-    unless defined? GetProcessId
-      pids = []
-    end
-
-    @child_pids.each_with_index{ |lpid, i|
-      handles[i] = OpenProcess(PROCESS_ALL_ACCESS, 0, lpid)
+        unless bool
+          raise SystemCallError.new("CreateProcessWithLogonW", FFI.errno)
+        end
+      else
+        inherit  = hash['inherit'] || false
+
+        bool = CreateProcessW(
+          app,                    # App name
+          cmd,                    # Command line
+          process_security,       # Process attributes
+          thread_security,        # Thread attributes
+          inherit,                # Inherit handles?
+          hash['creation_flags'], # Creation flags
+          env,                    # Environment
+          cwd,                    # Working directory
+          startinfo,              # Startup Info
+          procinfo                # Process Info
+        )
 
-      if handles[i] == INVALID_HANDLE_VALUE
-        err = "unable to get HANDLE on process associated with pid #{lpid}"
-        raise Error, err
+        unless bool
+          raise SystemCallError.new("CreateProcess", FFI.errno)
+        end
       end
 
-      unless defined? GetProcessId
-        pids[i] = lpid
+      # Automatically close the process and thread handles in the
+      # PROCESS_INFORMATION struct unless explicitly told not to.
+      if hash['close_handles']
+        CloseHandle(procinfo[:hProcess])
+        CloseHandle(procinfo[:hThread])
       end
-    }
 
-    wait = WaitForMultipleObjects(
-      handles.size,
-      handles.pack('L*'),
-      0,
-      INFINITE
-    )
-
-    if wait >= WAIT_OBJECT_0 && wait <= WAIT_OBJECT_0 + @child_pids.size - 1
-      index = wait - WAIT_OBJECT_0
-      handle = handles[index]
-
-      if defined? GetProcessId
-        pid = GetProcessId(handle)
-      else
-        pid = pids[index]
-      end
-
-      @child_pids.delete(pid)
-      handles.each{ |h| CloseHandle(h) }
-      return pid
-    end
-
-    nil
-  end
-
-  # Waits for any child process to exit and returns an array containing the
-  # process id and the exit status of that child.
-  #
-  # The +flags+ argument is ignored at the moment. It is provided strictly
-  # for interface compatibility.
-  #
-  # Note that the $? (Process::Status) global variable is NOT set.  This
-  # may be addressed in a future release.
-  #--
-  # The GetProcessId() function is not defined in Windows 2000 or earlier
-  # so we have to do some extra work for those platforms.
-  #
-  def wait2(pid = -1, flags = nil)
-    if pid && pid >= 0
-      pid, status = waitpid2(pid, flags)
-      return pid
-    end
-
-    handles = []
-
-    # Windows 2000 or earlier
-    unless defined? GetProcessId
-      pids = []
+      ProcessInfo.new(
+        procinfo[:hProcess],
+        procinfo[:hThread],
+        procinfo[:dwProcessId],
+        procinfo[:dwThreadId]
+      )
     end
 
-    @child_pids.each_with_index{ |lpid, i|
-      handles[i] = OpenProcess(PROCESS_ALL_ACCESS, 0, lpid)
-
-      if handles[i] == INVALID_HANDLE_VALUE
-        err = "unable to get HANDLE on process associated with pid #{lpid}"
-        raise Error, err
+    remove_method :kill
+
+    # Kill a given process with a specific signal. This overrides the default
+    # implementation of Process.kill. The differences mainly reside in the way
+    # it kills processes, but this version also gives you finer control over
+    # behavior.
+    #
+    # Internally, signals 2 and 3 will generate a console control event, using
+    # a ctrl-c or ctrl-break event, respectively. Signal 9 terminates the
+    # process harshly, given that process no chance to do any internal cleanup.
+    # Signals 1 and 4-8 kill the process more nicely, giving the process a
+    # chance to do internal cleanup before being killed. Signal 0 behaves the
+    # same as the default implementation.
+    #
+    # When using signals 1 or 4-8 you may specify additional options that
+    # allow finer control over how that process is killed and how your program
+    # behaves.
+    #
+    # Possible options for signals 1 and 4-8.
+    #
+    # :exit_proc  => The name of the exit function called when signal 1 or 4-8
+    #                is used. The default is 'ExitProcess'.
+    #
+    # :dll_module => The name of the .dll (or .exe) that contains :exit_proc.
+    #                The default is 'kernel32'.
+    #
+    # :wait_time  => The time, in milliseconds, to wait for the process to
+    #                actually die. The default is 5ms. If you specify 0 here
+    #                then the process does not wait if the process is not
+    #                signaled and instead returns immediately. Alternatively,
+    #                you may specify Process::INFINITE, and your code will
+    #                block until the process is actually signaled.
+    #
+    # Example:
+    #
+    #   Process.kill(1, 12345, :exit_proc => 'ExitProcess', :module => 'kernel32')
+    #
+    def kill(signal, *pids)
+      # Match the spec, require at least 2 arguments
+      if pids.length == 0
+        raise ArgumentError, "wrong number of arguments (1 for at least 2)"
+      end
+
+      # Match the spec, signal may not be less than zero if numeric
+      if signal.is_a?(Numeric) && signal < 0 # EINVAL
+        raise SystemCallError.new(22)
+      end
+
+      # Match the spec, signal must be a numeric, string or symbol
+      unless signal.is_a?(String) || signal.is_a?(Numeric) || signal.is_a?(Symbol)
+        raise ArgumentError, "bad signal type #{signal.class}"
+      end
+
+      # Match the spec, making an exception for BRK/SIGBRK, if the signal name is invalid
+      if signal.is_a?(String) || signal.is_a?(Symbol)
+        signal = signal.to_s.sub('SIG', '')
+        unless Signal.list.keys.include?(signal) || ['BRK', 'BRK'].include?(signal)
+          raise ArgumentError, "unsupported name '#{signal}'"
+        end
       end
 
-      unless defined? GetProcessId
-        pids[i] = lpid
-      end
-    }
+      # If the last argument is a hash, pop it and assume it's a hash of options
+      if pids.last.is_a?(Hash)
+        hash = pids.pop
+        opts = {}
 
-    wait = WaitForMultipleObjects(
-      handles.size,
-      handles.pack('L*'),
-      0,
-      INFINITE
-    )
+        valid = %w[exit_proc dll_module wait_time]
 
-    if wait >= WAIT_OBJECT_0 && wait <= WAIT_OBJECT_0 + @child_pids.size - 1
-      index = wait - WAIT_OBJECT_0
-      handle = handles[index]
+        hash.each{ |k,v|
+          k = k.to_s.downcase
+          unless valid.include?(k)
+            raise ArgumentError, "invalid option '#{k}'"
+          end
+          opts[k] = v
+        }
 
-      if defined? GetProcessId
-        pid = GetProcessId(handle)
+        exit_proc  = opts['exit_proc']  || 'ExitProcess'
+        dll_module = opts['dll_module'] || 'kernel32'
+        wait_time  = opts['wait_time']  || 5
       else
-        pid = pids[index]
+        wait_time  = 5
+        exit_proc  = 'ExitProcess'
+        dll_module = 'kernel32'
       end
 
-      exit_code = [0].pack('l')
+      count = 0
 
-      unless GetExitCodeProcess(handle, exit_code)
-        raise get_last_error
-      end
+      pids.each{ |pid|
+        raise TypeError unless pid.is_a?(Numeric) # Match spec, pid must be a number
+        raise SystemCallError.new(22) if pid < 0  # Match spec, EINVAL if pid less than zero
 
-      @child_pids.delete(pid)
+        sigint = [Signal.list['INT'], 'INT', 'SIGINT', :INT, :SIGINT, 2]
 
-      handles.each{ |h| CloseHandle(h) }
-      return [pid, exit_code.unpack('l').first]
-    end
+        # Match the spec
+        if pid == 0 && !sigint.include?(signal)
+          raise SystemCallError.new(22)
+        end
 
-    nil
-  end
+        if signal == 0
+          access = PROCESS_QUERY_INFORMATION | PROCESS_VM_READ
+        elsif signal == 9
+          access = PROCESS_TERMINATE
+        else
+          access = PROCESS_ALL_ACCESS
+        end
 
-  # Returns the process ID of the parent of this process.
-  #--
-  # In MRI this method always returns 0.
-  #
-  def ppid
-    ppid = 0
+        begin
+          handle = OpenProcess(access, false, pid)
 
-    return ppid if Process.pid == 0 # Paranoia
+          if signal != 0 && handle == 0
+            raise SystemCallError, FFI.errno, "OpenProcess"
+          end
 
-    handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0)
+          case signal
+            when 0
+              if handle != 0
+                count += 1
+              else
+                if FFI.errno == ERROR_ACCESS_DENIED
+                  count += 1
+                else
+                  raise SystemCallError.new(3) # ESRCH
+                end
+              end
+            when Signal.list['INT'], 'INT', 'SIGINT', :INT, :SIGINT, 2
+              if GenerateConsoleCtrlEvent(CTRL_C_EVENT, pid)
+                count += 1
+              else
+                raise SystemCallError.new("GenerateConsoleCtrlEvent", FFI.errno)
+              end
+            when Signal.list['BRK'], 'BRK', 'SIGBRK', :BRK, :SIGBRK, 3
+              if GenerateConsoleCtrlEvent(CTRL_BREAK_EVENT, pid)
+                count += 1
+              else
+                raise SystemCallError.new("GenerateConsoleCtrlEvent", FFI.errno)
+              end
+            when Signal.list['KILL'], 'KILL', 'SIGKILL', :KILL, :SIGKILL, 9
+              if TerminateProcess(handle, pid)
+                count += 1
+              else
+                raise SystemCallError.new("TerminateProcess", FFI.errno)
+              end
+            else
+              thread_id = FFI::MemoryPointer.new(:ulong)
 
-    if handle == INVALID_HANDLE_VALUE
-      raise Error, get_last_error
-    end
+              mod = GetModuleHandle(dll_module)
 
-    proc_entry = 0.chr * 296 # 36 + 260
-    proc_entry[0, 4] = [proc_entry.size].pack('L') # Set dwSize member
+              if mod == 0
+                raise SystemCallError.new("GetModuleHandle: '#{dll_module}'", FFI.errno)
+              end
 
-    begin
-      unless Process32First(handle, proc_entry)
-        error = get_last_error
-        raise Error, error
-      end
+              proc_addr = GetProcAddress(mod, exit_proc)
 
-      while Process32Next(handle, proc_entry)
-        if proc_entry[8, 4].unpack('L')[0] == Process.pid
-          ppid = proc_entry[24, 4].unpack('L')[0] # th32ParentProcessID
-          break
-        end
-      end
-    ensure
-      CloseHandle(handle)
-    end
+              if proc_addr == 0
+                raise SystemCallError.new("GetProcAddress: '#{exit_proc}'", FFI.errno)
+              end
 
-    ppid
-  end
+              thread = CreateRemoteThread(handle, nil, 0, proc_addr, nil, 0, thread_id)
 
-  # Creates the equivalent of a subshell via the CreateProcess() function.
-  # This behaves in a manner that is similar, but not identical to, the
-  # Kernel.fork method for Unix. Unlike the Unix fork, this method starts
-  # from the top of the script rather than the point of the call.
-  #
-  # WARNING: This implementation should be considered experimental. It is
-  # not recommended for production use.
-  #
-  def fork
-    last_arg = ARGV.last
-
-    # Look for the 'child#xxx' tag
-    if last_arg =~ /child#\d+/
-      @i += 1
-      num = last_arg.split('#').last.to_i
-      if num == @i
-        if block_given?
-          status = 0
-          begin
-            yield
-          rescue Exception
-            status = -1 # Any non-zero result is failure
-          ensure
-            return status
+              if thread > 0
+                WaitForSingleObject(thread, wait_time)
+                count += 1
+              else
+                raise SystemCallError.new("CreateRemoteThread", FFI.errno)
+              end
           end
+        ensure
+          CloseHandle(handle) if handle
         end
-        return nil
-      else
-        return false
-      end
-    end
-
-    # Tag the command with the word 'child#xxx' to distinguish it
-    # from the calling process.
-    cmd = 'ruby -I "' + $LOAD_PATH.join(File::PATH_SEPARATOR) << '" "'
-    cmd << File.expand_path($PROGRAM_NAME) << '" ' << ARGV.join(' ')
-    cmd << ' child#' << @child_pids.length.to_s
-
-    startinfo = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
-    startinfo = startinfo.pack('LLLLLLLLLLLLSSLLLL')
-    procinfo  = [0,0,0,0].pack('LLLL')
-
-    rv = CreateProcess(nil, cmd, 0, 0, 1, 0, 0, 0, startinfo, procinfo)
+      }
 
-    if rv == 0
-      raise Error, get_last_error
+      count
     end
-
-    pid = procinfo[8,4].unpack('L').first
-    @child_pids.push(pid)
-
-    pid
   end
 
-  module_function :create, :fork, :get_affinity, :getrlimit, :getpriority
-  module_function :job?, :kill, :ppid, :setpriority, :setrlimit
-  module_function :wait, :wait2, :waitpid, :waitpid2, :uid
-end
+  class << self
+    private
 
-# Create a global fork method
-module Kernel
-  undef_method :fork # Eliminate redefinition warning
-  def fork(&block)
-    Process.fork(&block)
+    # Private method that returns the volume type, e.g. "NTFS", etc.
+    def volume_type
+      buf = FFI::MemoryPointer.new(:char, 32)
+      bool = GetVolumeInformationA(nil, nil, 0, nil, nil, nil, buf, buf.size)
+      bool ? buf.read_string : nil
+    end
   end
 end