curb 0.7.15 → 0.7.16

data/ext/curb_easy.h

@@ -56,6 +56,7 @@ typedef struct {
   long ssl_version;
   long use_ssl;
   long ftp_filemethod;
+  unsigned short resolve_mode;
 
   /* bool flags */
   char proxy_tunnel;

data/ext/curb_errors.c

@@ -28,6 +28,7 @@ VALUE eCurlErrUnsupportedProtocol;
 VALUE eCurlErrFailedInit;
 VALUE eCurlErrMalformedURL;
 VALUE eCurlErrMalformedURLUser;
+VALUE eCurlErrNotBuiltIn;
 VALUE eCurlErrProxyResolution;
 VALUE eCurlErrHostResolution;
 VALUE eCurlErrConnectFailed;
@@ -141,9 +142,15 @@ VALUE rb_curl_easy_error(CURLcode code) {
     case CURLE_URL_MALFORMAT:           /* 3 */
       exclz = eCurlErrMalformedURL;
       break;
+#ifdef HAVE_CURLE_NOT_BUILT_IN
+    case CURLE_NOT_BUILT_IN:            /* 4 - [was obsoleted in August 2007 for 7.17.0, reused in April 2011 for 7.21.5] */
+      exclz = eCurlErrNotBuiltIn;
+      break;
+#else
     case CURLE_URL_MALFORMAT_USER:      /* 4 (NOT USED) */
       exclz = eCurlErrMalformedURLUser;
       break;
+#endif
     case CURLE_COULDNT_RESOLVE_PROXY:   /* 5 */
       exclz = eCurlErrProxyResolution;
       break;
@@ -518,6 +525,7 @@ void init_curb_errors() {
   eCurlErrUnsupportedProtocol = rb_define_class_under(mCurlErr, "UnsupportedProtocolError", eCurlErrError);
   eCurlErrFailedInit = rb_define_class_under(mCurlErr, "FailedInitError", eCurlErrError);
   eCurlErrMalformedURL = rb_define_class_under(mCurlErr, "MalformedURLError", eCurlErrError);
+  eCurlErrNotBuiltIn = rb_define_class_under(mCurlErr, "NotBuiltInError", eCurlErrError);
   eCurlErrMalformedURLUser = rb_define_class_under(mCurlErr, "MalformedURLUserError", eCurlErrError);
   eCurlErrProxyResolution = rb_define_class_under(mCurlErr, "ProxyResolutionError", eCurlErrError);
   eCurlErrHostResolution = rb_define_class_under(mCurlErr, "HostResolutionError", eCurlErrError);

data/ext/curb_macros.h

@@ -8,6 +8,7 @@
 #ifndef __CURB_MACROS_H
 #define __CURB_MACROS_H
 
+#define rb_easy_sym(sym) ID2SYM(rb_intern(sym))
 #define rb_easy_hkey(key) ID2SYM(rb_intern(key))
 #define rb_easy_set(key,val) rb_hash_aset(rbce->opts, rb_easy_hkey(key) , val)
 #define rb_easy_get(key) rb_hash_aref(rbce->opts, rb_easy_hkey(key))
@@ -152,4 +153,7 @@
               return INT2FIX(ptr->attr);                            \
             }
 
+#define CURB_DEFINE(name) \
+  rb_define_const(mCurl, #name, INT2FIX(name))
+
 #endif

data/ext/curb_multi.c

@@ -3,7 +3,6 @@
  * Licensed under the Ruby License. See LICENSE for details.
  *
  */
-
 #include "curb_config.h"
 #ifdef HAVE_RUBY19_ST_H
   #include <ruby.h>
@@ -39,13 +38,12 @@ 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 void rb_curl_multi_mark_all_easy(VALUE key, VALUE rbeasy, ruby_curl_multi *rbcm) {
-  rb_gc_mark(rbeasy);
-}
+static VALUE callback_exception(VALUE unused) {
+  return Qfalse;
+} 
 
 static void curl_multi_mark(ruby_curl_multi *rbcm) {
   rb_gc_mark(rbcm->requests);
-  rb_hash_foreach( rbcm->requests, (int (*)())rb_curl_multi_mark_all_easy, (VALUE)rbcm );
 }
 
 static void curl_multi_flush_easy(VALUE key, VALUE easy, ruby_curl_multi *rbcm) {
@@ -245,8 +243,6 @@ VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
 
   rb_hash_aset( rbcm->requests, easy, easy );
 
-  rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
-
   return self;
 }
 
@@ -323,11 +319,20 @@ static VALUE ruby_curl_multi_cancel(VALUE self) {
   return self;
 }
 
+// on_success, on_failure, on_complete
+static VALUE call_status_handler1(VALUE ary) {
+  return rb_funcall(rb_ary_entry(ary, 0), idCall, 1, rb_ary_entry(ary, 1));
+}
+static VALUE call_status_handler2(VALUE ary) {
+  return rb_funcall(rb_ary_entry(ary, 0), idCall, 2, rb_ary_entry(ary, 1), rb_ary_entry(ary, 2));
+}
+
 static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int result) {
 
   long response_code = -1;
   VALUE easy;
   ruby_curl_easy *rbce = NULL;
+  VALUE callargs;
 
   CURLcode ecode = curl_easy_getinfo(easy_handle, CURLINFO_PRIVATE, (char**)&easy);
 
@@ -348,24 +353,32 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
   }
 
   if (!rb_easy_nil("complete_proc")) {
-    rb_funcall( rb_easy_get("complete_proc"), idCall, 1, easy );
+    callargs = rb_ary_new3(2, rb_easy_get("complete_proc"), easy);
+    rb_rescue(call_status_handler1, callargs, callback_exception, Qnil);
+    //rb_funcall( rb_easy_get("complete_proc"), idCall, 1, easy );
   }
 
   curl_easy_getinfo(rbce->curl, CURLINFO_RESPONSE_CODE, &response_code);
 
   if (result != 0) {
     if (!rb_easy_nil("failure_proc")) {
-      rb_funcall( rb_easy_get("failure_proc"), idCall, 2, easy, rb_curl_easy_error(result) );
+      callargs = rb_ary_new3(3, rb_easy_get("failure_proc"), easy, rb_curl_easy_error(result));
+      rb_rescue(call_status_handler2, callargs, callback_exception, Qnil);
+      //rb_funcall( rb_easy_get("failure_proc"), idCall, 2, easy, rb_curl_easy_error(result) );
     }
   }
   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 */
-    rb_funcall( rb_easy_get("success_proc"), idCall, 1, easy );
+    callargs = rb_ary_new3(2, rb_easy_get("success_proc"), easy);
+    rb_rescue(call_status_handler1, callargs, callback_exception, Qnil);
+    //rb_funcall( rb_easy_get("success_proc"), idCall, 1, easy );
   }
   else if (!rb_easy_nil("failure_proc") &&
           (response_code >= 300 && response_code <= 999)) {
-    rb_funcall( rb_easy_get("failure_proc"), idCall, 2, easy, rb_curl_easy_error(result) );
+    callargs = rb_ary_new3(3, rb_easy_get("failure_proc"), easy, rb_curl_easy_error(result));
+    rb_rescue(call_status_handler2, callargs, callback_exception, Qnil);
+    //rb_funcall( rb_easy_get("failure_proc"), idCall, 2, easy, rb_curl_easy_error(result) );
   }
 
 }
