ghazel-curb 0.5.9.0

data/ext/extconf.rb

@@ -0,0 +1,162 @@
+require 'mkmf'
+
+dir_config('curl')
+
+if find_executable('curl-config')
+  $CFLAGS << " #{`curl-config --cflags`.strip}"
+  if ENV['STATIC_BUILD']
+    $LIBS << " #{`curl-config --static-libs`.strip}"
+  else
+    $LIBS << " #{`curl-config --libs`.strip}"
+  end
+  ca_bundle_path=`curl-config --ca`.strip
+  if !ca_bundle_path.nil? and ca_bundle_path != ''
+    $defs.push( %{-D HAVE_CURL_CONFIG_CA} )
+    $defs.push( %{-D CURL_CONFIG_CA='#{ca_bundle_path.inspect}'} )
+  end
+elsif !have_library('curl') or !have_header('curl/curl.h')
+  fail <<-EOM
+  Can't find libcurl or curl/curl.h
+
+  Try passing --with-curl-dir or --with-curl-lib and --with-curl-include
+  options to extconf.
+  EOM
+end
+
+# Check arch flags
+archs = $CFLAGS.scan(/-arch\s(.*?)\s/).first # get the first arch flag
+if archs and archs.size >= 1
+  # need to reduce the number of archs...
+  # guess the first one is correct... at least the first one is probably the ruby installed arch...
+  # this could lead to compiled binaries that crash at runtime...
+  $CFLAGS.gsub!(/-arch\s(.*?)\s/,' ')
+  $CFLAGS << " -arch #{archs.first}"
+  puts "Selected arch: #{archs.first}"
+end
+
+def define(s)
+  $defs.push( format("-D HAVE_%s", s.to_s.upcase) )
+end
+
+def have_constant(name)
+  checking_for name do
+    src = %{
+      #include <curl/curl.h>
+      int main() {
+        int test = (int)#{name.upcase};
+        return 0;
+      }
+    }
+    if try_compile(src,"#{$CFLAGS} #{$LIBS}")
+      define name
+      true
+    else
+      false
+    end
+  end
+end
+
+have_constant "curlinfo_redirect_time"
+have_constant "curlinfo_response_code"
+have_constant "curlinfo_filetime"
+have_constant "curlinfo_redirect_count"
+have_constant "curlinfo_os_errno"
+have_constant "curlinfo_num_connects"
+have_constant "curlinfo_ftp_entry_path"
+have_constant "curl_version_ssl"
+have_constant "curl_version_libz"
+have_constant "curl_version_ntlm"
+have_constant "curl_version_gssnegotiate"
+have_constant "curl_version_debug"
+have_constant "curl_version_asynchdns"
+have_constant "curl_version_spnego"
+have_constant "curl_version_largefile"
+have_constant "curl_version_idn"
+have_constant "curl_version_sspi"
+have_constant "curl_version_conv"
+have_constant "curlproxy_http"
+have_constant "curlproxy_socks4"
+have_constant "curlproxy_socks5"
+have_constant "curlauth_basic"
+have_constant "curlauth_digest"
+have_constant "curlauth_gssnegotiate"
+have_constant "curlauth_ntlm"
+have_constant "curlauth_anysafe"
+have_constant "curlauth_any"
+have_constant "curle_tftp_notfound"
+have_constant "curle_tftp_perm"
+have_constant "curle_tftp_diskfull"
+have_constant "curle_tftp_illegal"
+have_constant "curle_tftp_unknownid"
+have_constant "curle_tftp_exists"
+have_constant "curle_tftp_nosuchuser"
+# older versions of libcurl 7.12
+have_constant "curle_send_fail_rewind"
+have_constant "curle_ssl_engine_initfailed"
+have_constant "curle_login_denied"
+
+# older than 7.16.3
+have_constant "curlmopt_maxconnects"
+
+# additional consts
+have_constant "curle_conv_failed"
+have_constant "curle_conv_reqd"
+have_constant "curle_ssl_cacert_badfile"
+have_constant "curle_remote_file_not_found"
+have_constant "curle_ssh"
+have_constant "curle_ssl_shutdown_failed"
+have_constant "curle_again"
+have_constant "curle_ssl_crl_badfile"
+have_constant "curle_ssl_issuer_error"
+
+# centos 4.5 build of libcurl
+have_constant "curlm_bad_socket"
+have_constant "curlm_unknown_option"
+have_func("curl_multi_timeout")
+have_func("curl_multi_fdset")
+have_func("curl_multi_perform")
+
+if try_compile('int main() { return 0; }','-Wall')
+  $CFLAGS << ' -Wall'
+end
+
+# do some checking to detect ruby 1.8 hash.c vs ruby 1.9 hash.c
+def test_for(name, const, src)
+  checking_for name do
+    if try_compile(src,"#{$CFLAGS} #{$LIBS}")
+      define const
+      true
+    else
+      false
+    end
+  end
+end
+test_for("Ruby 1.9 Hash", "RUBY19_HASH", %{
+  #include <ruby.h>
+  int main() {
+    VALUE hash = rb_hash_new();
+    if( RHASH(hash)->ntbl->num_entries ) {
+      return 0;
+    }
+    return 1;
+  }
+})
+test_for("Ruby 1.9 st.h", "RUBY19_ST_H", %{
+  #include <ruby.h>
+  #include <ruby/st.h>
+  int main() {
+    return 0;
+  }
+})
+
+test_for("curl_easy_escape", "CURL_EASY_ESCAPE", %{
+  #include <curl/curl.h>
+  int main() {
+    CURL *easy = curl_easy_init();
+    curl_easy_escape(easy,"hello",5);
+    return 0;
+  }
+})
+
+create_header('curb_config.h')
+create_makefile('curb_core')

data/lib/curb.rb

@@ -0,0 +1,184 @@
+require 'curb_core'
+
+module Curl
+  class Easy
+    class << self
+    
+      # call-seq:
+      #   Curl::Easy.download(url, filename = url.split(/\?/).first.split(/\//).last) { |curl| ... }
+      #   
+      # Stream the specified url (via perform) and save the data directly to the
+      # supplied filename (defaults to the last component of the URL path, which will 
+      # usually be the filename most simple urls).
+      # 
+      # If a block is supplied, it will be passed the curl instance prior to the
+      # perform call.
+      # 
+      # *Note* that the semantics of the on_body handler are subtly changed when using
+      # download, to account for the automatic routing of data to the specified file: The 
+      # data string is passed to the handler *before* it is written
+      # to the file, allowing the handler to perform mutative operations where 
+      # necessary. As usual, the transfer will be aborted if the on_body handler
+      # returns a size that differs from the data chunk size - in this case, the 
+      # offending chunk will *not* be written to the file, the file will be closed,
+      # and a Curl::Err::AbortedByCallbackError will be raised.
+      def download(url, filename = url.split(/\?/).first.split(/\//).last, &blk)
+        curl = Curl::Easy.new(url, &blk)
+        
+        File.open(filename, "wb") do |output|
+          old_on_body = curl.on_body do |data| 
+            result = old_on_body ?  old_on_body.call(data) : data.length
+            output << data if result == data.length
+            result
+          end
+          
+          curl.perform
+        end        
+
+        return curl
+      end
+    end
+
+    # Allow the incoming cert string to be file:password
+    # but be careful to not use a colon from a windows file path
+    # as the split point. Mimic what curl's main does
+    alias_method :native_cert=, :cert=
+    def cert=(cert_file)
+      pos = cert_file.rindex(':')
+      if pos && pos > 1
+        self.native_cert= cert_file[0..pos-1]
+        self.certpassword= cert_file[pos+1..-1]
+      else
+        self.native_cert= cert_file
+      end
+      self.cert
+    end
+  end
+  class Multi
+    class << self
+      # call-seq:
+      #   Curl::Multi.get('url1','url2','url3','url4','url5', :follow_location => true) do|easy|
+      #     easy
+      #   end
+      # 
+      # Blocking call to fetch multiple url's in parallel.
+      def get(urls, easy_options={}, multi_options={}, &blk)
+        url_confs = []
+        urls.each do|url|
+          url_confs << {:url => url, :method => :get}.merge(easy_options)
+        end
+        self.http(url_confs, multi_options) {|c,code,method| blk.call(c) }
+      end
+
+      # call-seq:
+      #
+      #   Curl::Multi.post([{:url => 'url1', :post_fields => {'field1' => 'value1', 'field2' => 'value2'}},
+      #                     {:url => 'url2', :post_fields => {'field1' => 'value1', 'field2' => 'value2'}},
+      #                     {:url => 'url3', :post_fields => {'field1' => 'value1', 'field2' => 'value2'}}],
+      #                    { :follow_location => true, :multipart_form_post => true },
+      #                    {:pipeline => true }) do|easy|
+      #     easy_handle_on_request_complete
+      #   end
+      # 
+      # Blocking call to POST multiple form's in parallel.
+      # 
+      # urls_with_config: is a hash of url's pointing to the postfields to send 
+      # easy_options: are a set of common options to set on all easy handles
+      # multi_options: options to set on the Curl::Multi handle
+      #
+      def post(urls_with_config, easy_options={}, multi_options={}, &blk)
+        url_confs = []
+        urls_with_config.each do|uconf|
+          url_confs << uconf.merge(:method => :post).merge(easy_options)
+        end
+        self.http(url_confs, multi_options) {|c,code,method| blk.call(c) }
+      end
+
+      # call-seq:
+      #
+      #   Curl::Multi.put([{:url => 'url1', :put_data => "some message"},
+      #                    {:url => 'url2', :put_data => IO.read('filepath')},
+      #                    {:url => 'url3', :put_data => "maybe another string or socket?"],
+      #                    {:follow_location => true},
+      #                    {:pipeline => true }) do|easy|
+      #     easy_handle_on_request_complete
+      #   end
+      # 
+      # Blocking call to POST multiple form's in parallel.
+      # 
+      # urls_with_config: is a hash of url's pointing to the postfields to send 
+      # easy_options: are a set of common options to set on all easy handles
+      # multi_options: options to set on the Curl::Multi handle
+      #
+      def put(urls_with_config, easy_options={}, multi_options={}, &blk)
+        url_confs = []
+        urls_with_config.each do|uconf|
+          url_confs << uconf.merge(:method => :put).merge(easy_options)
+        end
+        self.http(url_confs, multi_options) {|c,code,method| blk.call(c) }
+      end
+
+
+      # call-seq:
+      #
+      # Curl::Multi.http( [
+      #   { :url => 'url1', :method => :post,
+      #     :post_fields => {'field1' => 'value1', 'field2' => 'value2'} },
+      #   { :url => 'url2', :method => :get,
+      #     :follow_location => true, :max_redirects => 3 },
+      #   { :url => 'url3', :method => :put, :put_data => File.open('file.txt','rb') },
+      #   { :url => 'url4', :method => :head }
+      # ], {:pipeline => true})
+      #
+      # Blocking call to issue multiple HTTP requests with varying verb's.
+      #
+      # urls_with_config: is a hash of url's pointing to the easy handle options as well as the special option :method, that can by one of [:get, :post, :put, :delete, :head], when no verb is provided e.g. :method => nil -> GET is used
+      # multi_options: options for the multi handle 
+      # blk: a callback, that yeilds when a handle is completed
+      #
+      def http(urls_with_config, multi_options={}, &blk)
+        m = Curl::Multi.new
+        # configure the multi handle
+        multi_options.each { |k,v| m.send("#{k}=", v) }
+
+        urls_with_config.each do|conf|
+          c = conf.dup # avoid being destructive to input
+          url     = c.delete(:url)
+          method  = c.delete(:method)
+          headers = c.delete(:headers)
+
+          easy    = Curl::Easy.new(url)
+
+          case method
+          when :post
+            fields = c.delete(:post_fields)
+            # set the post post using the url fields
+            easy.post_body = fields.map{|f,k| "#{easy.escape(f)}=#{easy.escape(k)}"}.join('&')
+          when :put
+            easy.put_data = c.delete(:put_data)
+          when :head
+            easy.head = true
+          when :delete
+            easy.delete = true
+          when :get
+          else
+            # XXX: nil is treated like a GET
+          end
+
+          # headers is a special key
+          headers.each {|k,v| easy.headers[k] = v } if headers
+ 
+          #
+          # use the remaining options as specific configuration to the easy handle
+          # bad options should raise an undefined method error
+          #
+          c.each { |k,v| easy.send("#{k}=",v) }
+
+          easy.on_complete {|curl,code| blk.call(curl,code,method) } if blk
+          m.add(easy)
+        end
+        m.perform
+      end
+    end
+  end
+end

data/lib/curl.rb

@@ -0,0 +1,2 @@
+require 'curb'
+

data/tests/alltests.rb

@@ -0,0 +1,3 @@
+$: << $TESTDIR = File.expand_path(File.dirname(__FILE__))
+require 'unittests'
+Dir[File.join($TESTDIR, 'bug_*.rb')].each { |lib| require lib }

data/tests/bug_curb_easy_blocks_ruby_threads.rb

@@ -0,0 +1,52 @@
+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|
+      sleep 0.5
+      res.body = "hi"
+      res['Content-Type'] = "text/html"
+    end
+
+    thread = Thread.new(server) do|srv|
+      srv.start
+    end
+
+    threads = []
+    timer = Time.now
+
+    5.times do |i|
+      t = Thread.new do
+        c = Curl::Easy.perform('http://localhost:9999/test')
+        c.header_str
+      end
+      threads << t
+    end
+
+    multi_responses = threads.collect do|t|
+      t.value
+    end
+
+    multi_time = (Time.now - timer)
+    puts "requested in #{multi_time}"
+
+    timer = Time.now
+    single_responses = []
+    5.times do |i|
+      c = Curl::Easy.perform('http://localhost:9999/test')
+      single_responses << c.header_str
+    end
+    
+    single_time = (Time.now - timer)
+    puts "requested in #{single_time}"
+
+    assert single_time > multi_time
+
+    server.shutdown
+    thread.join
+  end
+end

data/tests/bug_instance_post_differs_from_class_post.rb

@@ -0,0 +1,53 @@
+# From Vlad Jebelev:
+#
+# - Second thing - I think you just probably didn't have the time to update 
+# instance methods yet but when I POST with a reusal of a previous curl 
+# instance, it doesnt' work for me, e.g. when I create a curl previously and 
+# then issue:
+#  
+#   c.http_post(login_url, *fields)
+#   
+# instead of:
+#  
+#   c = Curl::Easy.http_post(login_url, *fields) do |curl|
+#     ...  
+#   end
+#    
+# then the result I am getting is quite different.
+#
+# ================
+#
+# Update:
+#
+#   It seems that class httpost is incorrectly passing arguments down to 
+#   instance httppost. This bug is intermittent, but results in an
+#   exception from the first post when it occurs.
+#   
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class BugTestInstancePostDiffersFromClassPost < Test::Unit::TestCase
+  def test_bug
+    5.times do |i|
+      puts "Test ##{i}"
+      do_test
+      sleep 2
+    end
+  end
+
+  def do_test
+    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
+
+    # timestamps will differ, just check first bit. We wont get here if
+    # the bug bites anyway...
+    assert_equal header_c[0..50], header_i[0..50]
+  end
+end
+

data/tests/bug_multi_segfault.rb

@@ -0,0 +1,10 @@
+# From safis  http://github.com/taf2/curb/issues#issue/5
+# irb: require 'curb'
+# irb: multi = Curl::Multi.new
+# irb: exit
+# <main>:47140: [BUG] Bus Error
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__),'..','ext'))
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__),'..','lib'))
+require 'curb'
+multi = Curl::Multi.new
+exit

data/tests/bug_require_last_or_segfault.rb

@@ -0,0 +1,40 @@
+# From Vlad Jebelev:
+# 
+# - if I have a require statement after "require 'curb'" and there is a 
+# POST with at least 1 field, the script will fail with a segmentation 
+# fault, e.g. the following sequence fails every time for me (Ruby 1.8.5):
+# -----------------------------------------------------------------
+# require 'curb'
+# require 'uri'
+#  
+#  url = 'https://www.google.com/accounts/ServiceLoginAuth'
+#   
+#  c = Curl::Easy.http_post(
+#         'https://www.google.com/accounts/ServiceLoginAuth',
+#               [Curl:: PostField.content('ltmpl','m_blanco')] ) do |curl|
+#  end
+#  ------------------------------------------------------------------
+#  :..dev/util$ ruby seg.rb
+#  seg.rb:6: [BUG] Segmentation fault
+#  ruby 1.8.5 (2006-08-25) [i686-linux]
+#                
+#  Aborted
+#  ------------------------------------------------------------------
+#
+require 'test/unit'
+require 'rbconfig'
+
+$rubycmd = Config::CONFIG['RUBY_INSTALL_NAME'] || 'ruby'
+
+class BugTestRequireLastOrSegfault < Test::Unit::TestCase
+  def test_bug
+    5.times do |i|
+      puts "Test ##{i}"
+
+      # will be empty string if it segfaults...
+      assert_equal 'success', `#$rubycmd #{File.dirname(__FILE__)}/require_last_or_segfault_script.rb`.chomp
+      sleep 5
+    end
+  end
+end
+

data/tests/helper.rb

@@ -0,0 +1,168 @@
+# DO NOT REMOVE THIS COMMENT - PART OF TESTMODEL.
+# Copyright (c)2006 Ross Bamford. See LICENSE.
+$CURB_TESTING = true
+require 'uri'
+
+$TOPDIR = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+$EXTDIR = File.join($TOPDIR, 'ext')
+$LIBDIR = File.join($TOPDIR, 'lib')
+$:.unshift($LIBDIR)
+$:.unshift($EXTDIR)
+
+require 'curb'
+require 'test/unit'
+
+$TEST_URL = "file://#{URI.escape(File.expand_path(__FILE__).tr('\\','/').tr(':','|'))}"
+
+require 'thread'
+require 'webrick'
+
+# set this to true to avoid testing with multiple threads
+# or to test with multiple threads set it to false
+# this is important since, some code paths will change depending
+# on the presence of multiple threads
+TEST_SINGLE_THREADED=false
+
+# keep webrick quiet
+class ::WEBrick::HTTPServer
+  def access_log(config, req, res)
+    # nop
+  end
+end
+class ::WEBrick::BasicLog
+  def log(level, data)
+    # nop
+  end
+end
+
+#
+# Simple test server to record number of times a request is sent/recieved of a specific 
+# request type, e.g. GET,POST,PUT,DELETE
+#
+class TestServlet < WEBrick::HTTPServlet::AbstractServlet
+
+  def self.port=(p)
+    @port = p
+  end
+
+  def self.port
+    (@port or 9129)
+  end
+
+  def self.path
+    '/methods'
+  end
+
+  def self.url
+    "http://127.0.0.1:#{port}#{path}"
+  end
+
+  def respond_with(method,req,res)
+    res.body = method.to_s
+    res['Content-Type'] = "text/plain"
+  end
+
+  def do_GET(req,res)
+    respond_with(:GET,req,res)
+  end
+
+  def do_HEAD(req,res)
+    res['Location'] = "/nonexistent"
+    respond_with(:HEAD, req, res)
+  end
+
+  def do_POST(req,res)
+    if req.body
+      params = {}
+      req.body.split('&').map{|s| k,v=s.split('='); params[k] = v }
+    end
+    if params and params['s'] == '500'
+      res.status = 500
+    else
+      respond_with("POST\n#{req.body}",req,res)
+    end
+  end
+
+  def do_PUT(req,res)
+    res['X-Requested-Content-Type'] = req.content_type
+    respond_with("PUT\n#{req.body}",req,res)
+  end
+
+  def do_DELETE(req,res)
+    respond_with(:DELETE,req,res)
+  end
+
+end
+
+module TestServerMethods
+  def locked_file
+    File.join(File.dirname(__FILE__),"server_lock-#{@__port}")
+  end
+
+  def server_setup(port=9129,servlet=TestServlet)
+    @__port = port
+    if @server.nil? and !File.exist?(locked_file)
+
+      File.open(locked_file,'w') {|f| f << 'locked' }
+      if TEST_SINGLE_THREADED
+        rd, wr = IO.pipe
+        @__pid = fork do
+          rd.close
+          rd = nil
+
+          # start up a webrick server for testing delete 
+          server = WEBrick::HTTPServer.new :Port => port, :DocumentRoot => File.expand_path(File.dirname(__FILE__))
+
+          server.mount(servlet.path, servlet)
+          server.mount("/ext", WEBrick::HTTPServlet::FileHandler, File.join(File.dirname(__FILE__),'..','ext'))
+
+          trap("INT") { server.shutdown }
+          GC.start
+          wr.flush
+          wr.close
+          server.start
+        end
+        wr.close
+        rd.read
+        rd.close
+      else
+        # start up a webrick server for testing delete 
+        @server = WEBrick::HTTPServer.new :Port => port, :DocumentRoot => File.expand_path(File.dirname(__FILE__))
+
+        @server.mount(servlet.path, servlet)
+        @server.mount("/ext", WEBrick::HTTPServlet::FileHandler, File.join(File.dirname(__FILE__),'..','ext'))
+        queue = Queue.new # synchronize the thread startup to the main thread
+
+        @test_thread = Thread.new { queue << 1; @server.start }
+
+        # wait for the queue
+        value = queue.pop
+        if !value
+          STDERR.puts "Failed to startup test server!"
+          exit(1)
+        end
+
+      end
+
+      exit_code = lambda do
+        begin
+          if File.exist?(locked_file)
+            File.unlink locked_file
+            if TEST_SINGLE_THREADED
+              Process.kill 'INT', @__pid
+            else
+              @server.shutdown unless @server.nil?
+            end
+          end
+          #@server.shutdown unless @server.nil?
+        rescue Object => e
+          puts "Error #{__FILE__}:#{__LINE__}\n#{e.message}"
+        end
+      end
+
+      trap("INT"){exit_code.call}
+      at_exit{exit_code.call}
+
+    end
+  end
+end