win32-process 0.5.1

data/CHANGES

@@ -0,0 +1,98 @@
+== 0.5.1 - 24-Aug-2006
+* Fixed a bug in the Process.create method where the return value for
+  CreateProcess() was being evaluated incorrectly.  Thanks go to David Haney
+  for the spot.
+* Added a slightly nicer error message if an invalid value is passed to the
+  Process.create method.
+* Removed an extraneous '%' character from an error message.
+
+== 0.5.0 - 29-Jul-2006
+* The Process.create method now returns a ProcessInfo struct instead of the
+  pid.  Note that you can still grab the pid out of the struct if needed.
+* The Process.create method now allows the process_inherit and
+  thread_inherit options which determine whether a process or thread
+  object's handles are inheritable, respectively.
+* The wait and wait2 methods will now work if GetProcessId() isn't defined
+  on your system.
+* The 'inherit?' hash option was changed to just 'inherit' (no question mark).
+* Minor doc correction - the 'inherit' option defaults to false, not true.
+
+== 0.4.2 - 29-May-2006
+* Fixed a typo/bug in Process.kill for signal 3, where I had accidentally
+  used CTRL_BRK_EVENT instead of the correct CTRL_BREAK_EVENT.  Thanks go
+  to Luis Lavena for the spot.
+
+== 0.4.1 - 13-May-2006
+* Fixed a bug where spaces in $LOAD_PATH would cause Process.fork to fail.
+  Thanks go to Justin Bailey for the spot and patch.
+* Added a short synopsis to the README file.
+
+== 0.4.0 - 7-May-2006
+* Now pure Ruby, courtesy of the Win32API package.
+* Now comes with a gem.
+* Modified Process.kill to send a signal to the current process if pid 0
+  is specified, as per the current 1.8 behavior.
+* Process.create now accepts the 'environment' key/value, where you can
+  pass a semicolon-separated string as the environment for the new process.
+* Moved the GUI related options of Process.create to subkeys of the
+  'startup_info' key.  See documentation for details.
+* Replaced Win32::ProcessError with just ProcessError.
+
+== 0.3.3 - 16-Apr-2006
+* Fixed a bug in Process.create with regards to creation_flags.  Thanks go
+  to Tophe Vigny for the spot.
+
+== 0.3.2 - 12-Aug-2005
+* Fixed a bug in Process.kill where a segfault could occur.  Thanks go to
+  Bill Atkins for the spot.
+* Changed VERSION to WIN32_PROCESS_VERSION, because it's a module.
+* Made the CHANGES, README and doc/process.txt documents rdoc friendly.
+* Removed the process.rd file.
+
+== 0.3.1 - 9-Dec-2004
+* Modified Process.fork to return an actual PID instead of a handle.  This
+  means that it should work with Process.kill and other methods that expect
+  an actual PID.
+* Modified Process.kill to understand the strings "SIGINT", "INT", "SIGBRK",
+  "BRK", "SIGKILL" and "KILL".  These correspond to signals 2, 3 and 9,
+  respectively.
+* Added better $LOAD_PATH handling for Process.fork.  Thanks go to Aslak
+  Hellesoy for the spot and the patch.
+* Replaced all instances of rb_sys_fail(0) with rb_raise().  This is because
+  of a strange bug in the Windows Installer that hasn't been nailed down yet.
+  This means that you can't rescue Errno::ENOENT any more, but will have to
+  rescue StandardError.  This only affects Process.kill.
+* The signals that were formerly 1 and 2 and now 2 and 3.  I did this because
+  I wanted the same signal number for SIGINT as it is on *nix.
+* Added a test_kill.rb script under the examples directory.
+* Other minor cleanup and corrections.
+
+== 0.3.0 - 25-Jul-2004
+* Added the create() method.
+* Moved the example programs to doc/examples.
+* Updated the docs, and toned down claims of fork's similarity to the Unix
+  version.
+* Minor updates to the test suite.
+
+== 0.2.1 - 17-May-2004
+* Made all methods module functions, except fork, rather than singleton
+  methods.
+* Minor doc changes.
+
+== 0.2.0 - 11-May-2004
+* Removed the Win32 module/namespace.  You no longer 'include Win32' and you
+  no longer need to prefix Process with 'Win32::'.
+* The fork() method is now a global function as well as a method of the
+  Process module.  That means you can call 'fork' instead of 'Process.fork'
+  if you like.
+* Doc updates to reflect the above changes.
+
+== 0.1.1 - 6-Mar-2004
+* Fixed bug where spaces in the directory name caused the fork() method to
+  fail (Park).
+* Normalized tc_process.rb somewhat to make it easier to run outside of the
+  test directory if desired.
+* Fixed up tc_process.rb a bit.
+
+== 0.1.0 - 19-Feb-2004
+* Initial release

