curb 1.0.0 → 1.0.5

data/ext/curb_multi.c

@@ -43,8 +43,25 @@ static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy);
 static void rb_curl_multi_read_info(VALUE self, CURLM *mptr);
 static void rb_curl_multi_run(VALUE self, CURLM *multi_handle, int *still_running);
 
-static VALUE callback_exception(VALUE unused) {
-  return Qfalse;
+static VALUE callback_exception(VALUE did_raise, VALUE exception) {
+  // TODO: we could have an option to enable exception reporting
+/*  VALUE ret = rb_funcall(exception, rb_intern("message"), 0);
+  VALUE trace = rb_funcall(exception, rb_intern("backtrace"), 0);
+  if (RB_TYPE_P(trace, T_ARRAY) && RARRAY_LEN(trace) > 0) {
+    printf("we got an exception: %s:%d\n", StringValueCStr(ret), RARRAY_LEN(trace));
+    VALUE sep = rb_str_new_cstr("\n");
+    VALUE trace_lines = rb_ary_join(trace, sep);
+    if (RB_TYPE_P(trace_lines, T_STRING)) {
+      printf("%s\n", StringValueCStr(trace_lines));
+    } else {
+      printf("trace is not a string??\n");
+    }
+  } else {
+    printf("we got an exception: %s\nno stack available\n", StringValueCStr(ret));
+  }
+  */
+  rb_hash_aset(did_raise, rb_easy_hkey("error"), exception);
+  return exception;
 }
 
 void curl_multi_free(ruby_curl_multi *rbcm) {
@@ -64,7 +81,7 @@ static void ruby_curl_multi_init(ruby_curl_multi *rbcm) {
 
 /*
  * call-seq:
- *   Curl::Multi.new                                   => #<Curl::Easy...>
+ *   Curl::Multi.new                                   => #<Curl::Easy...>
  *
  * Create a new Curl::Multi instance
  */
@@ -132,7 +149,7 @@ VALUE ruby_curl_multi_get_autoclose(VALUE klass) {
 
 /*
  * call-seq:
- *   multi.requests                                   => [#&lt;Curl::Easy...&gt;, ...]
+ *   multi.requests                                   => [#<Curl::Easy...>, ...]
  * 
  * Returns an array containing all the active requests on this Curl::Multi object.
  */
@@ -274,7 +291,7 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
   long response_code = -1;
   VALUE easy;
   ruby_curl_easy *rbce = NULL;
-  VALUE callargs, val = Qtrue;
+  VALUE callargs;
 
   CURLcode ecode = curl_easy_getinfo(easy_handle, CURLINFO_PRIVATE, (char**)&easy);
 
@@ -295,55 +312,62 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
     raise_curl_easy_error_exception(ecode);
   }
 
+  VALUE did_raise = rb_hash_new();
+
   if (!rb_easy_nil("complete_proc")) {
     callargs = rb_ary_new3(2, rb_easy_get("complete_proc"), easy);
     rbce->callback_active = 1;
-    val = rb_rescue(call_status_handler1, callargs, callback_exception, Qnil);
+    rb_rescue(call_status_handler1, callargs, callback_exception, did_raise);
     rbce->callback_active = 0;
-    //rb_funcall( rb_easy_get("complete_proc"), idCall, 1, easy );
+    CURB_CHECK_RB_CALLBACK_RAISE(did_raise);
   }
 
+#ifdef HAVE_CURLINFO_RESPONSE_CODE
   curl_easy_getinfo(rbce->curl, CURLINFO_RESPONSE_CODE, &response_code);
+#else
+  // old libcurl
+  curl_easy_getinfo(rbce->curl, CURLINFO_HTTP_CODE, &response_code);
+#endif
+  long redirect_count;
+  curl_easy_getinfo(rbce->curl, CURLINFO_REDIRECT_COUNT, &redirect_count);
 
   if (result != 0) {
     if (!rb_easy_nil("failure_proc")) {
       callargs = rb_ary_new3(3, rb_easy_get("failure_proc"), easy, rb_curl_easy_error(result));
       rbce->callback_active = 1;
-      val = rb_rescue(call_status_handler2, callargs, callback_exception, Qnil);
+      rb_rescue(call_status_handler2, callargs, callback_exception, did_raise);
       rbce->callback_active = 0;
-      //rb_funcall( rb_easy_get("failure_proc"), idCall, 2, easy, rb_curl_easy_error(result) );
+      CURB_CHECK_RB_CALLBACK_RAISE(did_raise);
     }
-  }
-  else if (!rb_easy_nil("success_proc") &&
+  } else if (!rb_easy_nil("success_proc") &&
           ((response_code >= 200 && response_code < 300) || response_code == 0)) {
     /* NOTE: we allow response_code == 0, in the case of non http requests e.g. reading from disk */
     callargs = rb_ary_new3(2, rb_easy_get("success_proc"), easy);
     rbce->callback_active = 1;
-    val = rb_rescue(call_status_handler1, callargs, callback_exception, Qnil);
+    rb_rescue(call_status_handler1, callargs, callback_exception, did_raise);
     rbce->callback_active = 0;
-    //rb_funcall( rb_easy_get("success_proc"), idCall, 1, easy );
-  }
-  else if (!rb_easy_nil("redirect_proc") &&
-          (response_code >= 300 && response_code < 400)) {
+    CURB_CHECK_RB_CALLBACK_RAISE(did_raise);
+
+  } else if (!rb_easy_nil("redirect_proc") && ((response_code >= 300 && response_code < 400) || redirect_count > 0) ) {
     rbce->callback_active = 1;
     callargs = rb_ary_new3(3, rb_easy_get("redirect_proc"), easy, rb_curl_easy_error(result));
     rbce->callback_active = 0;
-    val = rb_rescue(call_status_handler2, callargs, callback_exception, Qnil);
-  }
-  else if (!rb_easy_nil("missing_proc") &&
+    rb_rescue(call_status_handler2, callargs, callback_exception, did_raise);
+    CURB_CHECK_RB_CALLBACK_RAISE(did_raise);
+  } else if (!rb_easy_nil("missing_proc") &&
           (response_code >= 400 && response_code < 500)) {
     rbce->callback_active = 1;
     callargs = rb_ary_new3(3, rb_easy_get("missing_proc"), easy, rb_curl_easy_error(result));
     rbce->callback_active = 0;
-    val = rb_rescue(call_status_handler2, callargs, callback_exception, Qnil);
-  }
-  else if (!rb_easy_nil("failure_proc") &&
+    rb_rescue(call_status_handler2, callargs, callback_exception, did_raise);
+    CURB_CHECK_RB_CALLBACK_RAISE(did_raise);
+  } else if (!rb_easy_nil("failure_proc") &&
           (response_code >= 500 && response_code <= 999)) {
     callargs = rb_ary_new3(3, rb_easy_get("failure_proc"), easy, rb_curl_easy_error(result));
     rbce->callback_active = 1;
-    val = rb_rescue(call_status_handler2, callargs, callback_exception, Qnil);
+    rb_rescue(call_status_handler2, callargs, callback_exception, did_raise);
     rbce->callback_active = 0;
-    //rb_funcall( rb_easy_get("failure_proc"), idCall, 2, easy, rb_curl_easy_error(result) );
+    CURB_CHECK_RB_CALLBACK_RAISE(did_raise);
   }
 
 }
@@ -627,6 +651,8 @@ void init_curb_multi() {
   idCall = rb_intern("call");
   cCurlMulti = rb_define_class_under(mCurl, "Multi", rb_cObject);
 
+  rb_undef_alloc_func(cCurlMulti);
+
   /* Class methods */
   rb_define_singleton_method(cCurlMulti, "new", ruby_curl_multi_new, 0);
   rb_define_singleton_method(cCurlMulti, "default_timeout=", ruby_curl_multi_set_default_timeout, 1);

data/ext/curb_postfield.c

@@ -195,9 +195,9 @@ void curl_postfield_free(ruby_curl_postfield *rbcpf) {
 
 /*
  * call-seq:
- *   Curl::PostField.content(name, content) => #<Curl::PostField...>
- *   Curl::PostField.content(name, content, content_type = nil) => #<Curl::PostField...>
- *   Curl::PostField.content(name, content_type = nil) { |field| ... } => #<Curl::PostField...>
+ *   Curl::PostField.content(name, content) => #<Curl::PostField...>
+ *   Curl::PostField.content(name, content, content_type = nil) => #<Curl::PostField...>
+ *   Curl::PostField.content(name, content_type = nil) { |field| ... } => #<Curl::PostField...>
  * 
  * Create a new Curl::PostField, supplying the field name, content,
  * and, optionally, Content-type (curl will attempt to determine this if
@@ -241,9 +241,9 @@ static VALUE ruby_curl_postfield_new_content(int argc, VALUE *argv, VALUE klass)
 
 /*
  * call-seq:
- *   Curl::PostField.file(name, local_file_name) => #&lt;Curl::PostField...&gt;
- *   Curl::PostField.file(name, local_file_name, remote_file_name = local_file_name) => #&lt;Curl::PostField...&gt;
- *   Curl::PostField.file(name, remote_file_name) { |field| ... } => #&lt;Curl::PostField...&gt;
+ *   Curl::PostField.file(name, local_file_name) => #<Curl::PostField...>
+ *   Curl::PostField.file(name, local_file_name, remote_file_name = local_file_name) => #<Curl::PostField...>
+ *   Curl::PostField.file(name, remote_file_name) { |field| ... } => #<Curl::PostField...>
  * 
  * Create a new Curl::PostField for a file upload field, supplying the local filename
  * to read from, and optionally the remote filename (defaults to the local name).
@@ -399,7 +399,7 @@ static VALUE ruby_curl_postfield_remote_file_get(VALUE self) {
 
 /*
  * call-seq:
- *   field.set_content_proc { |field| ... }           => &lt;old proc&gt;
+ *   field.set_content_proc { |field| ... }           => <old proc>
  * 
  * Set a content proc for this field. This proc will be called during the
  * perform to supply the content for this field, overriding any setting
@@ -498,6 +498,8 @@ void init_curb_postfield() {
   
   cCurlPostField = rb_define_class_under(mCurl, "PostField", rb_cObject);
 
+  rb_undef_alloc_func(cCurlPostField);
+
   /* Class methods */
   rb_define_singleton_method(cCurlPostField, "content", ruby_curl_postfield_new_content, -1);
   rb_define_singleton_method(cCurlPostField, "file", ruby_curl_postfield_new_file, -1);

data/ext/curb_upload.c

@@ -72,6 +72,7 @@ VALUE ruby_curl_upload_offset_get(VALUE self) {
 /* =================== INIT LIB =====================*/
 void init_curb_upload() {
   cCurlUpload = rb_define_class_under(mCurl, "Upload", rb_cObject);
+  rb_undef_alloc_func(cCurlUpload);
   rb_define_singleton_method(cCurlUpload, "new", ruby_curl_upload_new, 0);
   rb_define_method(cCurlUpload, "stream=", ruby_curl_upload_stream_set, 1);
   rb_define_method(cCurlUpload, "stream", ruby_curl_upload_stream_get, 0);

data/ext/extconf.rb

@@ -405,6 +405,8 @@ have_constant "curlopt_path_as_is"
 # added in 7.43.0
 have_constant "curlopt_pipewait"
 
+have_constant "curlopt_proxy_ssl_verifyhost"
+
 # protocol constants
 have_constant "curlproto_all"
 have_constant "curlproto_dict"

data/lib/curl/easy.rb

@@ -21,7 +21,7 @@ module Curl
     #
     def status
       # Matches the last HTTP Status - following the HTTP protocol specification 'Status-Line = HTTP-Version SP Status-Code SP (Opt:)Reason-Phrase CRLF'
-      statuses = self.header_str.scan(/HTTP\/\d(\.\d)?\s(\d+\s.*)\r\n/).map{ |match| match[1] }
+      statuses = self.header_str.to_s.scan(/HTTP\/\d(\.\d)?\s(\d+\s.*)\r\n/).map {|match| match[1] }
       statuses.last.strip if statuses.length > 0
     end
 
@@ -321,7 +321,7 @@ module Curl
 
       #
       # call-seq:
-      #   Curl::Easy.perform(url) { |easy| ... }           => #<Curl::Easy...>
+      #   Curl::Easy.perform(url) { |easy| ... }           => #<Curl::Easy...>
       #
       # Convenience method that creates a new Curl::Easy instance with
       # the specified URL and calls the general +perform+ method, before returning
@@ -339,7 +339,7 @@ module Curl
 
       #
       # call-seq:
-      #   Curl::Easy.http_get(url) { |easy| ... }          => #&lt;Curl::Easy...&gt;
+      #   Curl::Easy.http_get(url) { |easy| ... }          => #<Curl::Easy...>
       #
       # Convenience method that creates a new Curl::Easy instance with
       # the specified URL and calls +http_get+, before returning the new instance.
@@ -356,7 +356,7 @@ module Curl
 
       #
       # call-seq:
-      #   Curl::Easy.http_head(url) { |easy| ... }         => #&lt;Curl::Easy...&gt;
+      #   Curl::Easy.http_head(url) { |easy| ... }         => #<Curl::Easy...>
       #
       # Convenience method that creates a new Curl::Easy instance with
       # the specified URL and calls +http_head+, before returning the new instance.
@@ -410,7 +410,7 @@ module Curl
 
       #
       # call-seq:
-      #   Curl::Easy.http_delete(url) { |easy| ... }       => #&lt;Curl::Easy...&gt;
+      #   Curl::Easy.http_delete(url) { |easy| ... }       => #<Curl::Easy...>
       #
       # Convenience method that creates a new Curl::Easy instance with
       # the specified URL and calls +http_delete+, before returning the new instance.

data/lib/curl/multi.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 module Curl
   class Multi
+    class DownloadError < RuntimeError
+      attr_accessor :errors
+    end
     class << self
       # call-seq:
       #   Curl::Multi.get(['url1','url2','url3','url4','url5'], :follow_location => true) do|easy|
@@ -241,7 +244,11 @@ module Curl
             errors << e
           end
         }
-        raise errors unless errors.empty?
+        if errors.any?
+          de = Curl::Multi::DownloadError.new
+          de.errors = errors
+          raise de
+        end
       end
     end
 

data/lib/curl.rb

@@ -9,12 +9,20 @@ require 'cgi'
 module Curl
 
   def self.http(verb, url, post_body=nil, put_data=nil, &block)
-    handle = Thread.current[:curb_curl] ||= Curl::Easy.new
-    handle.reset
+    if Thread.current[:curb_curl_yielding]
+      handle = Curl::Easy.new # we can't reuse this
+    else
+      handle = Thread.current[:curb_curl] ||= Curl::Easy.new
+      handle.reset
+    end
     handle.url = url
     handle.post_body = post_body if post_body
     handle.put_data = put_data if put_data
-    yield handle if block_given?
+    if block_given?
+      Thread.current[:curb_curl_yielding] = true
+      yield handle
+      Thread.current[:curb_curl_yielding] = false
+    end
     handle.http(verb)
     handle
   end

data/tests/bug_crash_on_debug.rb

@@ -1,37 +1,23 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
 
-require 'webrick'
-class ::WEBrick::HTTPServer ; def access_log(config, req, res) ; end ; end
-class ::WEBrick::BasicLog ; def log(level, data) ; end ; end
-
-require 'curl'
-
 class BugCrashOnDebug < Test::Unit::TestCase
+  include BugTestServerSetupTeardown
 
   def test_on_debug
-    server = WEBrick::HTTPServer.new( :Port => 9999 )
-    server.mount_proc("/test") do|req,res|
-      res.body = "hi"
-      res['Content-Type'] = "text/html"
-    end
-    puts 'a'
-    thread = Thread.new(server) do|srv|
-      srv.start
-    end
-    puts 'b'
-    c = Curl::Easy.new('http://127.0.0.1:9999/test')
-    c.on_debug do|x|
-      puts x.inspect
-      raise "error" # this will get swallowed
+    c = Curl::Easy.new("http://127.0.0.1:#{@port}/test")
+    did_raise = false
+    did_call = false
+    begin
+      c.on_success do|x|
+        did_call = true
+        raise "error" # this will get swallowed
+      end
+      c.perform
+    rescue => e
+      did_raise = true
     end
-    c.perform
-    puts 'c'
-  ensure
-    puts 'd'
-    server.shutdown
-    puts 'e'
-    puts thread.exit
-    puts 'f'
+    assert did_raise
+    assert did_call
   end
 
 end

data/tests/bug_crash_on_progress.rb

@@ -1,22 +1,10 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
-require 'webrick'
-class ::WEBrick::HTTPServer ; def access_log(config, req, res) ; end ; end
-class ::WEBrick::BasicLog ; def log(level, data) ; end ; end
 
 class BugCrashOnDebug < Test::Unit::TestCase
-  
-  def test_on_progress_raise
-    server = WEBrick::HTTPServer.new( :Port => 9999 )
-    server.mount_proc("/test") do|req,res|
-      res.body = "hi"
-      res['Content-Type'] = "text/html"
-    end
+  include BugTestServerSetupTeardown
 
-    thread = Thread.new(server) do|srv|
-      srv.start
-    end
-
-    c = Curl::Easy.new('http://127.0.0.1:9999/test')
+  def test_on_progress_raise
+    c = Curl::Easy.new("http://127.0.0.1:#{@port}/test")
     c.on_progress do|x|
       raise "error"
     end
@@ -27,21 +15,9 @@ class BugCrashOnDebug < Test::Unit::TestCase
   rescue => e
     assert_equal 'Curl::Err::AbortedByCallbackError', e.class.to_s
     c.close
-  ensure
-    server.shutdown
   end
 
   def test_on_progress_abort
-    server = WEBrick::HTTPServer.new( :Port => 9999 )
-    server.mount_proc("/test") do|req,res|
-      res.body = "hi"
-      res['Content-Type'] = "text/html"
-    end
-
-    thread = Thread.new(server) do|srv|
-      srv.start
-    end
-
     # see: https://github.com/taf2/curb/issues/192,
     # to pass:
     # 
@@ -54,20 +30,20 @@ class BugCrashOnDebug < Test::Unit::TestCase
     # 
     #  notice no return keyword
     #
-    c = Curl::Easy.new('http://127.0.0.1:9999/test')
+    c = Curl::Easy.new("http://127.0.0.1:#{@port}/test")
+    did_progress = false
     c.on_progress do|x|
-      puts "we're in the progress callback"
+      did_progress = true
       return false
     end
     c.perform
+    assert did_progress
 
     assert false, "should not reach this point"
 
   rescue => e
     assert_equal 'Curl::Err::AbortedByCallbackError', e.class.to_s
     c.close
-  ensure
-    server.shutdown
   end
 
 end

data/tests/bug_curb_easy_blocks_ruby_threads.rb

@@ -1,21 +1,19 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
-require 'webrick'
-class ::WEBrick::HTTPServer ; def access_log(config, req, res) ; end ; end
-class ::WEBrick::BasicLog ; def log(level, data) ; end ; end
 
 class BugTestInstancePostDiffersFromClassPost < Test::Unit::TestCase
-  def test_bug
-    server = WEBrick::HTTPServer.new( :Port => 9999 )
-    server.mount_proc("/test") do|req,res|
+  include BugTestServerSetupTeardown
+
+  def setup
+    @port = 9999
+    @response_proc = lambda do|res|
       sleep 0.5
       res.body = "hi"
       res['Content-Type'] = "text/html"
     end
+    super
+  end
 
-    thread = Thread.new(server) do|srv|
-      srv.start
-    end
-
+  def test_bug
     threads = []
     timer = Time.now
 
@@ -45,8 +43,5 @@ class BugTestInstancePostDiffersFromClassPost < Test::Unit::TestCase
     puts "requested in #{single_time}"
 
     assert single_time > multi_time
-
-    server.shutdown
-    thread.join
   end
 end

data/tests/bug_curb_easy_post_with_string_no_content_length_header.rb

@@ -22,26 +22,15 @@ end
 Any insight you care to share would be helpful. Thanks.
 =end
 require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
-require 'webrick'
-class ::WEBrick::HTTPServer ; def access_log(config, req, res) ; end ; end
-class ::WEBrick::BasicLog ; def log(level, data) ; end ; end
 
 class BugCurbEasyPostWithStringNoContentLengthHeader < Test::Unit::TestCase
-  def test_bug_workaround
-    server = WEBrick::HTTPServer.new( :Port => 9999 )
-    server.mount_proc("/test") do|req,res|
-      assert_equal '15', req['Content-Length']
-      res.body = "hi"
-      res['Content-Type'] = "text/html"
-    end
+  include BugTestServerSetupTeardown
 
-    thread = Thread.new(server) do|srv|
-      srv.start
-    end
+  def test_bug_workaround
     params = {:cat => "hat", :foo => "bar"}
 
     post_body = params.map{|f,k| "#{Curl::Easy.new.escape(f)}=#{Curl::Easy.new.escape(k)}"}.join('&')
-    c = Curl::Easy.http_post("http://127.0.0.1:9999/test",post_body) do |curl|
+    c = Curl::Easy.http_post("http://127.0.0.1:#{@port}/test",post_body) do |curl|
       curl.headers["User-Agent"] = "Curl/Ruby"
       curl.headers["X-Tender-Auth"] = "A Token"
       curl.headers["Accept"] = "application/vnd.tender-v1+json"
@@ -50,23 +39,12 @@ class BugCurbEasyPostWithStringNoContentLengthHeader < Test::Unit::TestCase
       curl.enable_cookies = true
     end
 
-    server.shutdown
-    thread.join
   end
-  def test_bug
-    server = WEBrick::HTTPServer.new( :Port => 9999 )
-    server.mount_proc("/test") do|req,res|
-      assert_equal '15', req['Content-Length']
-      res.body = "hi"
-      res['Content-Type'] = "text/html"
-    end
 
-    thread = Thread.new(server) do|srv|
-      srv.start
-    end
+  def test_bug
     params = {:cat => "hat", :foo => "bar"}
 
-    c = Curl::Easy.http_post("http://127.0.0.1:9999/test") do |curl|
+    c = Curl::Easy.http_post("http://127.0.0.1:#{@port}/test") do |curl|
       curl.headers["User-Agent"] = "Curl/Ruby"
       curl.headers["X-Tender-Auth"] = "A Token"
       curl.headers["Accept"] = "application/vnd.tender-v1+json"
@@ -76,8 +54,6 @@ class BugCurbEasyPostWithStringNoContentLengthHeader < Test::Unit::TestCase
       curl.follow_location = true
       curl.enable_cookies = true
     end
-
-    server.shutdown
-    thread.join
   end
+
 end

data/tests/bug_follow_redirect_288.rb

@@ -0,0 +1,83 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class BugFollowRedirect288 < Test::Unit::TestCase
+  include BugTestServerSetupTeardown
+
+  def setup
+    @port = 9999
+    super
+    @server.mount_proc("/redirect_to_test") do|req,res|
+      res.set_redirect(WEBrick::HTTPStatus::TemporaryRedirect, "/test")
+    end
+  end
+
+  def test_follow_redirect_with_no_redirect
+
+    c = Curl::Easy.new('http://127.0.0.1:9999/test')
+    did_call_redirect = false
+    c.on_redirect do|x|
+      did_call_redirect = true
+    end
+    c.perform
+
+    assert !did_call_redirect, "should reach this point redirect should not have been called"
+
+    c = Curl::Easy.new('http://127.0.0.1:9999/test')
+    did_call_redirect = false
+    c.on_redirect do|x|
+      did_call_redirect = true
+    end
+    c.follow_location = true
+    c.perform
+
+    assert_equal 0, c.redirect_count
+    assert !did_call_redirect, "should reach this point redirect should not have been called"
+
+    c = Curl::Easy.new('http://127.0.0.1:9999/redirect_to_test')
+    did_call_redirect = false
+    c.on_redirect do|x|
+      did_call_redirect = true
+    end
+    c.perform
+    assert_equal 307, c.response_code
+
+    assert did_call_redirect, "we should have called on_redirect"
+
+    c = Curl::Easy.new('http://127.0.0.1:9999/redirect_to_test')
+    did_call_redirect = false
+    c.follow_location = true
+    # NOTE: while this API is not supported by libcurl e.g. there is no redirect function callback in libcurl we could 
+    # add support in ruby for this by executing this callback if redirect_count is greater than 0 at the end of a request in curb_multi.c
+    c.on_redirect do|x|
+      did_call_redirect = true
+    end
+    c.perform
+    assert_equal 1, c.redirect_count
+    assert_equal 200, c.response_code
+
+    assert did_call_redirect, "we should have called on_redirect"
+
+    c.url = 'http://127.0.0.1:9999/test'
+    c.perform
+    assert_equal 0, c.redirect_count
+    assert_equal 200, c.response_code
+
+    puts "checking for raise support"
+    did_raise = false
+    begin
+      c = Curl::Easy.new('http://127.0.0.1:9999/redirect_to_test')
+      did_call_redirect = false
+      c.on_redirect do|x|
+        raise "raise"
+        did_call_redirect = true
+      end
+      c.perform
+    rescue => e
+      did_raise = true
+    end
+    assert_equal 307, c.response_code
+    assert did_raise
+
+  end
+
+end

data/tests/bug_instance_post_differs_from_class_post.rb

@@ -35,15 +35,13 @@ class BugTestInstancePostDiffersFromClassPost < Test::Unit::TestCase
   end
 
   def do_test
-    c = Curl::Easy.http_post('https://www.google.com/accounts/ServiceLoginAuth',
-                Curl::PostField.content('ltmpl','m_blanco'))
+    c = Curl::Easy.http_post('https://www.google.com/accounts/ServiceLoginAuth', Curl::PostField.content('ltmpl','m_blanco'))
     body_c, header_c = c.body_str, c.header_str
    
     sleep 2
 
-    c.http_post('https://www.google.com/accounts/ServiceLoginAuth',
-                Curl::PostField.content('ltmpl','m_blanco'))
-    body_i, header_i = c.body_str, c.header_str
+    c.http_post('https://www.google.com/accounts/ServiceLoginAuth', Curl::PostField.content('ltmpl','m_blanco'))
+    body_i, header_i = c.body, c.head
 
     # timestamps will differ, just check first bit. We wont get here if
     # the bug bites anyway...

data/tests/bug_issue277.rb

@@ -0,0 +1,32 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+
+require 'curb'
+
+class BugIssue102 < Test::Unit::TestCase
+
+  def test_gc_closewait
+		100.times do
+			responses = {}
+			requests = ["http://www.google.co.uk/", "http://www.ruby-lang.org/"]
+			m = Curl::Multi.new
+			# add a few easy handles
+			requests.each do |url|
+				responses[url] = ""
+				c = Curl::Easy.new(url) do|curl|
+					curl.follow_location = true
+					curl.on_body{|data| responses[url] << data; data.size }
+					curl.on_success {|easy| #puts "success, add more easy handles"
+          }
+				end
+				m.add(c)
+			end
+
+			m.perform do
+				#puts "idling... can do some work here"
+			end
+      GC.start
+		end
+	end
+
+end