win32-open3 0.3.2-x86-mingw32

data/CHANGES

@@ -0,0 +1,81 @@
+== 0.3.2 - 23-Jan-2010
+* Updated the gemspec. The required version is now any version less
+  than 1.9.x. This library is for the 1.8.x branch only.
+* The Rakefile now handles the gem building and installation and some
+  existing tasks were refactored.
+
+== 0.3.1 - 23-Jun-2009
+* Updated the license to Artistic 2.0
+* Set the license in the gemspec.
+* Added note regarding 1.9.x in the open3.txt file.
+
+== 0.3.0 - 22-Jun-2009
+* Fixed an issue where the block form of the Open3.popen3 method did not
+  return the exit value.
+* Fixed the version number.
+* Added a test to validate the exit value in block form.
+* Updated the gemspec description.
+
+== 0.2.9 - 8-Mar-2009
+* Fixed a bug within an internal function that could cause an exception.
+  Thanks go to Ross Bunker for the spot and patch.
+* Fixed the release dates for 0.2.7 and 0.2.8 (2009, not 2008).
+
+== 0.2.8 - 27-Feb-2009
+* Fixed a potential bug where nil might be returned instead of an actual
+  Process::Status object. Thanks go to Benny Bach for the spot.
+* The 'test' Rake task now runs the 'clean' task after the fact.
+* Some updates to the README about precompiled binaries.
+
+== 0.2.7 - 11-Jan-2009
+* Fixed a bug that could cause exitstatus to return bogus information. Thanks
+  go to Roman Zawada for the spot.
+* Added a 'build_binary_gem' Rake task.
+* Updates to the gemspec, including the addition of Park Heesob as the primary
+  author in the gemspec.
+* Renamed the test file and the example file.
+
+== 0.2.6 - 1-June-2007
+* Fixed RubyForge bug #20455 (closed IO stream). Thanks go an anonymous user
+  for the spot.
+* Added a Rakefile with tasks for building, testing and installation.
+* Minor updates to the test file.
+* Some minor rdoc improvements.
+
+== 0.2.5 - 8-Dec-2006
+* Added a WIN32_OPEN3_VERSION constant.
+* Fixes and updates to the gemspec.
+* Some internal reorganization.
+* Minor documentation updates and corrections.
+
+== 0.2.4 - 4-Jun-2006
+* Applied a patch for Windows 2000.  Thanks again to John-Mason Shackelford
+  for the patch.
+* Fixed the version number for the last release.
+
+== 0.2.3 - 3-Jun-2006
+* Now sets Process::Status when the block form is used.  Thanks go to
+  Samuel Tesla and John-Mason Shackelford for their patches.
+* Improved error messages.
+* Documentation updated with regards to the block form of the method calls.
+* Some internal reorganization that you don't care about.
+
+== 0.2.2 - 10-Feb-2006
+* Methods now support block form, and all handles are automatically closed
+  at the end of the block (via ensure).
+
+== 0.2.1 - 27-Oct-2005
+* Added a type check in the extconf.rb file and did some type mangling in
+  order to handle rb_pid_t in a backwards compatible way.  In other words,
+  you need this version to work with 1.8.3 or later.
+
+== 0.2.0 - 9-Jan-2005
+* Added the Open4 module and popen4 method.  Thanks go to Aslak Hellesoy for
+  the patch.
+* Added an optional 3rd parameter - the "show" flag.  See docs for details.
+* Made some documentation more rdoc friendly.
+* Moved the "examples" directory to the toplevel directory.
+* Added some information to the README file about possible compiler problems.
+
+== 0.1.0 - 8-Oct-2004
+* Initial release

data/MANIFEST

@@ -0,0 +1,11 @@
+* CHANGES
+* MANIFEST
+* README
+* Rakefile
+* win32-open3.gemspec
+* doc/open3.txt
+* examples/open3_test.rb
+* ext/extconf.rb
+* ext/win32/open3.c
+* ext/win32/open3.h
+* test/test_win32_open3.rb

data/README