@@ -465,6 +478,8 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
   timeout_milliseconds = cCurlMutiDefaulttimeout;
 
   rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
+  rb_curl_multi_read_info( self, rbcm->handle );
+  if (block != Qnil) { rb_funcall(block, rb_intern("call"), 1, self);  }
  
   do {
     while (rbcm->running) {

data/ext/extconf.rb

@@ -35,16 +35,17 @@ end
 #  puts "Selected arch: #{archs.first}"
 #end
 
-def define(s)
-  $defs.push( format("-D HAVE_%s", s.to_s.upcase) )
+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)#{name.upcase};
+        int test = (int)#{sname};
         return 0;
       }
     }
@@ -52,6 +53,7 @@ def have_constant(name)
       define name
       true
     else
+      #define name, 0
       false
     end
   end
@@ -130,6 +132,213 @@ have_func("curl_multi_timeout")
 have_func("curl_multi_fdset")
 have_func("curl_multi_perform")
 
+# constants
+have_constant "curlopt_interleavefunction"
+have_constant "curlopt_interleavedata"
+have_constant "curlopt_chunk_bgn_function"
+have_constant "curlopt_chunk_end_function"
+have_constant "curlopt_chunk_data"
+have_constant "curlopt_fnmatch_function"
+have_constant "curlopt_fnmatch_data"
+have_constant "curlopt_errorbuffer"
+have_constant "curlopt_stderr"
+have_constant "curlopt_failonerror"
+have_constant "curlopt_url"
+have_constant "curlopt_protocols"
+have_constant "curlopt_redir_protocols"
+have_constant "curlopt_proxy"
+have_constant "curlopt_proxyport"
+have_constant "curlopt_proxytype"
+have_constant "curlopt_noproxy"
+have_constant "curlopt_httpproxytunnel"
+have_constant "curlopt_socks5_gssapi_service"
+have_constant "curlopt_socks5_gssapi_nec"
+have_constant "curlopt_interface"
+have_constant "curlopt_localport"
+have_constant "curlopt_dns_cache_timeout"
+have_constant "curlopt_dns_use_global_cache"
+have_constant "curlopt_buffersize"
+have_constant "curlopt_port"
+have_constant "curlopt_tcp_nodelay"
+have_constant "curlopt_address_scope"
+have_constant "curlopt_netrc"
+have_constant "curl_netrc_optional"
+have_constant "curl_netrc_ignored"
+have_constant "curl_netrc_required"
+have_constant "curlopt_netrc_file"
+have_constant "curlopt_userpwd"
+have_constant "curlopt_proxyuserpwd"
+have_constant "curlopt_username"
+have_constant "curlopt_password"
+have_constant "curlopt_password"
+have_constant "curlopt_password"
+have_constant "curlopt_httpauth"
+have_constant "curlauth_digest_ie"
+have_constant "curlauth_only"
+have_constant "curlopt_tlsauth_type"
+have_constant "curlopt_tlsauth_srp"
+have_constant "curlopt_tlsauth_username"
+have_constant "curlopt_tlsauth_password"
+have_constant "curlopt_proxyauth"
+have_constant "curlopt_autoreferer"
+have_constant "curlopt_encoding"
+have_constant "curlopt_followlocation"
+have_constant "curlopt_unrestricted_auth"
+have_constant "curlopt_maxredirs"
+have_constant "curlopt_postredir"
+have_constant "curlopt_put"
+have_constant "curlopt_post"
+have_constant "curlopt_postfields"
+have_constant "curlopt_postfieldsize"
+have_constant "curlopt_postfieldsize_large"
+have_constant "curlopt_copypostfields"
+have_constant "curlopt_httppost"
+have_constant "curlopt_referer"
+have_constant "curlopt_useragent"
+have_constant "curlopt_httpheader"
+have_constant "curlopt_http200aliases"
+have_constant "curlopt_cookie"
+have_constant "curlopt_cookiefile"
+have_constant "curlopt_cookiejar"
+have_constant "curlopt_cookiesession"
+have_constant "curlopt_cookielist"
+have_constant "curlopt_httpget"
+have_constant "curlopt_http_version"
+have_constant "curl_http_version_none"
+have_constant "curl_http_version_1_0"
+have_constant "curl_http_version_1_1"
+have_constant "curlopt_ignore_content_length"
+have_constant "curlopt_http_content_decoding"
+have_constant "curlopt_http_transfer_decoding"
+have_constant "curlopt_mail_from"
+have_constant "curlopt_mail_rcpt"
+have_constant "curlopt_tftp_blksize"
+have_constant "curlopt_ftpport"
+have_constant "curlopt_quote"
+have_constant "curlopt_postquote"
+have_constant "curlopt_prequote"
+have_constant "curlopt_dirlistonly"
+have_constant "curlopt_append"
+have_constant "curlopt_ftp_use_eprt"
+have_constant "curlopt_ftp_use_epsv"
+have_constant "curlopt_ftp_use_pret"
+have_constant "curlopt_ftp_create_missing_dirs"
+have_constant "curlopt_ftp_response_timeout"
+have_constant "curlopt_ftp_alternative_to_user"
+have_constant "curlopt_ftp_skip_pasv_ip"
+have_constant "curlopt_ftpsslauth"
+have_constant "curlftpauth_default"
+have_constant "curlftpauth_ssl"
+have_constant "curlftpauth_tls"
+have_constant "curlopt_ftp_ssl_ccc"
+have_constant "curlftpssl_ccc_none"
+have_constant "curlftpssl_ccc_passive"
+have_constant "curlftpssl_ccc_active"
+have_constant "curlopt_ftp_account"
+have_constant "curlopt_ftp_filemethod"
+have_constant "curlftpmethod_multicwd"
+have_constant "curlftpmethod_nocwd"
+have_constant "curlftpmethod_singlecwd"
+have_constant "curlopt_rtsp_request"
+have_constant "curl_rtspreq_options"
+have_constant "curl_rtspreq_describe"
+have_constant "curl_rtspreq_announce"
+have_constant "curl_rtspreq_setup"
+have_constant "curl_rtspreq_play"
+have_constant "curl_rtspreq_pause"
+have_constant "curl_rtspreq_teardown"
+have_constant "curl_rtspreq_get_parameter"
+have_constant "curl_rtspreq_set_parameter"
+have_constant "curl_rtspreq_record"
+have_constant "curl_rtspreq_receive"
+have_constant "curlopt_rtsp_session_id"
+have_constant "curlopt_rtsp_stream_uri"
+have_constant "curlopt_rtsp_transport"
+have_constant "curlopt_rtsp_header"
+have_constant "curlopt_rtsp_client_cseq"
+have_constant "curlopt_rtsp_server_cseq"
+have_constant "curlopt_transfertext"
+have_constant "curlopt_proxy_transfer_mode"
+have_constant "curlopt_crlf"
+have_constant "curlopt_range"
+have_constant "curlopt_resume_from"
+have_constant "curlopt_resume_from_large"
+have_constant "curlopt_customrequest"
+have_constant "curlopt_filetime"
+have_constant "curlopt_nobody"
+have_constant "curlopt_infilesize"
+have_constant "curlopt_infilesize_large"
+have_constant "curlopt_upload"
+have_constant "curlopt_maxfilesize"
+have_constant "curlopt_maxfilesize_large"
+have_constant "curlopt_timecondition"
+have_constant "curlopt_timevalue"
+have_constant "curlopt_timeout"
+have_constant "curlopt_timeout_ms"
+have_constant "curlopt_low_speed_limit"
+have_constant "curlopt_low_speed_time"
+have_constant "curlopt_max_send_speed_large"
+have_constant "curlopt_max_recv_speed_large"
+have_constant "curlopt_maxconnects"
+have_constant "curlopt_closepolicy"
+have_constant "curlopt_fresh_connect"
+have_constant "curlopt_forbid_reuse"
+have_constant "curlopt_connecttimeout"
+have_constant "curlopt_connecttimeout_ms"
+have_constant "curlopt_ipresolve"
+have_constant "curl_ipresolve_whatever"
+have_constant "curl_ipresolve_v4"
+have_constant "curl_ipresolve_v6"
+have_constant "curlopt_connect_only"
+have_constant "curlopt_use_ssl"
+have_constant "curlusessl_none"
+have_constant "curlusessl_try"
+have_constant "curlusessl_control"
+have_constant "curlusessl_all"
+have_constant "curlopt_resolve"
+have_constant "curlopt_sslcert"
+have_constant "curlopt_sslcerttype"
+have_constant "curlopt_sslkey"
+have_constant "curlopt_sslkeytype"
+have_constant "curlopt_keypasswd"
+have_constant "curlopt_sslengine"
+have_constant "curlopt_sslengine_default"
+have_constant "curlopt_sslversion"
+have_constant "curl_sslversion_default"
+have_constant :CURL_SSLVERSION_TLSv1
+have_constant :CURL_SSLVERSION_SSLv2
+have_constant :CURL_SSLVERSION_SSLv3
+have_constant "curlopt_ssl_verifypeer"
+have_constant "curlopt_cainfo"
+have_constant "curlopt_issuercert"
+have_constant "curlopt_capath"
+have_constant "curlopt_crlfile"
+have_constant "curlopt_ssl_verifyhost"
+have_constant "curlopt_certinfo"
+have_constant "curlopt_random_file"
+have_constant "curlopt_egdsocket"
+have_constant "curlopt_ssl_cipher_list"
+have_constant "curlopt_ssl_sessionid_cache"
+have_constant "curlopt_krblevel"
+have_constant "curlopt_ssh_auth_types"
+have_constant "curlopt_ssh_host_public_key_md5"
+have_constant "curlopt_ssh_public_keyfile"
+have_constant "curlopt_ssh_private_keyfile"
+have_constant "curlopt_ssh_knownhosts"
+have_constant "curlopt_ssh_keyfunction"
+have_constant "curlkhstat_fine_add_to_file"
+have_constant "curlkhstat_fine"
+have_constant "curlkhstat_reject"
+have_constant "curlkhstat_defer"
+have_constant "curlopt_ssh_keydata"
+have_constant "curlopt_private"
+have_constant "curlopt_share"
+have_constant "curlopt_new_file_perms"
+have_constant "curlopt_new_directory_perms"
+have_constant "curlopt_telnetoptions"
+# was obsoleted in August 2007 for 7.17.0, reused in April 2011 for 7.21.5
+have_constant "curle_not_built_in"
+
 if try_compile('int main() { return 0; }','-Wall')
   $CFLAGS << ' -Wall'
 end