data/MANIFEST

@@ -0,0 +1,14 @@
+CHANGES
+README
+MANIFEST
+install.rb
+win32-process.gemspec
+
+examples/test_create.rb
+examples/test_fork_wait.rb
+examples/test_fork_waitpid.rb
+examples/test_kill.rb
+
+lib/win32/process.rb
+
+test/tc_process.rb

data/README

@@ -0,0 +1,118 @@
+= Description
+   This package provides the fork, wait, wait2, waitpid, and waitpid2 methods
+   for MS Windows.  In addition, it provides a different implementation of the
+   kill method.
+
+= Prerequisites
+   Ruby 1.8.2 or later.
+   The 'windows-pr' package 0.5.2 or later.
+   The 'sys-proctable' package 0.7.0 or later (test suite only).
+
+= Supported Platforms
+   This code is supported on Windows NT, Windows 2000 or Windows XP Pro only.
+   It may work on Windows XP Home, but it is not officially supported for that
+   platform.
+
+= Installation Instructions
+== Manual Installation
+   ruby test/tc_process.rb (optional)
+   ruby install.rb
+== Gem Installation
+   ruby win32-process.gemspec
+   win32-process-X.Y.Z-mswin32.gem
+
+= Synopsis
+   require 'win32/process'
+
+   Process.fork{
+      3.times{
+         puts 'In the child'
+         sleep 1
+      }
+   }
+
+   Process.wait
+   puts 'Done'
+	
+= Developer's Notes
+== The fork and wait methods
+   The fork method is emulated on Win32 by spawning a another Ruby process
+   against $PROGRAM_NAME via the CreateProcess() Win32 API function.  It will
+   use its parent's environment and starting directory.
+	
+   The various wait methods are a wrapper for the WaitForSingleObject() or
+   WaitForMultipleObjects() Win32 API functions, for the wait* and waitpid*
+   methods, respectively.  In the case of wait2 and waitpid2, the exit value
+   is returned via the GetExitCodeProcess() Win32API function.
+	
+   For now the waitpid and waitpid2 calls do not accept a second argument.
+   That's because we haven't yet determined if there's a signal we should
+   allow to be sent.
+
+   IMPORTANT!	
+   Note that because fork is calling CreateProcess($PROGRAM_NAME), it will
+   start again from the top of the script instead of from the point of the
+   call.  We will try to address this in a future release, if possible.
+	
+== The kill method
+   Initially, the kill method will try to get a HANDLE on the PID using the
+   OpenProcess() function.  If that succeeds, we know the process is running.
+
+   In the event of signal 2 or signal 3, the GenerateConsoleCtrlEvent()
+   function is used to send a signal to that process.  These will not kill
+   GUI processes.  It will not (currently) send a signal to remote
+   processes.
+
+   In the event of signal 1 or 4-8, the CreateRemoteThread() function is used
+   after the HANDLE's process has been identified to create a thread
+   within that process.  The ExitProcess() function is then sent to that
+   thread.
+
+   In the event of signal 9, the TerminateProcess() function is called.  This
+   will almost certainly kill the process, but doesn't give the process a
+   chance to necessarily do any cleanup it might otherwise do.
+
+== Differences between Ruby's kill and the Win32 Utils kill
+   Ruby does not currently use the CreateRemoteThread() + ExitProcess()
+   approach which is, according to everything I've read, a cleaner approach.
+   This includes not only online research but also Jeffrey Richter's
+   "Advanced Windows Programming, 3rd Edition."
+	
+   Also, the way kill handles multiple pids works slightly differently (and
+   better IMHO) in the Win32 Utils version than the way Ruby currently
+   provides.
+
+   The reason Process.kill was originally added, in case anyone cares for
+   historical trivia, is that Ruby 1.6.x did not support Process.kill on
+   Windows at all.
+	
+== Notes
+   It is unlikely you will be able to kill system processes with this module.
+   It's probably better that you don't.
+	
+== Known Bugs	
+   None known (though please see the +Details+ section for quirks).  Any
+   bugs should be reported on the project page at
+   http://rubyforge.org/projects/win32utils.
+	
+== Future Plans  
+   Train Process.fork to execute from the point of the call rather than the
+   top of the script (if possible).
+	
+   Other suggestions welcome.
+	
+== License
+   Ruby's
+	
+== Copyright
+   (C) 2003-2006 Daniel J. Berger
+   All Rights Reserved
+		
+== Warranty
+   This package is provided "as is" and without any express or
+   implied warranties, including, without limitation, the implied
+   warranties of merchantability and fitness for a particular purpose.
+	
+== Author(s)
+   Park Heesob	
+   Daniel J. Berger