@@ -0,0 +1,64 @@
+= Description
+  This library provides an Open3.popen3 implementation for MS Windows for
+  the Ruby 1.8.x branch.
+
+= Prerequisites
+  Ruby 1.8.x branch only
+  C++ compiler (if building from source)
+   
+= Installation
+  gem install win32-open3                    # Build and install from source
+  gem install win32-open3 --platform mingw # Install the binary gem
+   
+= Synopsis
+  require 'win32/open3'
+	
+  Open3.popen3('ver'){ |io_in, io_out, io_err|
+    error = io_err.gets
+
+    if error
+      puts "Error: " + error.chomp
+      exit
+    end
+
+    puts "Result: " + io_out.readlines.last.chomp
+  }
+
+= Notes
+  This library is not supported on Windows 95, 98, or ME.
+  This is a stripped down version of Park Heesob's win32_popen library.
+
+= Developer's Notes
+  This is a repackaging of Heesob's win32_popen module. The purpose of the
+  repackaging was to create a unified API between the existing Ruby open3
+  library and this library.
+
+  The popen2 and posix_popen methods are not included in this release. They
+  were originally part of the win32_popen module, but have been left out.
+  They may be added back in at a later date.
+
+  There are a couple of differences in the Windows version for open3 (which
+  also apply to Open4.popen4) - the mode flag and the show flag.  For the
+  mode, you can specify either 't' (text, the default) or 'b' (binary) as a
+  second argument. For the show flag, you can specify either true or false,
+  which will show the console window, or not, depending on the value you
+  pass.  The default is false.
+
+= Known Issues
+  I have noticed that this library (and others) may segfault if you are using
+  the latest version of the Ruby one-click installer and VC++ 7.0 or later.
+  This appears to be an issue between VC++ 6 (which the installer was built
+  with) and VC++ 7.0. Your best solution is to either upgrade your C
+  compiler or to rebuild Ruby from scratch rather than using the installer.
+   
+= Precompiled binaries
+  If you do a typical "gem install win32-open3" you will get a precompiled
+  binary appropriate for your platform. If you want to build from source,
+  go the project page and download, download the .zip file, and run the
+  'install' Rake task from the command line.
+   
+= Future Plans
+  Replace the current implementation with a pure Ruby version, if possible.
+ 
+= More Documentation
+  See the doc/open3.txt file for more details.

data/Rakefile

@@ -0,0 +1,98 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rbconfig'
+include Config
+
+make = CONFIG['MAKEFILES'].nil? ? 'nmake' : 'make'
+
+desc 'Install the win32-open3 library'
+task :install => [:build] do
+  Dir.chdir('ext'){
+    sh "#{make} install"
+  }
+end
+
+desc "Clean any build files for win32-open3"
+task :clean do
+  Dir.chdir('ext') do
+    if File.exists?('open3.so') || File.exists?('win32/open3.so')
+      sh "#{make} distclean"
+      rm 'win32/open3.so' if File.exists?('win32/open3.so') 
+    end
+  end
+  rm_rf 'lib'
+end
+
+desc "Build win32-open3 (but don't install it)"
+task :build => [:clean] do
+  Dir.chdir('ext') do
+    ruby 'extconf.rb'
+    sh make
+    mv 'open3.so', 'win32' # For the test suite
+  end
+end
+
+desc "Run the sample program"
+task :example => [:build] do |t|
+  Dir.chdir('examples'){
+    sh 'ruby -I../ext open3_test.rb'
+  }
+end
+
+namespace 'gem' do
+  desc 'Clean any build files and remove the .gem file'
+  task :clean do
+    Dir["*.gem"].each{ |f| File.delete(f) }
+    Dir.chdir('ext') do
+      if File.exists?('open3.so') || File.exists?('win32/open3.so')
+        sh "#{make} distclean"
+        rm 'win32/open3.so' if File.exists?('win32/open3.so') 
+      end
+    end
+  end
+
+  desc 'Build the gem'
+  task :build => [:clean] do
+    spec = eval(IO.read('win32-open3.gemspec'))
+    Gem::Builder.new(spec).build
+  end
+
+  desc 'Install the win32-open3 library as a gem'
+  task :install => [:build] do
+    file = Dir["*.gem"].first
+    sh "gem install #{file}"
+  end
+
+  desc 'Build a binary gem'
+  task :binary => [:clean] do
+    Dir.chdir('ext') do
+      ruby 'extconf.rb'
+      sh make
+    end
+
+    mkdir_p 'lib/win32'
+    mv 'ext/open3.so', 'lib/win32'
+
+    spec = eval(IO.read('win32-open3.gemspec'))
+    spec.extensions = nil
+    spec.platform = Gem::Platform::CURRENT
+
+    spec.files = Dir['**/*'].reject{ |file|
+      file.include?('ext') || file.include?('git')
+    }
+
+    Gem::Builder.new(spec).build
+  end
+end
+
+Rake::TestTask.new('test') do |test|
+  task :test => [:build]
+  test.libs << 'ext'
+  test.warning = true
+  test.verbose = true
+end
+
+task :test do
+  Rake.application[:clean].execute
+end

data/doc/open3.txt

