puppet 6.20.0-x86-mingw32 → 7.4.0-x86-mingw32

data/lib/puppet/util/windows/error.rb

@@ -1,4 +1,5 @@
 require 'puppet/util/windows'
+require 'puppet/error'
 
 # represents an error resulting from a Win32 error code
 class Puppet::Util::Windows::Error < Puppet::Error

data/lib/puppet/util/windows/eventlog.rb

@@ -46,8 +46,8 @@ class Puppet::Util::Windows::EventLog
   end
 
   # Report an event to this instance's event log handle. Accepts a string to
-  #   report (:data => <string>) and event type (:event_type => FixNum) and id
-  # (:event_id => FixNum) as returned by #to_native. The additional arguments to
+  #   report (:data => <string>) and event type (:event_type => Integer) and id
+  # (:event_id => Integer) as returned by #to_native. The additional arguments to
   # ReportEventW seen in this method aren't exposed - though ReportEventW
   # technically can accept multiple strings as well as raw binary data to log,
   # we accept a single string from Puppet::Util::Log
@@ -126,13 +126,8 @@ class Puppet::Util::Windows::EventLog
   def wide_string(str)
     # if given a nil string, assume caller wants to pass a nil pointer to win32
     return nil if str.nil?
-    # ruby (< 2.1) does not respect multibyte terminators, so it is possible
-    # for a string to contain a single trailing null byte, followed by garbage
-    # causing buffer overruns.
-    #
-    # See http://svn.ruby-lang.org/cgi-bin/viewvc.cgi?revision=41920&view=revision
-    newstr = str + "\0".encode(str.encoding)
-    newstr.encode!('UTF-16LE')
+
+    str.encode('UTF-16LE')
   end
 
   # Private duplicate of Puppet::Util::Windows::ApiTypes::from_string_to_wide_string

data/lib/puppet/util/windows/file.rb

@@ -1,74 +1,15 @@
-require 'puppet/util/windows'
+require 'puppet/ffi/windows'
 
 module Puppet::Util::Windows::File
-  require 'ffi'
-  extend FFI::Library
   extend Puppet::Util::Windows::String
 
-  FILE_ATTRIBUTE_READONLY      = 0x00000001
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa379607(v=vs.85).aspx
-  # The right to use the object for synchronization. This enables a thread to
-  # wait until the object is in the signaled state. Some object types do not
-  # support this access right.
-  SYNCHRONIZE                 = 0x100000
-  # The right to delete the object.
-  DELETE                      = 0x00010000
-  # The right to read the information in the object's security descriptor, not including the information in the system access control list (SACL).
-  # READ_CONTROL              = 0x00020000
-  # The right to modify the discretionary access control list (DACL) in the object's security descriptor.
-  WRITE_DAC                   = 0x00040000
-  # The right to change the owner in the object's security descriptor.
-  WRITE_OWNER                 = 0x00080000
-
-  # Combines DELETE, READ_CONTROL, WRITE_DAC, and WRITE_OWNER access.
-  STANDARD_RIGHTS_REQUIRED    = 0xf0000
-  # Currently defined to equal READ_CONTROL.
-  STANDARD_RIGHTS_READ        = 0x20000
-  # Currently defined to equal READ_CONTROL.
-  STANDARD_RIGHTS_WRITE       = 0x20000
-  # Currently defined to equal READ_CONTROL.
-  STANDARD_RIGHTS_EXECUTE     = 0x20000
-  # Combines DELETE, READ_CONTROL, WRITE_DAC, WRITE_OWNER, and SYNCHRONIZE access.
-  STANDARD_RIGHTS_ALL         = 0x1F0000
-  SPECIFIC_RIGHTS_ALL         = 0xFFFF
-
-  FILE_READ_DATA               = 1
-  FILE_WRITE_DATA              = 2
-  FILE_APPEND_DATA             = 4
-  FILE_READ_EA                 = 8
-  FILE_WRITE_EA                = 16
-  FILE_EXECUTE                 = 32
-  FILE_DELETE_CHILD            = 64
-  FILE_READ_ATTRIBUTES         = 128
-  FILE_WRITE_ATTRIBUTES        = 256
-
-  FILE_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1FF
-
-  FILE_GENERIC_READ =
-     STANDARD_RIGHTS_READ |
-     FILE_READ_DATA |
-     FILE_READ_ATTRIBUTES |
-     FILE_READ_EA |
-     SYNCHRONIZE
-
-  FILE_GENERIC_WRITE =
-     STANDARD_RIGHTS_WRITE |
-     FILE_WRITE_DATA |
-     FILE_WRITE_ATTRIBUTES |
-     FILE_WRITE_EA |
-     FILE_APPEND_DATA |
-     SYNCHRONIZE
-
-  FILE_GENERIC_EXECUTE =
-     STANDARD_RIGHTS_EXECUTE |
-     FILE_READ_ATTRIBUTES |
-     FILE_EXECUTE |
-     SYNCHRONIZE
-
-  REPLACEFILE_WRITE_THROUGH         = 0x1
-  REPLACEFILE_IGNORE_MERGE_ERRORS   = 0x2
-  REPLACEFILE_IGNORE_ACL_ERRORS     = 0x3
+  include Puppet::FFI::Windows::Constants
+
+  extend Puppet::FFI::Windows::Structs
+  include Puppet::FFI::Windows::Structs
+
+  include Puppet::FFI::Windows::Functions
+  extend Puppet::FFI::Windows::Functions
 
   def replace_file(target, source)
     target_encoded = wide_string(target.to_s)
