curb 1.1.0 → 1.2.0

data/ext/extconf.rb

@@ -1,4 +1,10 @@
 require 'mkmf'
+require 'tmpdir'
+begin
+  require 'etc'
+rescue LoadError
+  # Etc may not be available on all Ruby builds (very rare). Fallback later.
+end
 
 dir_config('curl')
 
@@ -37,26 +43,195 @@ end
 #  puts "Selected arch: #{archs.first}"
 #end
 
-def define(s, v=1)
-  $defs.push( format("-D HAVE_%s=%d", s.to_s.upcase, v) )
+def define(s, v = 1)
+  $defs.push(format("-D HAVE_%s=%d", s.to_s.upcase, v))
 end
 
-def have_constant(name)
-  sname = name.is_a?(Symbol) ? name.to_s : name.upcase
-  checking_for name do
-    src = %{
-      #include <curl/curl.h>
-      int main() {
-        int test = (int)#{sname};
-        return 0;
-      }
+# Optional parallelization support for constant checks only.
+# Enable automatically when job hints are present (JOBS, BUNDLE_JOBS, MAKEFLAGS -jN),
+# or explicitly via EXTCONF_JOBS/EXTCONF_PARALLEL.
+
+def parse_jobs_from_makeflags(flags)
+  return nil if flags.nil? || flags.empty?
+  tokens = flags.to_s.split(/\s+/)
+  jobs = nil
+  tokens.each_with_index do |tok, i|
+    case tok
+    when /\A-j(\d+)\z/
+      jobs = $1.to_i
+    when '-j'
+      nxt = tokens[i + 1]
+      jobs = nxt.to_i if nxt && nxt =~ /\A\d+\z/
+    when /\A--jobs(?:=(\d+)|\s+(\d+))\z/
+      jobs = ($1 || $2).to_i
+    when /\Aj(\d+)\z/ # sometimes make condenses flags
+      jobs = $1.to_i
+    end
+    break if jobs && jobs > 0
+  end
+  jobs
+end
+
+def detect_job_hints
+  # Priority: explicit extconf hint, then common envs used by bundler/rubygems
+  [
+    ENV['EXTCONF_JOBS'],
+    ENV['JOBS'],
+    ENV['BUNDLE_JOBS'],
+    parse_jobs_from_makeflags(ENV['MAKEFLAGS'])
+  ].each do |v|
+    n = v.to_i if v
+    return n if n && n > 0
+  end
+  nil
+end
+
+explicit_parallel = ENV.key?('EXTCONF_PARALLEL') && ENV['EXTCONF_PARALLEL'] == '1'
+job_hints = detect_job_hints
+
+DEFAULT_PARALLEL_JOBS = begin
+  n = Etc.respond_to?(:nprocessors) ? Etc.nprocessors.to_i : 1
+  n = 1 if n <= 0
+  # Use half the CPUs by default (rounded up), but at least 1
+  jobs = [(n.to_f / 2).ceil, 1].max
+  jobs
+rescue
+  1
+end
+
+PARALLEL_JOBS = begin
+  if job_hints && job_hints > 0
+    job_hints
+  else
+    # If no hints provided, default to half the CPUs.
+    DEFAULT_PARALLEL_JOBS
+  end
+end
+
+# Only enable if the platform supports fork. On Windows this stays sequential.
+PARALLEL_CONSTANT_CHECKS = PARALLEL_JOBS > 1 && Process.respond_to?(:fork)
+
+$queued_constants = []
+
+def try_constant_compile(sname)
+  src = %{
+    #include <curl/curl.h>
+    int main() {
+      int test = (int)#{sname};
+      (void)test;
+      return 0;
     }
-    if try_compile(src,"#{$CFLAGS} #{$LIBS}")
-      define name
-      true
-    else
-      #define name, 0
-      false
+  }
+  try_compile(src, "#{$CFLAGS} #{$LIBS}")
+end
+
+def have_constant(name)
+  # Queue constants for optional parallel probing. Falls back to sequential.
+  if PARALLEL_CONSTANT_CHECKS
+    $queued_constants << name
+    true
+  else
+    sname = name.is_a?(Symbol) ? name.to_s : name.upcase
+    checking_for name do
+      if try_constant_compile(sname)
+        define name
+        true
+      else
+        false
+      end
+    end
+  end
+end
+
+def flush_constant_checks
+  return if $queued_constants.empty?
+
+  constants = $queued_constants.uniq
+  $queued_constants.clear
+
+  # On platforms without fork (e.g., Windows), run sequentially.
+  unless PARALLEL_CONSTANT_CHECKS
+    constants.each { |name| have_constant(name) }
+    return
+  end
+
+  # Run constant probes in isolated child processes to avoid mkmf
+  # scratch file and logfile contention.
+  results = {}
+  pending = constants.dup
+  running = {}
+  max_jobs = PARALLEL_JOBS
+
+  spawn_probe = lambda do |const_name|
+    r, w = IO.pipe
+    pid = fork do
+      begin
+        r.close
+        Dir.mktmpdir('curb-mkmf-') do |dir|
+          Dir.chdir(dir) do
+            begin
+              # Avoid clobbering the main mkmf.log
+              Logging::logfile = File.open(File::NULL, 'w') rescue File.open(File.join(dir, 'mkmf.log'), 'w')
+            rescue
+              # best-effort
+            end
+            sname = const_name.is_a?(Symbol) ? const_name.to_s : const_name.upcase
+            ok = try_constant_compile(sname)
+            w.write([const_name, ok ? 1 : 0].join("\t"))
+          end
+        end
+      rescue
+        # Treat as failure if anything unexpected happens in child
+        begin
+          w.write([const_name, 0].join("\t"))
+        rescue
+        end
+      ensure
+        begin w.close rescue nil end
+        # Ensure the child exits without running at_exit handlers
+        exit! 0
+      end
+    end
+    w.close
+    running[pid] = r
+  end
+
+  # Start initial batch
+  while running.size < max_jobs && !pending.empty?
+    spawn_probe.call(pending.shift)
+  end
+
+  # Collect results and keep spawning until done
+  until running.empty?
+    pid = Process.wait
+    io = running.delete(pid)
+    if io
+      begin
+        msg = io.read.to_s
+        name_str, ok_str = msg.split("\t", 2)
+        if name_str
+          # Map back to the original object if symbol-like
+          original = constants.find { |n| n.to_s == name_str }
+          results[original || name_str] = ok_str.to_i == 1
+        end
+      ensure
+        begin io.close rescue nil end
+      end
+    end
+    # Fill next task slot
+    spawn_probe.call(pending.shift) unless pending.empty?
+  end
+
+  # Apply results to $defs and output summary via checking_for
+  results.each do |const_name, ok|
+    sname = const_name.is_a?(Symbol) ? const_name.to_s : const_name.upcase
+    checking_for const_name do
+      if ok
+        define const_name
+        true
+      else
+        false
+      end
     end
   end
 end
@@ -469,9 +644,31 @@ test_for("curl_easy_escape", "CURL_EASY_ESCAPE", %{
 have_func('rb_thread_blocking_region')
 have_header('ruby/thread.h') && have_func('rb_thread_call_without_gvl', 'ruby/thread.h')
 have_header('ruby/io.h')
+have_func('rb_thread_fd_select', 'ruby/io.h')
+have_func('rb_wait_for_single_fd', 'ruby/io.h')
+have_header('ruby/fiber/scheduler.h')
+have_func('rb_fiber_scheduler_current', 'ruby/fiber/scheduler.h')
+have_func('rb_fiber_scheduler_io_wait', 'ruby/fiber/scheduler.h')
 have_func('rb_io_stdio_file')
 have_func('curl_multi_wait')
+have_func('curl_multi_socket_action')
+have_func('curl_multi_assign')
+have_func('curl_multi_wakeup')
+have_func('curl_multi_poll')
+have_func('curl_multi_socket')
+have_func('curl_multi_timer_callback')
+have_constant 'curlmopt_socketfunction'
+have_constant 'curlmopt_timerfunction'
 have_func('curl_easy_duphandle')
 
+# Optional: enable verbose socket-action debug logging.
+# Set CURB_SOCKET_DEBUG=1 in the environment before running extconf to enable.
+if ENV['CURB_SOCKET_DEBUG'] == '1'
+  $defs << '-DCURB_SOCKET_DEBUG=1'
+end
+
+# Run any queued constant checks (in parallel if enabled) before header generation.
+flush_constant_checks
+
 create_header('curb_config.h')
 create_makefile('curb_core')

data/tests/bug_issue_noproxy.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class BugIssueNoproxy < Test::Unit::TestCase
+  def test_noproxy_option_support
+    # Test that CURLOPT_NOPROXY constant is defined
+    assert Curl.const_defined?(:CURLOPT_NOPROXY), "CURLOPT_NOPROXY constant should be defined"
+    
+    # Test basic noproxy setting using setopt
+    c = Curl::Easy.new('https://google.com')
+    
+    # This should not raise an error
+    assert_nothing_raised do
+      c.setopt(Curl::CURLOPT_NOPROXY, "localhost,127.0.0.1")
+    end
+    
+    # Test using the convenience method if it exists
+    if c.respond_to?(:noproxy=)
+      assert_nothing_raised do
+        c.noproxy = "localhost,127.0.0.1"
+      end
+      
+      # Test getter if it exists
+      if c.respond_to?(:noproxy)
+        assert_equal "localhost,127.0.0.1", c.noproxy
+      end
+    end
+  end
+  
+  def test_noproxy_with_set_method
+    c = Curl::Easy.new('https://google.com')
+    
+    # The issue specifically mentions using the set method
+    # This currently raises TypeError as reported in the issue
+    assert_nothing_raised(TypeError) do
+      c.set(:noproxy, "localhost,127.0.0.1")
+    end
+  end
+  
+  def test_noproxy_empty_string
+    c = Curl::Easy.new('https://google.com')
+    
+    # Test setting empty string to override environment variables
+    assert_nothing_raised do
+      c.setopt(Curl::CURLOPT_NOPROXY, "")
+    end
+  end
+  
+  def test_noproxy_nil_value
+    c = Curl::Easy.new('https://google.com')
+    
+    # Test setting nil to reset
+    assert_nothing_raised do
+      c.setopt(Curl::CURLOPT_NOPROXY, nil)
+    end
+  end
+end

data/tests/bug_issue_post_redirect.rb

@@ -0,0 +1,93 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require 'json'
+
+class BugIssuePostRedirect < Test::Unit::TestCase
+  include BugTestServerSetupTeardown
+
+  def setup
+    @port = 9998
+    super
+    # Mount a POST endpoint that returns a redirect
+    @server.mount_proc("/post_redirect") do |req, res|
+      if req.request_method == "POST"
+        res.status = 302
+        res['Location'] = "http://127.0.0.1:#{@port}/redirected"
+        res.body = "Redirecting..."
+      else
+        res.status = 405
+        res.body = "Method not allowed"
+      end
+    end
+
+    # Mount the redirect target
+    @server.mount_proc("/redirected") do |req, res|
+      res.status = 200
+      res['Content-Type'] = "text/plain"
+      res.body = "You have been redirected"
+    end
+  end
+
+  def test_post_with_max_redirects_zero_should_not_follow_redirect
+    # Test case replicating the issue: POST with max_redirects=0 and follow_location=false
+    # should NOT trigger on_redirect callback or follow the redirect
+    
+    redirect_called = false
+    
+    handle = Curl::Easy.new("http://127.0.0.1:#{@port}/post_redirect") do |curl|
+      curl.max_redirects = 0
+      curl.follow_location = false
+      curl.on_redirect do |easy|
+        redirect_called = true
+      end
+      curl.headers['Content-Type'] = 'application/json'
+      curl.post_body = {test: "data"}.to_json
+    end
+    
+    handle.http(:POST)
+    
+    # The response should be the redirect response (302)
+    assert_equal 302, handle.response_code
+    assert_match(/Redirecting/, handle.body_str)
+    
+    # on_redirect should NOT be called when follow_location is false
+    assert !redirect_called, "on_redirect callback should not be called when follow_location is false"
+  end
+
+  def test_post_with_follow_location_true_triggers_redirect
+    # Test that on_redirect IS called when follow_location is true
+    redirect_called = false
+    
+    handle = Curl::Easy.new("http://127.0.0.1:#{@port}/post_redirect") do |curl|
+      curl.follow_location = true
+      curl.on_redirect do |easy|
+        redirect_called = true
+      end
+      curl.headers['Content-Type'] = 'application/json'
+      curl.post_body = {test: "data"}.to_json
+    end
+    
+    handle.http(:POST)
+    
+    # Should follow the redirect and get the final response
+    assert_equal 200, handle.response_code
+    assert_match(/You have been redirected/, handle.body_str)
+    
+    # on_redirect SHOULD be called when follow_location is true
+    assert redirect_called, "on_redirect callback should be called when follow_location is true"
+  end
+
+  def test_curl_post_class_method_respects_redirect_settings
+    # Test that Curl.post (class method) respects redirect settings
+    # According to the issue, this works correctly
+    
+    response = Curl.post("http://127.0.0.1:#{@port}/post_redirect", {test: "data"}.to_json) do |curl|
+      curl.max_redirects = 0
+      curl.follow_location = false
+      curl.headers['Content-Type'] = 'application/json'
+    end
+    
+    # Should get the redirect response, not follow it
+    assert_equal 302, response.response_code
+    assert_match(/Redirecting/, response.body_str)
+  end
+end

data/tests/bug_issue_spnego.rb

@@ -0,0 +1,41 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class BugIssueSpnego < Test::Unit::TestCase
+  def test_spnego_detection_works
+    # The fix for issue #227 ensures that Curl.spnego? checks for both
+    # CURL_VERSION_SPNEGO (newer libcurl) and CURL_VERSION_GSSNEGOTIATE (older libcurl)
+    # 
+    # We can't test that it returns true because that depends on how libcurl
+    # was compiled on the system. We can only test that:
+    # 1. The method exists and works
+    # 2. If CURLAUTH_GSSNEGOTIATE is available, we can use it
+    
+    # Check if CURLAUTH_GSSNEGOTIATE is available
+    if Curl.const_defined?(:CURLAUTH_GSSNEGOTIATE) && Curl.const_get(:CURLAUTH_GSSNEGOTIATE) != 0
+      # Test that we can use GSSNEGOTIATE auth type
+      c = Curl::Easy.new('http://example.com')
+      assert_nothing_raised do
+        c.http_auth_types = Curl::CURLAUTH_GSSNEGOTIATE
+      end
+      
+      # The fix ensures spnego? won't incorrectly return false when 
+      # older libcurl versions have GSSNEGOTIATE support
+      # (The actual return value depends on system libcurl compilation)
+    end
+    
+    # The important fix is that the method now checks both constants
+    # This test passes if no exceptions are raised
+    assert true, "SPNEGO detection is working correctly"
+  end
+  
+  def test_spnego_method_exists
+    # The method should always exist
+    assert Curl.respond_to?(:spnego?), "Curl should respond to spnego?"
+  end
+  
+  def test_spnego_returns_boolean
+    # The method should return a boolean
+    result = Curl.spnego?
+    assert [true, false].include?(result), "Curl.spnego? should return true or false, got #{result.inspect}"
+  end
+end

data/tests/helper.rb

@@ -11,6 +11,34 @@ $LIBDIR = File.join($TOPDIR, 'lib')
 $:.unshift($LIBDIR)
 $:.unshift($EXTDIR)
 
+# Setup SimpleCov for Ruby code coverage if COVERAGE env var is set
+if ENV['COVERAGE']
+  begin
+    require 'simplecov'
+    require 'simplecov-lcov'
+    
+    SimpleCov::Formatter::LcovFormatter.config.report_with_single_file = true
+    SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
+      SimpleCov::Formatter::HTMLFormatter,
+      SimpleCov::Formatter::LcovFormatter
+    ])
+    
+    SimpleCov.start do
+      add_filter '/tests/'
+      add_filter '/spec/'
+      add_filter '/vendor/'
+      add_filter '/.bundle/'
+      add_group 'Library', 'lib'
+      add_group 'Extensions', 'ext'
+      
+      # Track branch coverage if available
+      enable_coverage :branch if respond_to?(:enable_coverage)
+    end
+  rescue LoadError
+    puts "SimpleCov not available. Install it with: gem install simplecov simplecov-lcov"
+  end
+end
+
 require 'curb'
 begin
   require 'test/unit'
@@ -19,6 +47,11 @@ rescue LoadError
   require 'test/unit'
 end
 require 'fileutils'
+require 'rbconfig'
+
+# Platform helpers
+WINDOWS = /mswin|msys|mingw|cygwin|bccwin|wince|emc|windows/i.match?(RbConfig::CONFIG['host_os'])
+NO_FORK = !Process.respond_to?(:fork)
 
 $TEST_URL = "file://#{'/' if RUBY_DESCRIPTION =~ /mswin|msys|mingw|cygwin|bccwin|wince|emc/}#{File.expand_path(__FILE__).tr('\\','/')}"
 

data/tests/mem_check.rb

@@ -6,6 +6,9 @@ require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
 # Run some tests to measure the memory usage of curb, these tests require fork and ps
 #
 class TestCurbMemory < Test::Unit::TestCase
+  def setup
+    omit('Memory fork/ps tests not supported on Windows') if WINDOWS || NO_FORK
+  end
 
   def test_easy_memory
     easy_avg, easy_std = measure_object_memory(Curl::Easy)

data/tests/tc_curl_download.rb

@@ -32,6 +32,7 @@ class TestCurbCurlDownload < Test::Unit::TestCase
   end
 
   def test_download_url_to_file_via_io
+    omit('fork not available on this platform') if NO_FORK || WINDOWS
     dl_url = "http://127.0.0.1:9129/ext/curb_easy.c"
     dl_path = File.join(Dir::tmpdir, "dl_url_test.file")
     reader, writer = IO.pipe
@@ -58,7 +59,7 @@ class TestCurbCurlDownload < Test::Unit::TestCase
     assert File.exist?(dl_path)
     assert_equal File.read(File.join(File.dirname(__FILE__), '..','ext','curb_easy.c')), File.read(dl_path)
   ensure
-    File.unlink(dl_path) if File.exist?(dl_path)
+    File.unlink(dl_path) if dl_path && File.exist?(dl_path)
   end
 
   def test_download_bad_url_gives_404

data/tests/tc_curl_easy.rb

@@ -48,20 +48,62 @@ class TestCurbCurlEasy < Test::Unit::TestCase
   end
 
   def test_curlopt_stderr_with_io
-    path = Tempfile.new('curb_test_curlopt_stderr').path
+    tmp = Tempfile.new('curb_test_curlopt_stderr')
+    path = tmp.path
     fd = IO.sysopen(path, 'w')
-    io = IO.for_fd(fd)
+    io = IO.new(fd, 'w')
+    io.sync = true
 
     easy = Curl::Easy.new(TestServlet.url)
     easy.verbose = true
     easy.setopt(Curl::CURLOPT_STDERR, io)
     easy.perform
 
+    io.flush
+    io.close
+    output = File.read(path)
+
+    assert_match(/HTTP\/1\.1\ 200\ OK(?:\ )?/, output)
+    assert_match('Host: 127.0.0.1:9129', output)
+  ensure
+    tmp.close! if defined?(tmp) && tmp
+  end
+
+  def test_curlopt_stderr_gc_safe
+    tmp = Tempfile.new('curb_test_curlopt_stderr_gc')
+    path = tmp.path
+    fd = IO.sysopen(path, 'w')
+    io = IO.new(fd, 'w')
+
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.verbose = true
+    easy.setopt(Curl::CURLOPT_STDERR, io)
+
+    # Drop our Ruby reference and force GC; curb should retain it internally
+    io = nil
+    GC.start
+
+    easy.perform
 
     output = File.read(path)
+    assert_match(/HTTP\/1\.1\ 200\ OK(?:\ )?/, output)
+    assert_match('Host: 127.0.0.1:9129', output)
+  ensure
+    tmp.close! if defined?(tmp) && tmp
+  end
 
-    assert_match(output, 'HTTP/1.1 200 OK')
-    assert_match(output, 'Host: 127.0.0.1:9129')
+  def test_head_request_no_body_and_no_timeout
+    # Ensure a HEAD request completes and does not attempt to read a body
+    # even when the server advertises a Content-Length.
+    easy = nil
+    assert_nothing_raised do
+      easy = Curl.http(:HEAD, TestServlet.url)
+    end
+    assert_not_nil easy
+    # Header string should contain the HTTP status line.
+    assert_match(/HTTP\/1\.1\s\d+\s/, easy.header_str.to_s)
+    # Body should be empty for HEAD requests (libcurl won't call the write callback).
+    assert_equal "", easy.body_str.to_s
   end
 
   def test_curlopt_stderr_fails_with_tempdir
@@ -245,6 +287,7 @@ class TestCurbCurlEasy < Test::Unit::TestCase
 
 
   def test_last_effective_url_01
+    omit('Windows file URL semantics differ') if WINDOWS
     c = Curl::Easy.new($TEST_URL)
     
     assert_equal $TEST_URL, c.url
@@ -1041,7 +1084,11 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     $auth_header = nil
     # curl checks the auth type supported by the server, so we have to create a 
     # new easy handle if we're going to change the auth type...
-
+    if WINDOWS
+      # On Windows, libcurl often uses SSPI for NTLM which yields a different
+      # header value and encoding; skip the NTLM-specific assertion.
+      return
+    end
     curl = Curl::Easy.new(TestServlet.url)
     curl.username = "foo"
     curl.password = "bar"
@@ -1073,7 +1120,7 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     easy.http_post(pf)
 
     assert_not_equal(0,easy.body.size)
-    assert_equal(Digest::MD5.hexdigest(easy.body), Digest::MD5.hexdigest(File.read(readme)))
+    assert_equal(Digest::MD5.hexdigest(easy.body), Digest::MD5.hexdigest(File.binread(readme)))
   end
 
   def test_easy_close
@@ -1095,6 +1142,18 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     easy.http_get
   end
 
+  def test_last_result_initialization
+    # Test for issue #463 - ensure last_result is properly initialized to 0
+    easy = Curl::Easy.new
+    assert_equal 0, easy.last_result, "last_result should be initialized to 0 for new instance"
+    
+    # Test that reset also sets last_result to 0
+    easy.url = TestServlet.url
+    easy.http_get
+    easy.reset
+    assert_equal 0, easy.last_result, "last_result should be reset to 0 after calling reset"
+  end
+
   def test_easy_use_http_versions
     easy = Curl::Easy.new
     easy.url = TestServlet.url + "?query=foo"

data/tests/tc_curl_multi.rb

@@ -10,6 +10,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
   # for https://github.com/taf2/curb/issues/277
   # must connect to an external
   def test_connection_keepalive
+    omit('Not supported on Windows runners') if WINDOWS
     # this test fails with libcurl 7.22.0. I didn't investigate, but it may be related
     # to CURLOPT_MAXCONNECTS bug fixed in 7.30.0:
     # https://github.com/curl/curl/commit/e87e76e2dc108efb1cae87df496416f49c55fca0
@@ -171,6 +172,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
   end
 
   def test_multi_easy_get_with_error
+    omit('Path/line parsing differs on Windows') if WINDOWS
     begin
       did_raise = false
       n = 3