@@ -0,0 +1,79 @@
+= Description
+  An open3 library for MS Windows for the Ruby 1.8.x branch.
+	
+= Synopsis
+  require 'win32/open3'
+	
+  Open3.popen3('ver'){ |io_in, io_out, io_err|
+    error = io_err.gets
+    if error
+      puts "Error: " + error.chomp
+      exit
+    end
+    puts "Result: " + io_out.readlines.last.chomp
+  }
+
+= Module functions
+Open3.popen3(command, mode='t', show=false)
+
+Open3.popen3(command, mode='t', show=false){ |io_in, io_out, io_err| ... }
+
+  Executes 'command', returning an array of three IO handles representing
+  STDIN, STDOUT and STDERR, respectively.  In block form these IO handles
+  are yielded back to the block and automatically closed at the end of the
+  block.
+	
+  You may optionally pass a mode flag of 't' (text, the default) or 'b'
+  (binary) to this method.
+	
+  If the 'show' variable is set to true, then a console window is shown.
+
+Open4.popen4(command, mode='t', show=false)
+
+Open4.popen4(command, mode='t', show=false){ |io_in, io_out, io_err, pid| ... }
+   
+  Executes 'command', returning an array consisting of three IO handles,
+  representing STDIN, STDOUT and STDERR, respectively, as well as the PID
+  of the newly generated process.  In block form these IO handles and pid
+  are yielded back to the block and automatically closed at the end of the
+  block.
+	
+  You may optionally pass a mode flag of 't' (text, the default) or 'b'
+  (binary) to this method.
+	
+  If the 'show' variable is set to true, then a console window is shown.
+	
+= Notes
+  This is a remake of Park Heesob's win32_popen package.  It has been reworked
+  in order to make the API (nearly) identical to the Open3 package currently
+  included in the Ruby standard library.
+	
+  For now only the popen3 and popen4 methods have been included.  In later
+  releases we will probably add the popen2 and posix_popen methods back in.
+   
+  Ruby 1.9.x users will not generally need this library because of its support
+  for native threads. That means you can use the open3 library that ships as
+  part of the standard library.
+
+= Acknowledgements
+  Thanks go to Samuel Tesla and John-Mason Shackelford for their patches that
+  enabled us to set Process::Status.
+	
+= Known Bugs  
+  None that I know of.  Please log any other bug reports on the RubyForge
+  project page at http://www.rubyforge.net/projects/win32utils.
+      
+= License
+  Artistic 2.0
+        
+= Copyright
+  (C) 2003-2010 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.
+	
+= Authors
+  Park Heesob
+  Daniel J. Berger

data/examples/win32_open3_example.rb

@@ -0,0 +1,34 @@
+##############################################################################
+# win32_open3_example.rb
+#
+# Test script for the win32-open3 library. You should run this via the
+# 'rake example' Rakefile task.
+#
+# Modify as you see fit.
+##############################################################################
+require 'win32/open3'
+
+puts "VERSION: " + Open3::WIN32_OPEN3_VERSION
+
+cmd1 = 'ver'   # valid
+cmd2 = 'verb'  # invalid
+cmd3 = "ruby -e 'exit 1'" # valid, with explicit exit status
+
+# Try each command as you like...
+Open3.popen3(cmd3){ |io_in, io_out, io_err|
+   error = io_err.read
+   if error && error.length > 0
+      puts 'Error: ' + error
+      break
+   else
+      output = io_out.read
+      puts 'Output: ' + output if output
+   end
+}
+
+p $?.class
+p $? >> 8
+p $?.stopped?
+p $?.exited?
+p $?.exitstatus
+p $?.pid

data/ext/win32/open3.c