@@ -111,7 +52,6 @@ module Puppet::Util::Windows::File
   end
   module_function :symlink
 
-
   def exist?(path)
     path = path.to_str if path.respond_to?(:to_str) # support WatchedFile
     path = path.to_s # support String and Pathname
@@ -144,9 +84,6 @@ module Puppet::Util::Windows::File
   end
   module_function :exist?
 
-
-  INVALID_FILE_ATTRIBUTES = 0xFFFFFFFF #define INVALID_FILE_ATTRIBUTES (DWORD (-1))
-
   def get_attributes(file_name, raise_on_invalid = true)
     result = GetFileAttributesW(wide_string(file_name.to_s))
     if raise_on_invalid && result == INVALID_FILE_ATTRIBUTES
@@ -199,18 +136,6 @@ module Puppet::Util::Windows::File
         "#{flags_and_attributes.to_s(8)}, #{template_file_handle})")
   end
 
-  IO_REPARSE_TAG_MOUNT_POINT  = 0xA0000003
-  IO_REPARSE_TAG_HSM          = 0xC0000004
-  IO_REPARSE_TAG_HSM2         = 0x80000006
-  IO_REPARSE_TAG_SIS          = 0x80000007
-  IO_REPARSE_TAG_WIM          = 0x80000008
-  IO_REPARSE_TAG_CSV          = 0x80000009
-  IO_REPARSE_TAG_DFS          = 0x8000000A
-  IO_REPARSE_TAG_SYMLINK      = 0xA000000C
-  IO_REPARSE_TAG_DFSR         = 0x80000012
-  IO_REPARSE_TAG_DEDUP        = 0x80000013
-  IO_REPARSE_TAG_NFS          = 0x80000014
-
   def self.get_reparse_point_data(handle, &block)
     # must be multiple of 1024, min 10240
     FFI::MemoryPointer.new(MAXIMUM_REPARSE_DATA_BUFFER_SIZE) do |reparse_data_buffer_ptr|
@@ -276,7 +201,6 @@ module Puppet::Util::Windows::File
     out_buffer
   end
 
-  FILE_ATTRIBUTE_REPARSE_POINT = 0x400
   def reparse_point?(file_name)
     attributes = get_attributes(file_name, false)
 
@@ -291,16 +215,6 @@ module Puppet::Util::Windows::File
   end
   module_function :symlink?
 
-  GENERIC_READ                  = 0x80000000
-  GENERIC_WRITE                 = 0x40000000
-  GENERIC_EXECUTE               = 0x20000000
-  GENERIC_ALL                   = 0x10000000
-  FILE_SHARE_READ               = 1
-  FILE_SHARE_WRITE              = 2
-  OPEN_EXISTING                 = 3
-  FILE_FLAG_OPEN_REPARSE_POINT  = 0x00200000
-  FILE_FLAG_BACKUP_SEMANTICS    = 0x02000000
-
   def self.open_symlink(link_name)
     begin
       yield handle = create_file(
@@ -329,9 +243,6 @@ module Puppet::Util::Windows::File
   end
   module_function :readlink
 
-  ERROR_FILE_NOT_FOUND = 2
-  ERROR_PATH_NOT_FOUND = 3
-
   def get_long_pathname(path)
     converted = ''
     FFI::Pointer.from_string_to_wide_string(path) do |path_ptr|
@@ -411,9 +322,6 @@ module Puppet::Util::Windows::File
   end
   module_function :lstat
 
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa364571(v=vs.85).aspx
-  FSCTL_GET_REPARSE_POINT = 0x900a8
-
   def self.resolve_symlink(handle)
     path = nil
     get_reparse_point_data(handle) do |reparse_data|
@@ -444,146 +352,4 @@ module Puppet::Util::Windows::File
     symlink
   end
   private_class_method :symlink_reparse_point?
-
-  ffi_convention :stdcall
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa365512(v=vs.85).aspx
-  # BOOL WINAPI ReplaceFile(
-  #   _In_        LPCTSTR lpReplacedFileName,
-  #   _In_        LPCTSTR lpReplacementFileName,
-  #   _In_opt_    LPCTSTR lpBackupFileName,
-  #   _In_        DWORD dwReplaceFlags - 0x1 REPLACEFILE_WRITE_THROUGH,
-  #                                      0x2 REPLACEFILE_IGNORE_MERGE_ERRORS,
-  #                                      0x4 REPLACEFILE_IGNORE_ACL_ERRORS
-  #   _Reserved_  LPVOID lpExclude,
-  #   _Reserved_  LPVOID lpReserved
-  # );
-  ffi_lib :kernel32
-  attach_function_private :ReplaceFileW,
-    [:lpcwstr, :lpcwstr, :lpcwstr, :dword, :lpvoid, :lpvoid], :win32_bool
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa365240(v=vs.85).aspx
-  # BOOL WINAPI MoveFileEx(
-  #   _In_      LPCTSTR lpExistingFileName,
-  #   _In_opt_  LPCTSTR lpNewFileName,
-  #   _In_      DWORD dwFlags
-  # );
-  ffi_lib :kernel32
-  attach_function_private :MoveFileExW,
-    [:lpcwstr, :lpcwstr, :dword], :win32_bool
-
-  # BOOLEAN WINAPI CreateSymbolicLink(
-  #   _In_  LPTSTR lpSymlinkFileName, - symbolic link to be created
-  #   _In_  LPTSTR lpTargetFileName, - name of target for symbolic link
-  #   _In_  DWORD dwFlags - 0x0 target is a file, 0x1 target is a directory
-  # );
-  # rescue on Windows < 6.0 so that code doesn't explode
-  begin
-    ffi_lib :kernel32
-    attach_function_private :CreateSymbolicLinkW,
-      [:lpwstr, :lpwstr, :dword], :boolean
-  rescue LoadError
-  end
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa364944(v=vs.85).aspx
-  # DWORD WINAPI GetFileAttributes(
-  #   _In_  LPCTSTR lpFileName
-  # );
-  ffi_lib :kernel32
-  attach_function_private :GetFileAttributesW,
-    [:lpcwstr], :dword
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa365535(v=vs.85).aspx
-  # BOOL WINAPI SetFileAttributes(
-  #   _In_  LPCTSTR lpFileName,
-  #   _In_  DWORD dwFileAttributes
-  # );
-  ffi_lib :kernel32
-  attach_function_private :SetFileAttributesW,
-    [:lpcwstr, :dword], :win32_bool
-
-  # HANDLE WINAPI CreateFile(
-  #   _In_      LPCTSTR lpFileName,
-  #   _In_      DWORD dwDesiredAccess,
-  #   _In_      DWORD dwShareMode,
-  #   _In_opt_  LPSECURITY_ATTRIBUTES lpSecurityAttributes,
-  #   _In_      DWORD dwCreationDisposition,
-  #   _In_      DWORD dwFlagsAndAttributes,
-  #   _In_opt_  HANDLE hTemplateFile
-  # );
-  ffi_lib :kernel32
-  attach_function_private :CreateFileW,
-    [:lpcwstr, :dword, :dword, :pointer, :dword, :dword, :handle], :handle
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa363216(v=vs.85).aspx
-  # BOOL WINAPI DeviceIoControl(
-  #   _In_         HANDLE hDevice,
-  #   _In_         DWORD dwIoControlCode,
-  #   _In_opt_     LPVOID lpInBuffer,
-  #   _In_         DWORD nInBufferSize,
-  #   _Out_opt_    LPVOID lpOutBuffer,
-  #   _In_         DWORD nOutBufferSize,
-  #   _Out_opt_    LPDWORD lpBytesReturned,
-  #   _Inout_opt_  LPOVERLAPPED lpOverlapped
-  # );
-  ffi_lib :kernel32
-  attach_function_private :DeviceIoControl,
-    [:handle, :dword, :lpvoid, :dword, :lpvoid, :dword, :lpdword, :pointer], :win32_bool
-
-  MAXIMUM_REPARSE_DATA_BUFFER_SIZE = 16384
-
-  # SYMLINK_REPARSE_DATA_BUFFER
-  # https://msdn.microsoft.com/en-us/library/cc232006.aspx
-  # https://msdn.microsoft.com/en-us/library/windows/hardware/ff552012(v=vs.85).aspx
-  # struct is always MAXIMUM_REPARSE_DATA_BUFFER_SIZE bytes
-  class SYMLINK_REPARSE_DATA_BUFFER < FFI::Struct
-    layout :ReparseTag, :win32_ulong,
-           :ReparseDataLength, :ushort,
-           :Reserved, :ushort,
-           :SubstituteNameOffset, :ushort,
-           :SubstituteNameLength, :ushort,
-           :PrintNameOffset, :ushort,
-           :PrintNameLength, :ushort,
-           :Flags, :win32_ulong,
-           # max less above fields dword / uint 4 bytes, ushort 2 bytes
-           # technically a WCHAR buffer, but we care about size in bytes here
-           :PathBuffer, [:byte, MAXIMUM_REPARSE_DATA_BUFFER_SIZE - 20]
-  end
-
-  # MOUNT_POINT_REPARSE_DATA_BUFFER
-  # https://msdn.microsoft.com/en-us/library/cc232007.aspx
-  # https://msdn.microsoft.com/en-us/library/windows/hardware/ff552012(v=vs.85).aspx
-  # struct is always MAXIMUM_REPARSE_DATA_BUFFER_SIZE bytes
-  class MOUNT_POINT_REPARSE_DATA_BUFFER < FFI::Struct
-    layout :ReparseTag, :win32_ulong,
-           :ReparseDataLength, :ushort,
-           :Reserved, :ushort,
-           :SubstituteNameOffset, :ushort,
-           :SubstituteNameLength, :ushort,
-           :PrintNameOffset, :ushort,
-           :PrintNameLength, :ushort,
-           # max less above fields dword / uint 4 bytes, ushort 2 bytes
-           # technically a WCHAR buffer, but we care about size in bytes here
-           :PathBuffer, [:byte, MAXIMUM_REPARSE_DATA_BUFFER_SIZE - 16]
-  end
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa364980(v=vs.85).aspx
-  # DWORD WINAPI GetLongPathName(
-  #   _In_  LPCTSTR lpszShortPath,
-  #   _Out_ LPTSTR  lpszLongPath,
-  #   _In_  DWORD   cchBuffer
-  # );
-  ffi_lib :kernel32
-  attach_function_private :GetLongPathNameW,
-    [:lpcwstr, :lpwstr, :dword], :dword
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa364989(v=vs.85).aspx
-  # DWORD WINAPI GetShortPathName(
-  #   _In_  LPCTSTR lpszLongPath,
-  #   _Out_ LPTSTR  lpszShortPath,
-  #   _In_  DWORD   cchBuffer
-  # );
-  ffi_lib :kernel32
-  attach_function_private :GetShortPathNameW,
-    [:lpcwstr, :lpwstr, :dword], :dword
 end

data/lib/puppet/util/windows/monkey_patches/process.rb

@@ -0,0 +1,414 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require 'puppet/ffi/windows'
+require 'puppet/util/windows/string'
+
+module Process
+  extend FFI::Library
+  extend Puppet::Util::Windows::String
+
+  extend Puppet::FFI::Windows::APITypes
+  extend Puppet::FFI::Windows::Functions
+  extend Puppet::FFI::Windows::Structs
+
+  include Puppet::FFI::Windows::Constants
+  include Puppet::FFI::Windows::Structs
+
+  ProcessInfo = Struct.new(
+    'ProcessInfo',
+    :process_handle,
+    :thread_handle,
+    :process_id,
+    :thread_id
+  )
+
+  private_constant :ProcessInfo
+
+  # Disable popups. This mostly affects the Process.kill method.
+  SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX)
+
+  class << self
+
+    private :SetHandleInformation, :SetErrorMode, :CreateProcessW, :OpenProcess,
+            :SetPriorityClass, :CreateProcessWithLogonW, :get_osfhandle, :get_errno
+
+    # 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.
+
+    VALID_KEYS = %i[
+      app_name command_line inherit creation_flags cwd environment
+      startup_info thread_inherit process_inherit close_handles with_logon
+      domain password
+    ].freeze
+
+    VALID_SI_KEYS = %i[
+      startf_flags desktop title x y x_size y_size x_count_chars
+      y_count_chars fill_attribute sw_flags stdin stdout stderr
+    ].freeze
+
+    private_constant :VALID_KEYS, :VALID_SI_KEYS
+
+    def create(args)
+      # Validate that args is a Hash
+      validate_args(args)
+
+      initialize_defaults
+
+      # Validate the keys, and convert symbols and case to lowercase strings.
+      validate_keys(args)
+
+      # If the startup_info key is present, validate its subkeys
+      validate_startup_info if hash[:startup_info]
+
+      # validates that 'app_name' or 'command_line' is set
+      validate_command_line
+
+      if hash[:app_name] && !hash[:command_line]
+        hash[:command_line] = hash[:app_name]
+        hash[:app_name] = nil
+      end
+
+      # Setup stdin, stdout and stderr handlers
+      setup_std_handlers
+
+      if logon
+        create_process_with_logon
+      else
+        create_process
+      end
+
+      # Automatically close the process and thread handles in the
+      # PROCESS_INFORMATION struct unless explicitly told not to.
+      if hash[:close_handles]
+        FFI::WIN32.CloseHandle(procinfo[:hProcess])
+        FFI::WIN32.CloseHandle(procinfo[:hThread])
+      end
+
+      ProcessInfo.new(
+        procinfo[:hProcess],
+        procinfo[:hThread],
+        procinfo[:dwProcessId],
+        procinfo[:dwThreadId]
+      )
+    end
+
+    remove_method :setpriority
+
+    # 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
+      handle = OpenProcess(PROCESS_SET_INFORMATION, 0 , int)
+
+      if handle == 0
+        raise SystemCallError, FFI.errno, "OpenProcess"
+      end
+
+      begin
+        result = SetPriorityClass(handle, int_priority)
+        raise SystemCallError, FFI.errno, "SetPriorityClass" unless result
+      ensure
+        FFI::WIN32.CloseHandle(handle)
+      end
+
+      return 0
+    end
+
+    private
+
+    def initialize_defaults
+      @hash = {
+        app_name: nil,
+        creation_flags: 0,
+        close_handles: true
+      }
+      @si_hash = nil
+      @procinfo = nil
+    end
+
+    def validate_args(args)
+      raise TypeError, 'hash keyword arguments expected' unless args.is_a?(Hash)
+    end
+
+    def validate_keys(args)
+      args.each do |key, val|
+        key = key.to_s.to_sym
+        raise ArgumentError, "invalid key '#{key}'" unless VALID_KEYS.include?(key)
+
+        hash[key] = val
+      end
+    end
+
+    def validate_startup_info
+      hash[:startup_info].each do |key, val|
+        key = key.to_s.to_sym
+        raise ArgumentError, "invalid startup_info key '#{key}'" unless VALID_SI_KEYS.include?(key)
+
+        si_hash[key] = val
+      end
+    end
+
+    def validate_command_line
+      raise ArgumentError, 'command_line or app_name must be specified' unless hash[:app_name] || hash[:command_line]
+    end
+
+    def procinfo
+      @procinfo ||= PROCESS_INFORMATION.new
+    end
+
+    def hash
+      @hash ||= {}
+    end
+
+    def si_hash
+      @si_hash ||= {}
+    end
+
+    def app
+      wide_string(hash[:app_name])
+    end
+
+    def cmd
+      wide_string(hash[:command_line])
+    end
+
+    def cwd
+      wide_string(hash[:cwd])
+    end
+
+    def password
+      wide_string(hash[:password])
+    end
+
+    def logon
+      wide_string(hash[:with_logon])
+    end
+
+    def domain
+      wide_string(hash[:domain])
+    end
+
+    def env
+      env = hash[:environment]
+      return unless env
+
+      env = env.split(File::PATH_SEPARATOR) unless env.respond_to?(:join)
+      env = env.map { |e| e + 0.chr }.join('') + 0.chr
+      env = wide_string(env) if hash[:with_logon]
+      env
+    end
+
+    def process_security
+      return unless hash[:process_inherit]
+
+      process_security = SECURITY_ATTRIBUTES.new
+      process_security[:nLength] = SECURITY_ATTRIBUTES.size
+      process_security[:bInheritHandle] = 1
+      process_security
+    end
+
+    def thread_security
+      return unless hash[:thread_inherit]
+
+      thread_security = SECURITY_ATTRIBUTES.new
+      thread_security[:nLength] = SECURITY_ATTRIBUTES.size
+      thread_security[:bInheritHandle] = 1
+      thread_security
+    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.
+    def setup_std_handlers
+      %i[stdin stdout stderr].each do |io|
+        next unless si_hash[io]
+
+        handle = if si_hash[io].respond_to?(:fileno)
+                   get_osfhandle(si_hash[io].fileno)
+                 else
+                   get_osfhandle(si_hash[io])
+                 end
+
+        if handle == INVALID_HANDLE_VALUE
+          ptr = FFI::MemoryPointer.new(:int)
+
+          errno = if get_errno(ptr).zero?
+                    ptr.read_int
+                  else
+                    FFI.errno
+                  end
+
+          raise SystemCallError.new('get_osfhandle', errno)
+        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
+        )
+
+        raise SystemCallError.new('SetHandleInformation', FFI.errno) unless bool
+
+        si_hash[io] = handle
+        si_hash[:startf_flags] ||= 0
+        si_hash[:startf_flags] |= STARTF_USESTDHANDLES
+        hash[:inherit] = true
+      end
+    end
+
+    def startinfo
+      startinfo = STARTUPINFO.new
+
+      return startinfo if 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]
+      startinfo
+    end
+
+    def create_process_with_logon
+      raise ArgumentError, 'password must be specified if with_logon is used' unless password
+
+      hash[:creation_flags] |= CREATE_UNICODE_ENVIRONMENT
+
+      bool = CreateProcessWithLogonW(
+        logon,                  # User
+        domain,                 # Domain
+        password,               # 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 SystemCallError.new('CreateProcessWithLogonW', FFI.errno) unless bool
+    end
+
+    def create_process
+      inherit = hash[:inherit] ? 1 : 0
+
+      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
+      )
+
+      raise SystemCallError.new('CreateProcess', FFI.errno) unless bool
+    end
+  end
+end