data/lib/curb.rb

@@ -1,308 +1,3 @@
 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)
-        
-        output = if filename.is_a? IO
-          filename.binmode if filename.respond_to?(:binmode)
-          filename
-        else
-          File.open(filename, 'wb')
-        end
-        
-        begin
-          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
-        ensure
-          output.close rescue IOError
-        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) if blk }
-      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
-
-        # maintain a sane number of easy handles
-        multi_options[:max_connects] = max_connects = multi_options.key?(:max_connects) ? multi_options[:max_connects] : 10
-
-        free_handles = [] # keep a list of free easy handles
-
-        # configure the multi handle
-        multi_options.each { |k,v| m.send("#{k}=", v) }
-        callbacks = [:on_progress,:on_debug,:on_failure,:on_success,:on_body,:on_header]
-
-        add_free_handle = proc do|conf, easy|
-          c       = conf.dup # avoid being destructive to input
-          url     = c.delete(:url)
-          method  = c.delete(:method)
-          headers = c.delete(:headers)
-
-          easy    = Curl::Easy.new if easy.nil?
-
-          easy.url = url
-
-          # assign callbacks
-          callbacks.each do |cb|
-            cbproc = c.delete(cb)
-            easy.send(cb,&cbproc) if cbproc
-          end
-
-          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|
-            free_handles << curl
-            blk.call(curl,code,method) if blk
-          }
-          m.add(easy)
-        end
-
-        max_connects.times do
-          conf = urls_with_config.pop
-          add_free_handle.call conf, nil
-          break if urls_with_config.empty?
-        end
-
-        consume_free_handles = proc do
-          # as we idle consume free handles
-          if urls_with_config.size > 0 && free_handles.size > 0
-            easy = free_handles.pop
-            conf = urls_with_config.pop
-            add_free_handle.call conf, easy
-          end
-        end
-
-        until urls_with_config.empty?
-          m.perform do
-            consume_free_handles.call
-          end
-          consume_free_handles.call
-        end
-        free_handles = nil 
-      end
-
-      # call-seq:
-      #
-      # Curl::Multi.download(['http://example.com/p/a/t/h/file1.txt','http://example.com/p/a/t/h/file2.txt']){|c|}
-      #
-      # will create 2 new files file1.txt and file2.txt
-      # 
-      # 2 files will be opened, and remain open until the call completes
-      #
-      # when using the :post or :put method, urls should be a hash, including the individual post fields per post
-      #
-      def download(urls,easy_options={},multi_options={},download_paths=nil,&blk)
-        errors = []
-        procs = []
-        files = []
-        urls_with_config = []
-        url_to_download_paths = {}
-
-        urls.each_with_index do|urlcfg,i|
-          if urlcfg.is_a?(Hash)
-            url = url[:url]
-          else
-            url = urlcfg
-          end
-
-          if download_paths and download_paths[i]
-            download_path = download_paths[i]
-          else
-            download_path = File.basename(url)
-          end
-
-          file = lambda do|dp|
-            file = File.open(dp,"wb")
-            procs << (lambda {|data| file.write data; data.size })
-            files << file
-            file
-          end.call(download_path)
-
-          if urlcfg.is_a?(Hash)
-            urls_with_config << urlcfg.merge({:on_body => procs.last}.merge(easy_options))
-          else
-            urls_with_config << {:url => url, :on_body => procs.last, :method => :get}.merge(easy_options)
-          end
-          url_to_download_paths[url] = {:path => download_path, :file => file} # store for later
-        end
-
-        if blk
-          # when injecting the block, ensure file is closed before yielding
-          Curl::Multi.http(urls_with_config, multi_options) do |c,code,method|
-            info = url_to_download_paths[c.url]
-            begin
-              file = info[:file]
-              files.reject!{|f| f == file }
-              file.close
-            rescue => e
-              errors << e
-            end
-            blk.call(c,info[:path])
-          end
-        else
-          Curl::Multi.http(urls_with_config, multi_options)
-        end
-
-      ensure
-        files.each {|f|
-          begin
-            f.close
-          rescue => e
-            errors << e
-          end
-        }
-        raise errors unless errors.empty?
-      end
-
-    end
-  end
-end
+require 'curl/easy'
+require 'curl/multi'