@@ -0,0 +1,567 @@
+/***************************************************
+ * open3.c
+ *
+ * Source for the win32-open3 extension.
+ ***************************************************/
+#include "ruby.h"
+
+#ifdef HAVE_RUBY_IO_H
+#include "ruby/io.h"
+#else
+#include "rubysig.h"
+#include "rubyio.h"
+#endif
+
+#include "open3.h"
+
+#include <malloc.h>
+#include <io.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+
+// Necessary to work with Ruby 1.8.3 or later
+#ifdef HAVE_TYPE_RB_PID_T
+#define pid_t rb_pid_t
+#endif
+
+// Ruby 1.9.x
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(a) (RARRAY(a)->ptr)
+#endif
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(a) (RARRAY(a)->len)
+#endif
+
+static VALUE win32_last_status = Qnil;
+static HANDLE pid_handle = NULL;
+
+static VALUE ruby_popen(char *, int, VALUE);
+
+static int rb_io_mode_flags2(int mode){
+   int flags;
+
+   switch (mode & (O_RDONLY|O_WRONLY|O_RDWR)) {
+      case O_RDONLY:
+         flags = FMODE_READABLE;
+         break;
+      case O_WRONLY:
+         flags = FMODE_WRITABLE;
+         break;
+      case O_RDWR:
+         flags = FMODE_WRITABLE|FMODE_READABLE;
+         break;
+   }
+
+#ifdef O_BINARY
+   if(mode & O_BINARY)
+      flags |= FMODE_BINMODE;
+#endif
+
+   return flags;
+}
+
+static char* rb_io_modenum_mode(int flags, char* mode){
+    char *p = mode;
+
+    switch(flags & (O_RDONLY|O_WRONLY|O_RDWR)){
+      case O_RDONLY:
+         *p++ = 'r';
+         break;
+      case O_WRONLY:
+         *p++ = 'w';
+         break;
+      case O_RDWR:
+         *p++ = 'r';
+         *p++ = '+';
+         break;
+   }
+
+   *p++ = '\0';
+
+#ifdef O_BINARY
+   if(flags & O_BINARY){
+      if(mode[1] == '+'){
+         mode[1] = 'b';
+         mode[2] = '+';
+         mode[3] = '\0';
+      }
+      else{
+         mode[1] = 'b'; mode[2] = '\0';
+      }
+   }
+#endif
+   return mode;
+}
+
+/* Used to close io handle */
+static VALUE io_close(VALUE val) {
+   int i;
+
+   for(i = 0; i < 3; i++){
+      if(rb_funcall(RARRAY_PTR(val)[i], rb_intern("closed?"), 0) == Qfalse)
+         rb_funcall(RARRAY_PTR(val)[i], rb_intern("close"), 0);
+   }
+
+   return Qnil;
+}
+
+/*
+ * call-seq:
+ *    Open3.popen3(cmd, mode='t', show=false)
+ *    Open3.popen3(cmd, mode='t', show=false){ |io_in, io_out, io_err| ... }
+ *
+ * Executes 'command', returning an array of three IO handles representing
+ * STDIN, STDOUT and STDERR, respectively.  In block form these IO handles
+ * are yielded back to the block and automatically closed at the end of the
+ * block.
+ *
+ * You may optionally pass a mode flag of 't' (text, the default) or 'b'
+ * (binary) to this method.
+ *
+ * If the 'show' variable is set to true, then a console window is shown.
+ */
+static VALUE win32_popen3(int argc, VALUE *argv, VALUE klass)
+{
+   VALUE v_name, v_mode, v_port;
+   VALUE v_show_window = Qfalse;
+   char mbuf[4];
+   int tm = 0;
+   char *mode = "t";
+
+   rb_scan_args(argc, argv, "12", &v_name, &v_mode, &v_show_window);
+
+   // Mode can be either a string or a number
+   if(!NIL_P(v_mode)){
+      if(FIXNUM_P(v_mode))
+         mode = rb_io_modenum_mode(FIX2INT(v_mode), mbuf);
+      else
+         mode = StringValuePtr(v_mode);
+   }
+
+   if(*mode == 't')
+      tm = _O_TEXT;
+   else if(*mode != 'b')
+      rb_raise(rb_eArgError, "popen3() arg 2 must be 't' or 'b'");
+   else
+      tm = _O_BINARY;
+
+   v_port = ruby_popen(StringValuePtr(v_name), tm, v_show_window);
+
+   // Ensure handles are closed in block form
+   if(rb_block_given_p()){
+      return rb_ensure(rb_yield_splat, v_port, io_close, v_port);
+   }
+
+   return v_port;
+}
+
+static BOOL RubyCreateProcess(char *cmdstring, HANDLE hStdin, HANDLE hStdout,
+   HANDLE hStderr, HANDLE *hProcess, pid_t *pid, VALUE v_show_window)
+{
+   PROCESS_INFORMATION piProcInfo;
+   STARTUPINFO siStartInfo;
+   char *s1,*s2, *s3 = " /c ";
+   int i, x;
+
+   if(i = GetEnvironmentVariable("COMSPEC", NULL, 0)){
+      char *comshell;
+      s1 = (char *)_alloca(i);
+
+      if(!(x = GetEnvironmentVariable("COMSPEC", s1, i)))
+         return x;
+
+      /* Explicitly check if we are using COMMAND.COM. If we are
+       * then use the w9xpopen hack.
+       */
+      comshell = s1 + x;
+
+      while(comshell >= s1 && *comshell != '\\')
+         --comshell;
+
+      ++comshell;
+
+      // Windows 95, 98 and ME are not supported
+      if(GetVersion() < 0x80000000 && _stricmp(comshell, "command.com") != 0){
+         x = i + strlen(s3) + strlen(cmdstring) + 1;
+         s2 = ALLOCA_N(char, x);
+         sprintf(s2, "%s%s%s", s1, s3, cmdstring);
+      }
+      else{
+         rb_raise(rb_eRuntimeError,"not supported on this platform");
+      }
+   }
+   else{
+      // Could be an else here to try cmd.exe / command.com in the path.
+      // Now we'll just error out..
+      rb_raise(rb_eRuntimeError,
+         "Cannot locate a COMSPEC environment variable to use as the shell"
+      );
+      return FALSE;
+   }
+
+   ZeroMemory(&siStartInfo, sizeof(STARTUPINFO));
+
+   siStartInfo.cb = sizeof(STARTUPINFO);
+   siStartInfo.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
+   siStartInfo.hStdInput = hStdin;
+   siStartInfo.hStdOutput = hStdout;
+   siStartInfo.hStdError = hStderr;
+   siStartInfo.wShowWindow = SW_HIDE;
+
+   if(v_show_window == Qtrue)
+      siStartInfo.wShowWindow = SW_SHOW;
+
+   // Try the command first without COMSPEC
+   if(CreateProcess(
+      NULL,
+      cmdstring,
+      NULL,
+      NULL,
+      TRUE,
+      0,
+      NULL,
+      NULL,
+      &siStartInfo,
+      &piProcInfo)
+    ){
+      // Close the handles now so anyone waiting is woken.
+      CloseHandle(piProcInfo.hThread);
+
+      // Return process handle
+      *hProcess = piProcInfo.hProcess;
+      *pid = (pid_t)piProcInfo.dwProcessId;
+      return TRUE;
+   }
+
+   // If that failed, try again with COMSPEC
+   if(CreateProcess(
+      NULL,
+      s2,
+      NULL,
+      NULL,
+      TRUE,
+      CREATE_NEW_CONSOLE,
+      NULL,
+      NULL,
+      &siStartInfo,
+      &piProcInfo)
+    ){
+      // Close the handles now so anyone waiting is woken.
+      CloseHandle(piProcInfo.hThread);
+
+      // Return process handle
+      *hProcess = piProcInfo.hProcess;
+      *pid = (pid_t)piProcInfo.dwProcessId;
+      return TRUE;
+   }
+
+   rb_raise(rb_eRuntimeError, "CreateProcess() failed: %s",
+      ErrorDescription(GetLastError())
+   );
+
+   return FALSE;
+}
+
+/* Set the Process::Status. This code is based on patches by Samuel Tesla and
+ * John-Mason Shackelford.
+ */
+static void win32_set_last_status(const int status, const int pid)
+{
+  // rb_last_status is defined in process.c in the main ruby.exe
+  __declspec (dllimport) extern VALUE rb_last_status;
+  VALUE klass = rb_path2class("Process::Status");
+  VALUE process_status = rb_obj_alloc(klass);
+  rb_iv_set(process_status, "status", INT2FIX(status << 8));
+  rb_iv_set(process_status, "pid", INT2FIX(pid));
+  rb_last_status = process_status;
+  win32_last_status = process_status;
+}
+
+static void win32_pipe_finalize(OpenFile *file, int noraise)
+{
+   DWORD status;
+
+   if(file->f){
+      fclose(file->f);
+      file->f = NULL;
+   }
+
+   if(file->f2){
+      fclose(file->f2);
+      file->f2 = NULL;
+   }
+
+   if(pid_handle != NULL){
+      GetExitCodeProcess(pid_handle, &status);
+
+      if(status != STILL_ACTIVE){
+    	 CloseHandle(pid_handle);
+         pid_handle = NULL;
+         win32_set_last_status(status, file->pid);
+      }
+   }
+}
+
+// The following code is based off of KB: Q190351
+static VALUE ruby_popen(char *cmdstring, int mode, VALUE v_show_window)
+{
+   HANDLE hChildStdinRd, hChildStdinWr, hChildStdoutRd, hChildStdoutWr,
+     hChildStderrRd, hChildStderrWr, hChildStdinWrDup, hChildStdoutRdDup,
+     hChildStderrRdDup, hProcess;
+
+   pid_t pid;
+
+   SECURITY_ATTRIBUTES saAttr;
+   BOOL fSuccess;
+   int fd1, fd2, fd3;
+   FILE *f1, *f2, *f3;
+   long file_count;
+   VALUE port;
+   VALUE p1,p2,p3;
+   int modef;
+   OpenFile *fptr;
+   char *m1, *m2;
+
+   saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
+   saAttr.bInheritHandle = TRUE;
+   saAttr.lpSecurityDescriptor = NULL;
+
+   if(!CreatePipe(&hChildStdinRd, &hChildStdinWr, &saAttr, 0)) {
+      rb_raise(rb_eRuntimeError, "CreatePipe() failed: %s",
+         ErrorDescription(GetLastError())
+      );
+   }
+
+   /* Create new output read handle and the input write handle. Set
+    * the inheritance properties to FALSE. Otherwise, the child inherits
+    * the these handles; resulting in non-closeable handles to the pipes
+    * being created.
+    */
+   fSuccess = DuplicateHandle(
+      GetCurrentProcess(),
+      hChildStdinWr,
+      GetCurrentProcess(),
+      &hChildStdinWrDup,
+      0,
+      FALSE,
+      DUPLICATE_SAME_ACCESS
+   );
+
+   if(!fSuccess){
+      rb_raise(rb_eRuntimeError, "DuplicateHandle() failed: %s",
+         ErrorDescription(GetLastError())
+      );
+   }
+
+   // Close the inheritable version of ChildStdin that we're using
+   CloseHandle(hChildStdinWr);
+
+   if(!CreatePipe(&hChildStdoutRd, &hChildStdoutWr, &saAttr, 0)) {
+      rb_raise(rb_eRuntimeError, "CreatePipe() failed: %s",
+         ErrorDescription(GetLastError())
+      );
+   }
+
+   fSuccess = DuplicateHandle(
+      GetCurrentProcess(),
+      hChildStdoutRd,
+      GetCurrentProcess(),
+      &hChildStdoutRdDup,
+      0,
+      FALSE,
+      DUPLICATE_SAME_ACCESS
+   );
+
+   if(!fSuccess){
+      rb_raise(rb_eRuntimeError, "DuplicateHandle() failed: %s",
+         ErrorDescription(GetLastError())
+      );
+   }
+
+   // Close the inheritable version of ChildStdout that we're using.
+   CloseHandle(hChildStdoutRd);
+
+   if(!CreatePipe(&hChildStderrRd, &hChildStderrWr, &saAttr, 0)) {
+      rb_raise(rb_eRuntimeError, "CreatePipe() failed: %s",
+         ErrorDescription(GetLastError())
+      );
+   }
+
+   fSuccess = DuplicateHandle(
+      GetCurrentProcess(),
+      hChildStderrRd,
+      GetCurrentProcess(),
+      &hChildStderrRdDup,
+      0,
+      FALSE,
+      DUPLICATE_SAME_ACCESS
+   );
+
+   if (!fSuccess) {
+      rb_raise(rb_eRuntimeError, "DuplicateHandle() failed: %s",
+         ErrorDescription(GetLastError())
+      );
+   }
+
+   // Close the inheritable version of ChildStdErr that we're using.
+   CloseHandle(hChildStderrRd);
+
+   if(mode & _O_TEXT){
+      m1 = "r";
+      m2 = "w";
+   }
+   else{
+      m1 = "rb";
+      m2 = "wb";
+   }
+
+   // Convert HANDLE's into file descriptors and, ultimately, Ruby IO objects.
+   fd1 = _open_osfhandle((long)hChildStdinWrDup, mode);
+   f1 = _fdopen(fd1, m2);
+
+   fd2 = _open_osfhandle((long)hChildStdoutRdDup, mode);
+   f2 = _fdopen(fd2, m1);
+
+   fd3 = _open_osfhandle((long)hChildStderrRdDup, mode);
+   f3 = _fdopen(fd3, m1);
+
+   file_count = 3;
+
+   if(!RubyCreateProcess(cmdstring,hChildStdinRd,hChildStdoutWr,
+      hChildStderrWr, &hProcess, &pid, v_show_window))
+   {
+      return Qnil;
+   }
+
+   // I think this is only possible on Win9x, but we'll leave it here
+   if(pid < 0){
+      pid = -pid;
+   }
+
+   modef = rb_io_mode_flags(m2);
+   p1 =  io_alloc(rb_cIO);
+   MakeOpenFile(p1, fptr);
+
+   fptr->finalize = win32_pipe_finalize;
+   fptr->mode = modef;
+   fptr->pid = pid;
+
+   if(modef & FMODE_READABLE){
+      fptr->f  = f1;
+   }
+
+   if(modef & FMODE_WRITABLE){
+      if(fptr->f){
+         fptr->f2 = f1;
+      }
+      else{
+         fptr->f = f1;
+      }
+      fptr->mode |= FMODE_SYNC;
+   }
+
+   modef = rb_io_mode_flags(m1);
+   p2 = io_alloc(rb_cIO);
+   MakeOpenFile(p2, fptr);
+
+   pid_handle = hProcess;
+   fptr->finalize = win32_pipe_finalize;
+   fptr->mode = modef;
+   fptr->pid = pid;
+
+   if(modef & FMODE_READABLE){
+      fptr->f  = f2;
+   }
+   if(modef & FMODE_WRITABLE){
+      if(fptr->f){
+         fptr->f2 = f2;
+      }
+      else{
+         fptr->f = f2;
+      }
+      fptr->mode |= FMODE_SYNC;
+   }
+
+   modef = rb_io_mode_flags(m1);
+   p3 =  io_alloc(rb_cIO);
+   MakeOpenFile(p3, fptr);
+
+   fptr->finalize = win32_pipe_finalize;
+   fptr->mode = modef;
+   fptr->pid = pid;
+
+   if(modef & FMODE_READABLE){
+      fptr->f  = f3;
+   }
+
+   if(modef & FMODE_WRITABLE){
+      if(fptr->f){
+         fptr->f2 = f3;
+      }
+      else{
+         fptr->f = f3;
+      }
+      fptr->mode |= FMODE_SYNC;
+   }
+
+   port = rb_ary_new2(4);
+   rb_ary_push(port,(VALUE)p1);
+   rb_ary_push(port,(VALUE)p2);
+   rb_ary_push(port,(VALUE)p3);
+   rb_ary_push(port,UINT2NUM((DWORD)pid));
+
+  /* Child is launched. Close the parents copy of those pipe
+   * handles that only the child should have open.  You need to
+   * make sure that no handles to the write end of the output pipe
+   * are maintained in this process or else the pipe will not close
+   * when the child process exits and the ReadFile() will hang.
+   */
+
+   if(!CloseHandle(hChildStdinRd)){
+      rb_raise(rb_eRuntimeError, "CloseHandle() failed: %s",
+         ErrorDescription(GetLastError())
+      );
+   }
+
+   if(!CloseHandle(hChildStdoutWr)){
+      rb_raise(rb_eRuntimeError, "CloseHandle() failed: %s",
+         ErrorDescription(GetLastError())
+      );
+   }
+
+   if(!CloseHandle(hChildStderrWr)){
+      rb_raise(rb_eRuntimeError, "CloseHandle() failed: %s",
+         ErrorDescription(GetLastError())
+      );
+   }
+
+   return port;
+}
+
+/*
+ * Spawn an external program and retrieve the stdin, stdout and stderr IO
+ * handles, as well as the process ID. Use in block or non-block form.
+ */
+void Init_open3()
+{
+   VALUE mOpen3 = rb_define_module("Open3");
+
+   VALUE mOpen4 = rb_define_module("Open4");
+
+   rb_define_module_function(mOpen3, "popen3", win32_popen3, -1);
+   rb_define_module_function(mOpen4, "popen4", win32_popen3, -1);
+
+   /* 0.3.1: The version of this library */
+   rb_define_const(mOpen3, "WIN32_OPEN3_VERSION", rb_str_new2(WIN32_OPEN3_VERSION));
+
+   /* 0.3.1: The version of this library */
+   rb_define_const(mOpen4, "WIN32_OPEN3_VERSION", rb_str_new2(WIN32_OPEN3_VERSION));
+}