data/lib/win32/process.rb

@@ -0,0 +1,563 @@
+require 'windows/error'
+require 'windows/process'
+require 'windows/synchronize'
+require 'windows/handle'
+require 'windows/library'
+require 'windows/console'
+require 'windows/window'
+
+class ProcessError < RuntimeError; end
+
+module Process
+   WIN32_PROCESS_VERSION = '0.5.1'
+   
+   include Windows::Process
+   include Windows::Error
+   include Windows::Library
+   include Windows::Console
+   include Windows::Handle
+   include Windows::Synchronize
+   include Windows::Window
+   extend Windows::Error
+   extend Windows::Process
+   extend Windows::Synchronize
+   extend Windows::Handle
+   extend Windows::Library
+   extend Windows::Console
+   
+   # 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
+
+   # Waits for the given child process to exit and returns that pid.
+   # 
+   # Note that the $? (Process::Status) global variable is NOT set.  This
+   # may be addressed in a future release.
+   # 
+   def waitpid(pid)
+      exit_code = [0].pack('L')
+      handle = OpenProcess(PROCESS_ALL_ACCESS, 0, pid)
+      
+      if handle == INVALID_HANDLE_VALUE
+         raise ProcessError, get_last_error
+      end
+      
+      # TODO: update the $? global variable (if/when possible)
+      status = WaitForSingleObject(handle, INFINITE)
+      
+      unless GetExitCodeProcess(handle, exit_code)
+         raise ProcessError, get_last_error
+      end
+      
+      CloseHandle(handle)
+      @child_pids.delete(pid)
+      
+      # TODO: update the $? global variable (if/when possible)
+      exit_code = exit_code.unpack('L').first
+      
+      pid
+   end
+   
+   # Waits for the given child process to exit and returns an array containing
+   # the process id and the exit status.
+   # 
+   # Note that the $? (Process::Status) global variable is NOT set.  This
+   # may be addressed in a future release.
+   # 
+   def waitpid2(pid)
+      exit_code = [0].pack('L')
+      handle    = OpenProcess(PROCESS_ALL_ACCESS, 0, pid)
+      
+      if handle == INVALID_HANDLE_VALUE
+         raise ProcessError, get_last_error
+      end
+      
+      # TODO: update the $? global variable (if/when possible)
+      status = WaitForSingleObject(handle, INFINITE)
+      
+      unless GetExitCodeProcess(handle, exit_code)
+         raise ProcessError, get_last_error
+      end
+      
+      CloseHandle(handle)
+      @child_pids.delete(pid)
+      
+      # TODO: update the $? global variable (if/when possible)
+      exit_code = exit_code.unpack('L').first
+      
+      [pid, status]
+   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 ProcessError, "Invalid signal '#{signal}'"
+      end
+      
+      killed_pids = []
+      
+      pids.each{ |pid|
+         # Send the signal to the current process if the pid is zero
+         if pid == 0
+            pid = Process.pid
+         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)
+         end
+         
+         case signal
+            when 0   
+               if handle != 0
+                  killed_pids.push(pid)
+                  CloseHandle(handle)
+               else
+                  # If ERROR_ACCESS_DENIED is returned, we know it's running
+                  if GetLastError() == ERROR_ACCESS_DENIED
+                     killed_pids.push(pid)
+                  else
+                     raise ProcessError, 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)
+                  CloseHandle(handle)
+                  killed_pids.push(pid)
+                  @child_pids.delete(pid)           
+               else
+                  raise ProcessError, get_last_error
+               end
+            else
+               if handle != 0
+                  thread_id = [0].pack('L')
+                  dll       = 'kernel32'
+                  proc      = 'ExitProcess'
+                  
+                  thread = CreateRemoteThread(
+                     handle,
+                     0,
+                     0,
+                     GetProcAddress(GetModuleHandle(dll), proc),
+                     0,
+                     0,
+                     thread_id
+                  )
+                  
+                  if thread
+                     WaitForSingleObject(thread, 5)
+                     CloseHandle(handle)
+                     killed_pids.push(pid)
+                     @child_pids.delete(pid)
+                  else
+                     CloseHandle(handle)
+                     raise ProcessError, get_last_error
+                  end
+               else
+                  raise ProcessError, get_last_error
+               end
+               @child_pids.delete(pid)
+         end
+      }
+      
+      killed_pids
+   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 six primary keys:
+	#
+   # * app_name         (mandatory)
+   # * 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)
+	#
+   # Of these, the 'app_name' must be specified or an error is raised.
+	#
+   # 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
+   # 
+   # 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 package, a prerequisite of this
+   # package.
+   # 
+   # 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 newly created
+   #                    process.
+   # * process_id     - Process ID.
+   # * thread_id      - Thread ID.
+   #
+   def create(args)
+      unless args.kind_of?(Hash)
+         raise TypeError, 'Expecting hash-style keyword arguments'
+      end
+      
+      valid_keys = %w/
+         app_name inherit creation_flags cwd environment startup_info
+         thread_inherit process_inherit
+      /
+
+      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 some default values
+      hash = {
+         'inherit'          => 0,
+         'process_inherit'  => 0,
+         'thread_inherit'   => 0,
+         'creation_flags'   => 0,
+         'cwd'              => 0
+      }
+      env = 0
+      
+      # 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 ProcessError, "invalid key '#{key}'"
+         end
+         
+         # Convert true to 1 and nil/false to 0.
+         case val
+            when true, false
+               hash[key] = val == false ? 0 : 1
+            when nil
+               hash[key] = 0 # Win32API no likey nil
+            else
+               hash[key] = val
+         end
+      }
+      
+      si_hash = {}
+      
+      # 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 ProcessError, "invalid startup_info key '#{key}'"
+            end
+            si_hash[key] = val
+         }
+      end
+      
+      # The +app_name+ key is mandatory
+      unless hash['app_name']
+         raise ProcessError, 'app_name must be specified'
+      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
+         env = [env.join("\0")].pack('p*').unpack('L').first
+      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] = [hash['process_inherit?']].pack('L')
+      end
+
+      # Thread SECURITY_ATTRIBUTE structure
+      thread_security = 0
+      if hash['thread_security?']
+         thread_security = [0,0,0].pack('LLL')
+         thread_security[0,4] = [12].pack('L') # sizeof(SECURITY_ATTRIBUTE)
+         thread_security[8,4] = [hash['thread_inherit?']].pack('L')
+      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
+
+      bool = CreateProcess(
+         0,                      # App name
+         hash['app_name'],       # 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
+      )
+      
+      unless bool
+         raise ProcessError, "CreateProcess() failed: ", get_last_error
+      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.
+   # 
+   # 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
+      handles = []
+      
+      # Windows 2000 or earlier
+      unless defined? GetProcessId
+         pids = []
+      end
+      
+      @child_pids.each_with_index{ |pid, i|
+         handles[i] = OpenProcess(PROCESS_ALL_ACCESS, 0, pid)
+         
+         if handles[i] == INVALID_HANDLE_VALUE
+            err = "unable to get HANDLE on process associated with pid #{pid}"
+            raise ProcessError, err
+         end
+         
+         unless defined? GetProcessId
+            pids[i] = pid
+         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{ |handle| CloseHandle(handle) }
+         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.
+   # 
+   # 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
+      handles = []
+      
+      # Windows 2000 or earlier
+      unless defined? GetProcessId
+         pids = []
+      end
+      
+      @child_pids.each_with_index{ |pid, i|
+         handles[i] = OpenProcess(PROCESS_ALL_ACCESS, 0, pid)
+         
+         if handles[i] == INVALID_HANDLE_VALUE
+            err = "unable to get HANDLE on process associated with pid #{pid}"
+            raise ProcessError, err
+         end
+         
+         unless defined? GetProcessId
+            pids[i] = pid
+         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
+         
+         exit_code = [0].pack('l')
+         unless GetExitCodeProcess(handle, exit_code)
+            raise get_last_error
+         end
+         
+         @child_pids.delete(pid)
+         
+         handles.each{ |handle| CloseHandle(handle) }
+         return [pid, exit_code.unpack('l').first]
+      end
+      
+      nil
+   end
+
+   # 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.
+   # 
+   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
+               end
+            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(0, cmd, 0, 0, 1, 0, 0, 0, startinfo, procinfo)
+      
+      if rv == 0
+         raise ProcessError, get_last_error
+      end
+      
+      pid = procinfo[8,4].unpack('L').first
+      @child_pids.push(pid)
+      
+      pid 
+   end
+   
+   module_function :kill, :wait, :wait2, :waitpid, :waitpid2, :create, :fork
+end
+
+# Create a global fork method
+module Kernel
+   def fork(&block)
+      Process.fork(&block)
+   end
+end

data/test/tc_process.rb

@@ -0,0 +1,134 @@
+###############################################################################
+# tc_process.rb
+#
+# Test suite for the win32-process package.  This test suite will start
+# at least two instances of Notepad on your system, which will then
+# be killed. Requires the sys-proctable package.
+#
+# I haven't added a lot of test cases for fork/wait because it's difficult
+# to run such tests without causing havoc with TestUnit itself.  Ideas
+# welcome.
+###############################################################################
+Dir.chdir('..') if File.basename(Dir.pwd) == 'test'
+$LOAD_PATH.unshift Dir.pwd
+$LOAD_PATH.unshift Dir.pwd + '/lib'
+Dir.chdir('test') rescue nil
+
+require 'test/unit'
+require 'win32/process'
+
+begin
+   require 'sys/proctable'
+rescue LoadError => e
+   site = 'http://www.rubyforge.org/projects/sysutils'
+   STDERR.puts "Stopping!"
+   STDERR.puts "The sys/proctable module is required to run this test suite."
+   STDERR.puts "You can find it at #{site} or the RAA"
+   exit!
+end   
+
+include Sys
+
+IO.popen("notepad")
+IO.popen("notepad")
+sleep 1
+
+$pids = []
+ProcTable.ps{ |s|
+   next unless s.comm =~ /notepad/i
+   $pids.push(s.pid)
+}
+
+class TC_Win32Process < Test::Unit::TestCase  
+   def setup
+      @pids = $pids
+      @pid = nil
+   end
+  
+   def test_version
+      assert_equal('0.5.1', Process::WIN32_PROCESS_VERSION)
+   end
+   
+   def test_kill
+      assert_respond_to(Process, :kill)
+   end
+   
+   def test_kill_expected_errors
+      assert_raises(ArgumentError){ Process.kill }
+      assert_raises(ProcessError){ Process.kill('SIGBOGUS') }
+      assert_raises(ProcessError){ Process.kill(0,9999999) }
+   end
+   
+   def test_kill_signal_0
+      pid = @pids.first
+      assert_nothing_raised{ Process.kill(0, pid) }
+   end
+   
+   def test_kill_signal_1
+      pid = @pids.shift
+      assert_nothing_raised{ Process.kill(1, pid) }
+   end
+   
+   def test_kill_signal_9
+      pid = @pids.pop
+      msg = "Could not find pid #{pid}"
+      assert_nothing_raised(msg){ Process.kill(9,pid) }
+   end
+
+   def test_fork
+      assert_respond_to(Process, :fork)
+   end
+      	
+   def test_create
+      assert_respond_to(Process, :create)
+      assert_nothing_raised{
+         @pid = Process.create(
+            :app_name         => "notepad.exe",
+            :creation_flags   => Process::DETACHED_PROCESS,
+            :process_inherit  => false,
+            :thread_inherit   => true,
+            :cwd              => "C:\\"
+         ).process_id
+      }
+      assert_nothing_raised{ Process.kill(1, @pid) }
+   end
+   
+   def test_create_expected_errors
+      assert_raises(TypeError){ Process.create("bogusapp.exe") }
+      assert_raises(ProcessError){ Process.create(:app_name => "bogusapp.exe") }
+   end
+   
+   def test_wait
+      assert_respond_to(Process, :wait)
+   end
+   
+   def test_wait2
+      assert_respond_to(Process, :wait2)
+   end
+   
+   def test_waitpid
+      assert_respond_to(Process, :waitpid)
+   end
+   
+   def test_waitpid2
+      assert_respond_to(Process, :waitpid2)
+   end
+  	
+   def test_creation_constants
+      assert_not_nil(Process::CREATE_DEFAULT_ERROR_MODE)
+      assert_not_nil(Process::CREATE_NEW_CONSOLE)
+      assert_not_nil(Process::CREATE_NEW_PROCESS_GROUP)
+      assert_not_nil(Process::CREATE_NO_WINDOW)
+      assert_not_nil(Process::CREATE_SEPARATE_WOW_VDM)
+      assert_not_nil(Process::CREATE_SHARED_WOW_VDM)
+      assert_not_nil(Process::CREATE_SUSPENDED)
+      assert_not_nil(Process::CREATE_UNICODE_ENVIRONMENT)
+      assert_not_nil(Process::DEBUG_ONLY_THIS_PROCESS)
+      assert_not_nil(Process::DEBUG_PROCESS)
+      assert_not_nil(Process::DETACHED_PROCESS)
+   end
+   
+   def teardown
+      @pids = []
+   end     
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: win32-process
+version: !ruby/object:Gem::Version 
+  version: 0.5.1
+date: 2006-08-24 00:00:00 -06:00
+summary: Adds fork, wait, wait2, waitpid, waitpid2 and a special kill method
+require_paths: 
+- lib
+email: djberg96@gmail.com
+homepage: http://www.rubyforge.org/projects/win32utils
+rubyforge_project: 
+description: Adds fork, wait, wait2, waitpid, waitpid2 and a special kill method
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Daniel J. Berger
+files: 
+- lib/win32/process.rb
+- test/CVS
+- test/tc_process.rb
+- CHANGES
+- CVS
+- MANIFEST
+- README
+test_files: 
+- test/tc_process.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+- CHANGES
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: windows-pr
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.5.2
+    version: