curb 1.1.0 → 1.2.1

data/ext/curb_multi.h

@@ -8,18 +8,21 @@
 #define __CURB_MULTI_H
 
 #include "curb.h"
-#include "curb_easy.h"
 #include <curl/multi.h>
 
+struct st_table;
+
 typedef struct {
   int active;
   int running;
   CURLM *handle;
+  struct st_table *attached;
 } ruby_curl_multi;
 
 extern VALUE cCurlMulti;
 void init_curb_multi();
 VALUE ruby_curl_multi_new(VALUE klass);
+void rb_curl_multi_forget_easy(ruby_curl_multi *rbcm, void *rbce_ptr);
 
 
 #endif

data/ext/curb_postfield.c

@@ -209,6 +209,9 @@ void curl_postfield_free(ruby_curl_postfield *rbcpf) {
  */
 static VALUE ruby_curl_postfield_new_content(int argc, VALUE *argv, VALUE klass) {
   ruby_curl_postfield *rbcpf = ALLOC(ruby_curl_postfield);
+  if (!rbcpf) {
+    rb_raise(rb_eNoMemError, "Failed to allocate memory for Curl::PostField");
+  }
  
   // wierdness - we actually require two args, unless a block is provided, but
   // we have to work that out below.
@@ -255,6 +258,9 @@ static VALUE ruby_curl_postfield_new_content(int argc, VALUE *argv, VALUE klass)
 static VALUE ruby_curl_postfield_new_file(int argc, VALUE *argv, VALUE klass) {
   // TODO needs to handle content-type too
   ruby_curl_postfield *rbcpf = ALLOC(ruby_curl_postfield);
+  if (!rbcpf) {
+    rb_raise(rb_eNoMemError, "Failed to allocate memory for Curl::PostField");
+  }
 
   rb_scan_args(argc, argv, "21&", &rbcpf->name, &rbcpf->local_file, &rbcpf->remote_file, &rbcpf->content_proc);
 

data/ext/curb_upload.c

@@ -24,6 +24,9 @@ static void curl_upload_free(ruby_curl_upload *rbcu) {
 VALUE ruby_curl_upload_new(VALUE klass) {
   VALUE upload;
   ruby_curl_upload *rbcu = ALLOC(ruby_curl_upload);
+  if (!rbcu) {
+    rb_raise(rb_eNoMemError, "Failed to allocate memory for Curl::Upload");
+  }
   rbcu->stream = Qnil;
   rbcu->offset = 0;
   upload = Data_Wrap_Struct(klass, curl_upload_mark, curl_upload_free, rbcu);

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
@@ -325,6 +500,7 @@ have_constant "curlusessl_try"
 have_constant "curlusessl_control"
 have_constant "curlusessl_all"
 have_constant "curlopt_resolve"
+have_constant "curlopt_request_target"
 have_constant "curlopt_sslcert"
 have_constant "curlopt_sslcerttype"
 have_constant "curlopt_sslkey"
@@ -469,9 +645,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/lib/curl/easy.rb

@@ -158,6 +158,22 @@ module Curl
       set :proxy, url
     end
 
+    #
+    # call-seq:
+    #   easy.request_target = string                    => string
+    #
+    # Set the request-target used in the HTTP request line (libcurl CURLOPT_REQUEST_TARGET).
+    # Useful for absolute-form request targets (e.g., when speaking to proxies) or
+    # special targets like "*" (OPTIONS *). Requires libcurl with CURLOPT_REQUEST_TARGET support.
+    #
+    def request_target=(value)
+      if Curl.const_defined?(:CURLOPT_REQUEST_TARGET)
+        set :request_target, value
+      else
+        raise NotImplementedError, "CURLOPT_REQUEST_TARGET is not supported by this libcurl"
+      end
+    end
+
     def ssl_verify_host=(value)
       value = 1 if value.class == TrueClass
       value = 0 if value.class == FalseClass
@@ -216,9 +232,18 @@ module Curl
     # call-seq:
     #   easy.cookies = "name1=content1; name2=content2;" => string
     #
-    # Set cookies to be sent by this Curl::Easy instance. The format of the string should
-    # be NAME=CONTENTS, where NAME is the cookie name and CONTENTS is what the cookie should contain.
-    # Set multiple cookies in one string like this: "name1=content1; name2=content2;" etc.
+    # Set the manual Cookie request header for this Curl::Easy instance.
+    # The format of the string should be NAME=CONTENTS, where NAME is the cookie name and
+    # CONTENTS is what the cookie should contain. Set multiple cookies in one string like this:
+    # "name1=content1; name2=content2;".
+    #
+    # Notes:
+    # - This only affects the outgoing Cookie header (libcurl CURLOPT_COOKIE) and does NOT
+    #   alter the internal libcurl cookie engine (which stores cookies from Set-Cookie).
+    # - To change cookies stored in the engine, use {#cookielist} / {#cookielist=} or
+    #   {#set} with :cookielist.
+    # - To clear a previously set manual Cookie header, assign an empty string ('').
+    #   Assigning +nil+ has no effect in current curb versions.
     #
     def cookies=(value)
       set :cookie, value
@@ -233,6 +258,8 @@ module Curl
     # *Note* that you must set enable_cookies true to enable the cookie
     # engine, or this option will be ignored.
     #
+    # Note: assigning +nil+ has no effect; pass a path string to use a cookie file.
+    #
     def cookiefile=(value)
       set :cookiefile, value
     end
@@ -241,16 +268,40 @@ module Curl
     # call-seq:
     #   easy.cookiejar = string                          => string
     #
-    # Set a cookiejar file to use for this Curl::Easy instance.
-    # Cookies from the response will be written into this file.
+    # Set a cookiejar file to use for this Curl::Easy instance. Cookies from the response
+    # will be written into this file.
     #
     # *Note* that you must set enable_cookies true to enable the cookie
     # engine, or this option will be ignored.
     #
+    # Note: assigning +nil+ has no effect; pass a path string to persist cookies to a file.
+    #
     def cookiejar=(value)
       set :cookiejar, value
     end
 
+    #
+    # call-seq:
+    #   easy.cookielist = string                         => string
+    #
+    # Modify cookies in libcurl's internal cookie engine (CURLOPT_COOKIELIST).
+    # Accepts a Set-Cookie style string, one or more lines in Netscape cookie file format,
+    # or one of the special commands: "ALL" (clear), "SESS" (remove session cookies),
+    # "FLUSH" (write to jar), "RELOAD" (reload from file).
+    #
+    # Examples:
+    #   easy.cookielist = "Set-Cookie: session=42; Domain=example.com; Path=/;"
+    #   easy.cookielist = [
+    #     ['.example.com', 'TRUE', '/', 'FALSE', 0, 'c1', 'v1'].join("\t"),
+    #     ['.example.com', 'TRUE', '/', 'FALSE', 0, 'c2', 'v2'].join("\t"),
+    #     ''
+    #   ].join("\n")
+    #   easy.cookielist = 'ALL'   # clear all cookies in the engine
+    #
+    def cookielist=(value)
+      set :cookielist, value
+    end
+
     #
     # call-seq:
     #  easy = Curl::Easy.new("url") do|c|

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