data/test/test_win32_open3.rb

@@ -0,0 +1,113 @@
+###########################################################################
+# test_win32_open3.rb
+#
+# Test suite for the win32-open3 library.  Except for the
+# 'test_open3_with_arguments' test and Open4 tests, this suite passes
+# on Unix as well.
+#
+# You should run this test suite via the 'rake test' task.
+###########################################################################
+require 'win32/open3'
+require 'test/unit'
+
+class TC_Win32_Open3 < Test::Unit::TestCase
+   def setup
+      @good_cmd = 'ver'
+      @bad_cmd  = 'verb'
+      @stdin    = nil
+      @stdout   = nil
+      @stderr   = nil
+      @value    = nil
+   end
+
+   def test_open3_version
+      assert_equal('0.3.1', Open3::WIN32_OPEN3_VERSION)
+      assert_equal('0.3.1', Open4::WIN32_OPEN3_VERSION)
+   end
+   
+   def test_open3_basic
+      assert_respond_to(Open3, :popen3)
+      assert_nothing_raised{ Open3.popen3(@good_cmd) }
+      assert_nothing_raised{ Open3.popen3(@bad_cmd) }
+   end
+   
+   def test_open4_basic
+      assert_respond_to(Open4, :popen4)
+      assert_nothing_raised{ Open4.popen4(@good_cmd) }
+      assert_nothing_raised{ Open4.popen4(@bad_cmd) }
+   end
+   
+   # This test would fail on other platforms
+   def test_open3_with_arguments
+      assert_nothing_raised{ Open3.popen3(@good_cmd, 't') }
+      assert_nothing_raised{ Open3.popen3(@bad_cmd, 't') }
+      assert_nothing_raised{ Open3.popen3(@good_cmd, 'b') }
+      assert_nothing_raised{ Open3.popen3(@bad_cmd, 'b') }
+      assert_nothing_raised{ Open3.popen3(@good_cmd, 't', false) }
+      assert_nothing_raised{ Open3.popen3(@good_cmd, 't', true) }
+   end
+   
+   def test_open3_handles
+      arr = Open3.popen3(@good_cmd)
+      assert_kind_of(Array, arr)
+      assert_kind_of(IO, arr[0])
+      assert_kind_of(IO, arr[1])
+      assert_kind_of(IO, arr[2])
+   end
+   
+   def test_open3_block
+      assert_nothing_raised{ Open3.popen3(@good_cmd){ |pin, pout, perr| } }
+      Open3.popen3(@good_cmd){ |pin, pout, perr|
+         assert_kind_of(IO, pin)
+         assert_kind_of(IO, pout)
+         assert_kind_of(IO, perr)
+      }
+   end
+   
+   def test_open4_block
+      assert_nothing_raised{ Open4.popen4(@good_cmd){ |pin, pout, perr, pid| } }
+      Open4.popen4(@good_cmd){ |pin, pout, perr, pid|
+         assert_kind_of(IO, pin)
+         assert_kind_of(IO, pout)
+         assert_kind_of(IO, perr)
+         assert_kind_of(Fixnum, pid)
+      }
+   end
+   
+   def test_open4_return_values
+      arr = Open4.popen4(@good_cmd)
+      assert_kind_of(Array,arr)
+      assert_kind_of(IO, arr[0])
+      assert_kind_of(IO, arr[1])
+      assert_kind_of(IO, arr[2])
+      assert_kind_of(Fixnum, arr[3])
+   end
+   
+   def test_handle_good_content
+      fin, fout, ferr = Open3.popen3(@good_cmd)
+      assert_kind_of(String, fout.gets)
+      assert_nil(ferr.gets)
+   end
+
+   def test_handle_bad_content
+      fin, fout, ferr = Open3.popen3(@bad_cmd)
+      assert_kind_of(String, ferr.gets)
+      assert_nil(fout.gets)
+   end
+   
+   def test_exit_status_in_block_form_popen4
+      assert_nothing_raised{ @value = Open3.popen3('dir'){ |x,y,z| 1 } }
+      assert_equal(1, @value)
+   end
+   
+   def test_exit_status_in_block_form_popen4
+      assert_nothing_raised{ @value = Open4.popen4('dir'){ |x,y,z,a| 1 } }
+      assert_equal(1, @value)
+   end
+   
+   def teardown
+      @good_cmd = nil
+      @bad_cmd  = nil
+      @value    = nil
+   end
+end

data/win32-open3.gemspec

@@ -0,0 +1,36 @@
+require 'rubygems'
+
+Gem::Specification.new do |spec|
+  spec.name       = 'win32-open3'
+  spec.version    = '0.3.2'
+  spec.authors    = ['Park Heesob', 'Daniel J. Berger']
+  spec.email      = 'djberg96@gmail.com'
+  spec.homepage   = 'http://www.rubyforge.org/projects/win32utils'
+  spec.platform   = Gem::Platform::RUBY
+  spec.summary    = 'Provides an Open3.popen3 implementation for MS Windows'
+  spec.test_file  = 'test/test_win32_open3.rb'
+  spec.has_rdoc   = true
+  spec.license    = 'Artistic 2.0'  
+  spec.extensions = ['ext/extconf.rb']
+  spec.files      = Dir['**/*'].reject{ |f| f.include?('git') }
+   
+  spec.extra_rdoc_files = [
+    'CHANGES',
+    'README',
+    'MANIFEST',
+    'doc/open3.txt',
+    'ext/win32/open3.c'
+  ]
+   
+  spec.rubyforge_project = 'win32utils'
+  spec.required_ruby_version = '< 1.9.0'
+   
+  spec.description = <<-EOF
+    The win32-open3 library provides a working implementation of the open3
+    library for MS Windows. In addition, it provides the Open4 class, which
+    also returns pid information.
+      
+    Note that this library is unnecessary with Ruby 1.9.x because of its
+    support for native threads.
+  EOF
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: win32-open3
+version: !ruby/object:Gem::Version 
+  version: 0.3.2
+platform: x86-mingw32
+authors: 
+- Park Heesob
+- Daniel J. Berger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-23 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: "    The win32-open3 library provides a working implementation of the open3\n    library for MS Windows. In addition, it provides the Open4 class, which\n    also returns pid information.\n      \n    Note that this library is unnecessary with Ruby 1.9.x because of its\n    support for native threads.\n"
+email: djberg96@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- CHANGES
+- README
+- MANIFEST
+- doc/open3.txt
+- ext/win32/open3.c
+files: 
+- CHANGES
+- doc/open3.txt
+- examples/win32_open3_example.rb
+- lib/win32/open3.so
+- MANIFEST
+- Rakefile
+- README
+- test/test_win32_open3.rb
+- win32-open3.gemspec
+- ext/win32/open3.c
+has_rdoc: true
+homepage: http://www.rubyforge.org/projects/win32utils
+licenses: 
+- Artistic 2.0
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - <
+    - !ruby/object:Gem::Version 
+      version: 1.9.0
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: win32utils
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Provides an Open3.popen3 implementation for MS Windows
+test_files: 
+- test/test_win32_open3.rb