curb 0.9.1 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d044ba4672e19b7fadd0097e309db4675b53c785
-  data.tar.gz: 3b0ebdde6d818e9103dd665d1f1b33c042514f5b
+  metadata.gz: c2d299f9e0dce739a74ea53589cc402c4dc2ae2b
+  data.tar.gz: efd8d73f02b9da758c3861a93489e78bb770e4af
 SHA512:
-  metadata.gz: a2daeabcdd2999b3ef7372c37baab4bebd0e56be7213ee82f8734f00bf798bde82de3888e02502f03e67d17bfb38f0fe49c306450eb83169287fa073ffb6b8b7
-  data.tar.gz: 9ef11cfaa3007ebf26247d97f1ab3f59b403ce769a30bff0c3e4be336c52fe05a5f74b19a083eb79b5660f5e3fd30c41c9a68bdd1c831a0c0223cd2a1deb62b3
+  metadata.gz: 364eed3e88338d6c1c7fc8028181b82e945d8d605d171d470d319a434ad7198a2900fe600e4870ac2acc680a35df4e4506471d923cee020d707888168920276d
+  data.tar.gz: ad15467a00c66ee255ed5a605ed48426400a12901e673181c873cf56c7e793534b4b17304cd75b02fd7c15d8e51e2b7a6f1bd24e5dc36c3ffc35096ef6c1b030

data/README.markdown

@@ -1,4 +1,4 @@
-# Curb - Libcurl bindings for Ruby
+# Curb - Libcurl bindings for Ruby [![Build Status](https://travis-ci.org/taf2/curb.svg?branch=master)](https://travis-ci.org/taf2/curb)
 
 * [rubydoc rdoc](http://www.rubydoc.info/github/taf2/curb/)
 * [github project](http://github.com/taf2/curb/tree/master)
@@ -172,14 +172,25 @@ c.multipart_form_post = true
 c.http_post(Curl::PostField.file('thing[file]', 'myfile.rb'))
 ```
 
+### Using HTTP/2
+
+```ruby
+c = Curl::Easy.new("https://http2.akamai.com")
+c.set(:HTTP_VERSION, Curl::HTTP_2_0)
+
+c.perform
+puts (c.body_str.include? "You are using HTTP/2 right now!") ? "HTTP/2" : "HTTP/1.x"
+```
+
 ### Multi Interface (Basic HTTP GET):
 
 ```ruby
 # make multiple GET requests
 easy_options = {:follow_location => true}
-multi_options = {:pipeline => true}
+# Use Curl::CURLPIPE_MULTIPLEX for HTTP/2 multiplexing
+multi_options = {:pipeline => Curl::CURLPIPE_HTTP1} 
 
-Curl::Multi.get('url1','url2','url3','url4','url5', easy_options, multi_options) do|easy|
+Curl::Multi.get(['url1','url2','url3','url4','url5'], easy_options, multi_options) do|easy|
   # do something interesting with the easy response
   puts easy.last_effective_url
 end
@@ -190,7 +201,8 @@ end
 ```ruby
 # make multiple POST requests
 easy_options = {:follow_location => true, :multipart_form_post => true}
-multi_options = {:pipeline => true}
+multi_options = {:pipeline => Curl::CURLPIPE_HTTP1}
+
 
 url_fields = [
   { :url => 'url1', :post_fields => {'f1' => 'v1'} },

data/Rakefile

@@ -69,7 +69,7 @@ desc "Compile the shared object"
 task :compile => [CURB_SO]
 
 desc "Install to your site_ruby directory"
-task :install => :alltests do
+task :install do
   m = make 'install' 
   fail "Make install failed (status #{m})" unless m == 0
 end

data/ext/curb.c

@@ -258,122 +258,128 @@ void Init_curb_core() {
   rb_define_const(mCurl, "CURL_LONG_VERSION", curllongver);
 
   /* Passed to on_debug handler to indicate that the data is informational text. */
-  rb_define_const(mCurl, "CURLINFO_TEXT", INT2FIX(CURLINFO_TEXT));
+  rb_define_const(mCurl, "CURLINFO_TEXT", LONG2NUM(CURLINFO_TEXT));
 
   /* Passed to on_debug handler to indicate that the data is header (or header-like) data received from the peer. */
-  rb_define_const(mCurl, "CURLINFO_HEADER_IN", INT2FIX(CURLINFO_HEADER_IN));
+  rb_define_const(mCurl, "CURLINFO_HEADER_IN", LONG2NUM(CURLINFO_HEADER_IN));
 
   /* Passed to on_debug handler to indicate that the data is header (or header-like) data sent to the peer. */
-  rb_define_const(mCurl, "CURLINFO_HEADER_OUT", INT2FIX(CURLINFO_HEADER_OUT));
+  rb_define_const(mCurl, "CURLINFO_HEADER_OUT", LONG2NUM(CURLINFO_HEADER_OUT));
 
   /* Passed to on_debug handler to indicate that the data is protocol data received from the peer. */
-  rb_define_const(mCurl, "CURLINFO_DATA_IN", INT2FIX(CURLINFO_DATA_IN));
+  rb_define_const(mCurl, "CURLINFO_DATA_IN", LONG2NUM(CURLINFO_DATA_IN));
 
   /* Passed to on_debug handler to indicate that the data is protocol data sent to the peer. */
-  rb_define_const(mCurl, "CURLINFO_DATA_OUT", INT2FIX(CURLINFO_DATA_OUT));
+  rb_define_const(mCurl, "CURLINFO_DATA_OUT", LONG2NUM(CURLINFO_DATA_OUT));
 
 #ifdef HAVE_CURLFTPMETHOD_MULTICWD 
-  rb_define_const(mCurl, "CURL_MULTICWD",  INT2FIX(CURLFTPMETHOD_MULTICWD));
+  rb_define_const(mCurl, "CURL_MULTICWD",  LONG2NUM(CURLFTPMETHOD_MULTICWD));
 #endif
 
 #ifdef HAVE_CURLFTPMETHOD_NOCWD 
-  rb_define_const(mCurl, "CURL_NOCWD",     INT2FIX(CURLFTPMETHOD_NOCWD));
+  rb_define_const(mCurl, "CURL_NOCWD",     LONG2NUM(CURLFTPMETHOD_NOCWD));
 #endif
 
 #ifdef HAVE_CURLFTPMETHOD_SINGLECWD 
-  rb_define_const(mCurl, "CURL_SINGLECWD", INT2FIX(CURLFTPMETHOD_SINGLECWD));
+  rb_define_const(mCurl, "CURL_SINGLECWD", LONG2NUM(CURLFTPMETHOD_SINGLECWD));
 #endif
 
   /* When passed to Curl::Easy#proxy_type , indicates that the proxy is an HTTP proxy. (libcurl >= 7.10) */
 #ifdef HAVE_CURLPROXY_HTTP
-  rb_define_const(mCurl, "CURLPROXY_HTTP", INT2FIX(CURLPROXY_HTTP));
+  rb_define_const(mCurl, "CURLPROXY_HTTP", LONG2NUM(CURLPROXY_HTTP));
 #else
-  rb_define_const(mCurl, "CURLPROXY_HTTP", INT2FIX(-1));
+  rb_define_const(mCurl, "CURLPROXY_HTTP", LONG2NUM(-1));
 #endif
 
 #ifdef CURL_VERSION_SSL
-  rb_define_const(mCurl, "CURL_SSLVERSION_DEFAULT", INT2FIX(CURL_SSLVERSION_DEFAULT));
-  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1",   INT2FIX(CURL_SSLVERSION_TLSv1));
-  rb_define_const(mCurl, "CURL_SSLVERSION_SSLv2",   INT2FIX(CURL_SSLVERSION_SSLv2));
-  rb_define_const(mCurl, "CURL_SSLVERSION_SSLv3",   INT2FIX(CURL_SSLVERSION_SSLv3));
-
-  rb_define_const(mCurl, "CURL_USESSL_CONTROL", INT2FIX(CURB_FTPSSL_CONTROL));
-  rb_define_const(mCurl, "CURL_USESSL_NONE", INT2FIX(CURB_FTPSSL_NONE));
-  rb_define_const(mCurl, "CURL_USESSL_TRY", INT2FIX(CURB_FTPSSL_TRY));
-  rb_define_const(mCurl, "CURL_USESSL_ALL", INT2FIX(CURB_FTPSSL_ALL));
+  rb_define_const(mCurl, "CURL_SSLVERSION_DEFAULT", LONG2NUM(CURL_SSLVERSION_DEFAULT));
+  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1",   LONG2NUM(CURL_SSLVERSION_TLSv1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_SSLv2",   LONG2NUM(CURL_SSLVERSION_SSLv2));
+  rb_define_const(mCurl, "CURL_SSLVERSION_SSLv3",   LONG2NUM(CURL_SSLVERSION_SSLv3));
+  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_0",   LONG2NUM(CURL_SSLVERSION_TLSv1_0));
+  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_1",   LONG2NUM(CURL_SSLVERSION_TLSv1_1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_2",   LONG2NUM(CURL_SSLVERSION_TLSv1_2));
+
+  rb_define_const(mCurl, "CURL_USESSL_CONTROL", LONG2NUM(CURB_FTPSSL_CONTROL));
+  rb_define_const(mCurl, "CURL_USESSL_NONE", LONG2NUM(CURB_FTPSSL_NONE));
+  rb_define_const(mCurl, "CURL_USESSL_TRY", LONG2NUM(CURB_FTPSSL_TRY));
+  rb_define_const(mCurl, "CURL_USESSL_ALL", LONG2NUM(CURB_FTPSSL_ALL));
 #else
-  rb_define_const(mCurl, "CURL_SSLVERSION_DEFAULT", INT2FIX(-1));
-  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1",   INT2FIX(-1));
-  rb_define_const(mCurl, "CURL_SSLVERSION_SSLv2",   INT2FIX(-1));
-  rb_define_const(mCurl, "CURL_SSLVERSION_SSLv3",   INT2FIX(-1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_DEFAULT", LONG2NUM(-1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1",   LONG2NUM(-1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_SSLv2",   LONG2NUM(-1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_SSLv3",   LONG2NUM(-1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_0", LONG2NUM(-1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_1", LONG2NUM(-1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_2", LONG2NUM(-1));
 
-  rb_define_const(mCurl, "CURL_USESSL_CONTROL", INT2FIX(-1));
-  rb_define_const(mCurl, "CURL_USESSL_NONE", INT2FIX(-1));
-  rb_define_const(mCurl, "CURL_USESSL_TRY", INT2FIX(-1));
-  rb_define_const(mCurl, "CURL_USESSL_ALL", INT2FIX(-1));
+  rb_define_const(mCurl, "CURL_USESSL_CONTROL", LONG2NUM(-1));
+  rb_define_const(mCurl, "CURL_USESSL_NONE", LONG2NUM(-1));
+  rb_define_const(mCurl, "CURL_USESSL_TRY", LONG2NUM(-1));
+  rb_define_const(mCurl, "CURL_USESSL_ALL", LONG2NUM(-1));
 #endif
 
   /* When passed to Curl::Easy#proxy_type , indicates that the proxy is a SOCKS4 proxy. (libcurl >= 7.15.2) */
 #ifdef HAVE_CURLPROXY_SOCKS4
-  rb_define_const(mCurl, "CURLPROXY_SOCKS4", INT2FIX(CURLPROXY_SOCKS4));
+  rb_define_const(mCurl, "CURLPROXY_SOCKS4", LONG2NUM(CURLPROXY_SOCKS4));
 #else
-  rb_define_const(mCurl, "CURLPROXY_SOCKS4", INT2FIX(-2));
+  rb_define_const(mCurl, "CURLPROXY_SOCKS4", LONG2NUM(-2));
 #endif
 
   /* When passed to Curl::Easy#proxy_type , indicates that the proxy is a SOCKS4A proxy. (libcurl >= 7.18.0) */
 #ifdef HAVE_CURLPROXY_SOCKS4A
-  rb_define_const(mCurl, "CURLPROXY_SOCKS4A", INT2FIX(CURLPROXY_SOCKS4A));
+  rb_define_const(mCurl, "CURLPROXY_SOCKS4A", LONG2NUM(CURLPROXY_SOCKS4A));
 #else
-  rb_define_const(mCurl, "CURLPROXY_SOCKS4A", INT2FIX(-2));
+  rb_define_const(mCurl, "CURLPROXY_SOCKS4A", LONG2NUM(-2));
 #endif
 
   /* When passed to Curl::Easy#proxy_type , indicates that the proxy is a SOCKS5 proxy. (libcurl >= 7.10) */
 #ifdef HAVE_CURLPROXY_SOCKS5
-  rb_define_const(mCurl, "CURLPROXY_SOCKS5", INT2FIX(CURLPROXY_SOCKS5));
+  rb_define_const(mCurl, "CURLPROXY_SOCKS5", LONG2NUM(CURLPROXY_SOCKS5));
 #else
-  rb_define_const(mCurl, "CURLPROXY_SOCKS5", INT2FIX(-2));
+  rb_define_const(mCurl, "CURLPROXY_SOCKS5", LONG2NUM(-2));
 #endif
 
   /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, directs libcurl to use Basic authentication. */
 #ifdef HAVE_CURLAUTH_BASIC
-  rb_define_const(mCurl, "CURLAUTH_BASIC", INT2FIX(CURLAUTH_BASIC));
+  rb_define_const(mCurl, "CURLAUTH_BASIC", LONG2NUM(CURLAUTH_BASIC));
 #else
-  rb_define_const(mCurl, "CURLAUTH_BASIC", INT2FIX(0));
+  rb_define_const(mCurl, "CURLAUTH_BASIC", LONG2NUM(0));
 #endif
 
   /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, directs libcurl to use Digest authentication. */
 #ifdef HAVE_CURLAUTH_DIGEST
-  rb_define_const(mCurl, "CURLAUTH_DIGEST", INT2FIX(CURLAUTH_DIGEST));
+  rb_define_const(mCurl, "CURLAUTH_DIGEST", LONG2NUM(CURLAUTH_DIGEST));
 #else
-  rb_define_const(mCurl, "CURLAUTH_DIGEST", INT2FIX(0));
+  rb_define_const(mCurl, "CURLAUTH_DIGEST", LONG2NUM(0));
 #endif
 
   /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, directs libcurl to use GSS Negotiate authentication. Requires a suitable GSS-API library. */
 #ifdef HAVE_CURLAUTH_GSSNEGOTIATE
-  rb_define_const(mCurl, "CURLAUTH_GSSNEGOTIATE", INT2FIX(CURLAUTH_GSSNEGOTIATE));
+  rb_define_const(mCurl, "CURLAUTH_GSSNEGOTIATE", LONG2NUM(CURLAUTH_GSSNEGOTIATE));
 #else
-  rb_define_const(mCurl, "CURLAUTH_GSSNEGOTIATE", INT2FIX(0));
+  rb_define_const(mCurl, "CURLAUTH_GSSNEGOTIATE", LONG2NUM(0));
 #endif
 
   /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, directs libcurl to use HTTP NTLM authentication. Requires MS Windows or OpenSSL support. */
 #ifdef HAVE_CURLAUTH_NTLM
-  rb_define_const(mCurl, "CURLAUTH_NTLM", INT2FIX(CURLAUTH_NTLM));
+  rb_define_const(mCurl, "CURLAUTH_NTLM", LONG2NUM(CURLAUTH_NTLM));
 #else
-  rb_define_const(mCurl, "CURLAUTH_NTLM", INT2FIX(0));
+  rb_define_const(mCurl, "CURLAUTH_NTLM", LONG2NUM(0));
 #endif
 
   /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, allows libcurl to select any suitable authentication method except basic. */
 #ifdef HAVE_CURLAUTH_ANYSAFE
-  rb_define_const(mCurl, "CURLAUTH_ANYSAFE", INT2FIX(CURLAUTH_ANYSAFE));
+  rb_define_const(mCurl, "CURLAUTH_ANYSAFE", LONG2NUM(CURLAUTH_ANYSAFE));
 #else
-  rb_define_const(mCurl, "CURLAUTH_ANYSAFE", INT2FIX(0));
+  rb_define_const(mCurl, "CURLAUTH_ANYSAFE", LONG2NUM(0));
 #endif
 
   /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, allows libcurl to select any suitable authentication method. */
 #ifdef HAVE_CURLAUTH_ANY
-  rb_define_const(mCurl, "CURLAUTH_ANY", INT2FIX(CURLAUTH_ANY));
+  rb_define_const(mCurl, "CURLAUTH_ANY", LONG2NUM(CURLAUTH_ANY));
 #else
-  rb_define_const(mCurl, "CURLAUTH_ANY", INT2FIX(0));
+  rb_define_const(mCurl, "CURLAUTH_ANY", LONG2NUM(0));
 #endif
 
   CURB_DEFINE(CURLOPT_VERBOSE);
@@ -585,6 +591,9 @@ void Init_curb_core() {
     CURB_DEFINE(CURL_HTTP_VERSION_NONE);
     CURB_DEFINE(CURL_HTTP_VERSION_1_0);
     CURB_DEFINE(CURL_HTTP_VERSION_1_1);
+#if LIBCURL_VERSION_NUM >= 0x072100 /* 7.33.0 */
+    CURB_DEFINE(CURL_HTTP_VERSION_2_0);
+#endif
 #if HAVE_CURLOPT_IGNORE_CONTENT_LENGTH
   CURB_DEFINE(CURLOPT_IGNORE_CONTENT_LENGTH);
 #endif
@@ -886,6 +895,15 @@ void Init_curb_core() {
 #if HAVE_CURL_SSLVERSION_SSLv3
   CURB_DEFINE(CURL_SSLVERSION_SSLv3);
 #endif
+#if HAVE_CURL_SSLVERSION_TLSv1_0
+  CURB_DEFINE(CURL_SSLVERSION_TLSv1_0);
+#endif
+#if HAVE_CURL_SSLVERSION_TLSv1_1
+  CURB_DEFINE(CURL_SSLVERSION_TLSv1_1);
+#endif
+#if HAVE_CURL_SSLVERSION_TLSv1_2
+  CURB_DEFINE(CURL_SSLVERSION_TLSv1_2);
+#endif
 #if HAVE_CURLOPT_SSL_VERIFYPEER
   CURB_DEFINE(CURLOPT_SSL_VERIFYPEER);
 #endif
@@ -990,6 +1008,16 @@ void Init_curb_core() {
   CURB_DEFINE(CURLOPT_UNIX_SOCKET_PATH);
 #endif
 
+#if LIBCURL_VERSION_NUM >= 0x072B00 /* 7.43.0 */
+  CURB_DEFINE(CURLPIPE_NOTHING);
+  CURB_DEFINE(CURLPIPE_HTTP1);
+  CURB_DEFINE(CURLPIPE_MULTIPLEX);
+
+  rb_define_const(mCurl, "PIPE_NOTHING", LONG2NUM(CURLPIPE_NOTHING));
+  rb_define_const(mCurl, "PIPE_HTTP1", LONG2NUM(CURLPIPE_HTTP1));
+  rb_define_const(mCurl, "PIPE_MULTIPLEX", LONG2NUM(CURLPIPE_MULTIPLEX));
+#endif
+
 #if LIBCURL_VERSION_NUM >= 0x072100 /* 7.33.0 */
   rb_define_const(mCurl, "HTTP_2_0", LONG2NUM(CURL_HTTP_VERSION_2_0));
 #endif
@@ -997,6 +1025,8 @@ void Init_curb_core() {
   rb_define_const(mCurl, "HTTP_1_0", LONG2NUM(CURL_HTTP_VERSION_1_0));
   rb_define_const(mCurl, "HTTP_NONE", LONG2NUM(CURL_HTTP_VERSION_NONE));
 
+
+
   rb_define_singleton_method(mCurl, "ipv6?", ruby_curl_ipv6_q, 0);
   rb_define_singleton_method(mCurl, "kerberos4?", ruby_curl_kerberos4_q, 0);
   rb_define_singleton_method(mCurl, "ssl?", ruby_curl_ssl_q, 0);

data/ext/curb.h

@@ -20,10 +20,10 @@
 #include "curb_macros.h"
 
 // These should be managed from the Rake 'release' task.
-#define CURB_VERSION   "0.9.1"
-#define CURB_VER_NUM   901
+#define CURB_VERSION   "0.9.2"
+#define CURB_VER_NUM   902
 #define CURB_VER_MAJ   0
-#define CURB_VER_MIN   1
+#define CURB_VER_MIN   2
 #define CURB_VER_MIC   0
 #define CURB_VER_PATCH 0
 

data/ext/curb_easy.c

@@ -192,7 +192,7 @@ static int proc_progress_handler(VALUE proc,
 
 static VALUE call_debug_handler(VALUE ary) {
   return rb_funcall(rb_ary_entry(ary, 0), idCall, 2,
-                    rb_ary_entry(ary, 1), // INT2FIX(type),
+                    rb_ary_entry(ary, 1), // INT2NUM(type),
                     rb_ary_entry(ary, 2)); // rb_str_new(data, data_len)
 }
 static int proc_debug_handler(CURL *curl,
@@ -202,13 +202,13 @@ static int proc_debug_handler(CURL *curl,
                               VALUE proc) {
   VALUE callargs = rb_ary_new2(3);
   rb_ary_store(callargs, 0, proc);
-  rb_ary_store(callargs, 1, INT2FIX(type));
+  rb_ary_store(callargs, 1, INT2NUM(type));
   rb_ary_store(callargs, 2, rb_str_new(data, data_len));
   rb_rescue(call_debug_handler, callargs, callback_exception, Qnil);
   /* no way to indicate to libcurl that we should break out given an exception in the on_debug handler...
    * this means exceptions will be swallowed
    */
-  //rb_funcall(proc, idCall, 2, INT2FIX(type), rb_str_new(data, data_len));
+  //rb_funcall(proc, idCall, 2, INT2NUM(type), rb_str_new(data, data_len));
   return 0;
 }
 
@@ -827,14 +827,14 @@ static VALUE ruby_curl_easy_put_data_set(VALUE self, VALUE data) {
         rb_hash_aset(headers, rb_str_new2("Expect"), rb_str_new2(""));
       }
       size = rb_funcall(stat, rb_intern("size"), 0);
-      curl_easy_setopt(curl, CURLOPT_INFILESIZE, FIX2LONG(size));
+      curl_easy_setopt(curl, CURLOPT_INFILESIZE, NUM2LONG(size));
     }
     else if( rb_hash_aref(headers, rb_str_new2("Content-Length")) == Qnil && rb_hash_aref(headers, rb_str_new2("Transfer-Encoding")) == Qnil ) {
       rb_hash_aset(headers, rb_str_new2("Transfer-Encoding"), rb_str_new2("chunked"));
     }
     else if( rb_hash_aref(headers, rb_str_new2("Content-Length")) ) {
       VALUE size = rb_funcall(rb_hash_aref(headers, rb_str_new2("Content-Length")), rb_intern("to_i"), 0);
-      curl_easy_setopt(curl, CURLOPT_INFILESIZE, FIX2LONG(size));
+      curl_easy_setopt(curl, CURLOPT_INFILESIZE, NUM2LONG(size));
     }
   }
   else if (rb_respond_to(data, rb_intern("to_s"))) {
@@ -978,16 +978,16 @@ static VALUE ruby_curl_easy_proxy_type_get(VALUE self) {
   (!strncmp("digest",node,6)) ? CURLAUTH_DIGEST : \
   (!strncmp("gssnegotiate",node,12)) ? CURLAUTH_GSSNEGOTIATE : \
   (!strncmp("ntlm",node,4)) ? CURLAUTH_NTLM : \
-  (!strncmp("any",node,3)) ? CURLAUTH_ANY : \
-  (!strncmp("anysafe",node,7)) ? CURLAUTH_ANYSAFE : 0
+  (!strncmp("anysafe",node,7)) ? CURLAUTH_ANYSAFE : \
+  (!strncmp("any",node,3)) ? CURLAUTH_ANY : 0
 #else 
 #define CURL_HTTPAUTH_STR_TO_NUM(node) \
   (!strncmp("basic",node,5)) ? CURLAUTH_BASIC : \
   (!strncmp("digest",node,6)) ? CURLAUTH_DIGEST : \
   (!strncmp("gssnegotiate",node,12)) ? CURLAUTH_GSSNEGOTIATE : \
   (!strncmp("ntlm",node,4)) ? CURLAUTH_NTLM : \
-  (!strncmp("any",node,3)) ? CURLAUTH_ANY : \
-  (!strncmp("anysafe",node,7)) ? CURLAUTH_ANYSAFE : 0
+  (!strncmp("anysafe",node,7)) ? CURLAUTH_ANYSAFE : \
+  (!strncmp("any",node,3)) ? CURLAUTH_ANY : 0
 #endif
 /*
  * call-seq:
@@ -1001,21 +1001,22 @@ static VALUE ruby_curl_easy_proxy_type_get(VALUE self) {
 static VALUE ruby_curl_easy_http_auth_types_set(int argc, VALUE *argv, VALUE self) {//VALUE self, VALUE http_auth_types) {
   ruby_curl_easy *rbce;
   VALUE args_ary;
-  int i, len;
+  long i, len;
   char* node = NULL;
-  long mask = 0x000000;
+  long mask = 0;
 
   rb_scan_args(argc, argv, "*", &args_ary);
   Data_Get_Struct(self, ruby_curl_easy, rbce);
 
-  len = (int)RARRAY_LEN(args_ary);
+  len = RARRAY_LEN(args_ary);
 
-  if (len == 1 && (TYPE(rb_ary_entry(args_ary,0)) == T_FIXNUM || rb_ary_entry(args_ary,0) == Qnil)) {
+  if (len == 1 && (rb_ary_entry(args_ary,0) == Qnil || TYPE(rb_ary_entry(args_ary,0)) == T_FIXNUM ||
+        TYPE(rb_ary_entry(args_ary,0)) == T_BIGNUM)) {
     if (rb_ary_entry(args_ary,0) == Qnil) { 
       rbce->http_auth_types = 0;
     }
     else {
-      rbce->http_auth_types = NUM2INT(rb_ary_entry(args_ary,0));
+      rbce->http_auth_types = NUM2LONG(rb_ary_entry(args_ary,0));
     }
   }
   else {
@@ -1028,7 +1029,7 @@ static VALUE ruby_curl_easy_http_auth_types_set(int argc, VALUE *argv, VALUE sel
     }
     rbce->http_auth_types = mask;
   }
-  return INT2NUM(rbce->http_auth_types);
+  return LONG2NUM(rbce->http_auth_types);
 }
 
 /*
@@ -1353,8 +1354,15 @@ static VALUE ruby_curl_easy_password_get(VALUE self, VALUE password) {
  *   easy.ssl_version = value                         => fixnum or nil
  *
  * Sets the version of SSL/TLS that libcurl will attempt to use. Valid
- * options are Curl::CURL_SSLVERSION_TLSv1, Curl::CURL_SSLVERSION::SSLv2,
- * Curl::CURL_SSLVERSION_SSLv3 and Curl::CURL_SSLVERSION_DEFAULT
+ * options are:
+ *
+ *   Curl::CURL_SSLVERSION_DEFAULT
+ *   Curl::CURL_SSLVERSION_TLSv1 (TLS 1.x)
+ *   Curl::CURL_SSLVERSION_SSLv2
+ *   Curl::CURL_SSLVERSION_SSLv3
+ *   Curl::CURL_SSLVERSION_TLSv1_0
+ *   Curl::CURL_SSLVERSION_TLSv1_1
+ *   Curl::CURL_SSLVERSION_TLSv1_2
  */
 static VALUE ruby_curl_easy_ssl_version_set(VALUE self, VALUE ssl_version) {
   CURB_IMMED_SETTER(ruby_curl_easy, ssl_version, -1);
@@ -2168,7 +2176,7 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
   /*
    * NOTE: we used to set CURLAUTH_ANY but see: http://curl.haxx.se/mail/lib-2015-06/0033.html
    */
-  if (rbce->http_auth_types > 0) {
+  if (rbce->http_auth_types != 0) {
 #if LIBCURL_VERSION_NUM >= 0x070a06
     curl_easy_setopt(curl, CURLOPT_HTTPAUTH, rbce->http_auth_types);
 #else
@@ -2176,7 +2184,7 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
 #endif
   }
 
-  if (rbce->proxy_auth_types > 0) {
+  if (rbce->proxy_auth_types != 0) {
 #if LIBCURL_VERSION_NUM >= 0x070a07
     curl_easy_setopt(curl, CURLOPT_PROXYAUTH, rbce->proxy_auth_types);
 #else
@@ -2403,7 +2411,7 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
         append_to_form(argv[i], &first, &last);
       } else if (rb_type(argv[i]) == T_ARRAY) {
         // see: https://github.com/rvanlieshout/curb/commit/8bcdefddc0162484681ebd1a92d52a642666a445
-        int c = 0, argv_len = (int)RARRAY_LEN(argv[i]);
+        long c = 0, argv_len = RARRAY_LEN(argv[i]);
         for (; c < argv_len; ++c) {
           if (rb_obj_is_instance_of(rb_ary_entry(argv[i],c), cCurlPostField)) {
             append_to_form(rb_ary_entry(argv[i],c), &first, &last);
@@ -2612,7 +2620,7 @@ static VALUE ruby_curl_easy_file_time_get(VALUE self) {
   return LONG2NUM(time);
 #else
   rb_warn("Installed libcurl is too old to support file_time");
-  return INT2FIX(0);
+  return LONG2NUM(0);
 #endif
 }
 
@@ -2772,7 +2780,7 @@ static VALUE ruby_curl_easy_redirect_count_get(VALUE self) {
   return LONG2NUM(count);
 #else
   rb_warn("Installed libcurl is too old to support redirect_count");
-  return INT2FIX(-1);
+  return LONG2NUM(-1);
 #endif
 
 }
@@ -2801,7 +2809,7 @@ static VALUE ruby_curl_easy_redirect_url_get(VALUE self) {
   }
 #else
   rb_warn("Installed libcurl is too old to support redirect_url");
-  return INT2FIX(-1);
+  return LONG2NUM(-1);
 #endif
 }
 
@@ -3030,7 +3038,7 @@ static VALUE ruby_curl_easy_os_errno_get(VALUE self) {
   return LONG2NUM(result);
 #else
   rb_warn("Installed libcurl is too old to support os_errno");
-  return INT2FIX(0);
+  return LONG2NUM(0);
 #endif
 }
 
@@ -3059,7 +3067,7 @@ static VALUE ruby_curl_easy_num_connects_get(VALUE self) {
   return LONG2NUM(result);
 #else
   rb_warn("Installed libcurl is too old to support num_connects");
-  return INT2FIX(-1);
+  return LONG2NUM(-1);
 #endif
 }
 
@@ -3136,7 +3144,7 @@ static VALUE ruby_curl_easy_multi_set(VALUE self, VALUE multi) {
 static VALUE ruby_curl_easy_last_result(VALUE self) {
   ruby_curl_easy *rbce;
   Data_Get_Struct(self, ruby_curl_easy, rbce);
-  return INT2FIX(rbce->last_result);
+  return LONG2NUM(rbce->last_result);
 }
 
 /*
@@ -3147,7 +3155,7 @@ static VALUE ruby_curl_easy_last_result(VALUE self) {
  */
 static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
   ruby_curl_easy *rbce;
-  long option = FIX2LONG(opt);
+  long option = NUM2LONG(opt);
 
   Data_Get_Struct(self, ruby_curl_easy, rbce);
 
@@ -3172,7 +3180,7 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
     curl_easy_setopt(rbce->curl, CURLOPT_CUSTOMREQUEST, NIL_P(val) ? NULL : StringValueCStr(val));
     break;
   case CURLOPT_HTTP_VERSION:
-    curl_easy_setopt(rbce->curl, CURLOPT_HTTP_VERSION, FIX2INT(val));
+    curl_easy_setopt(rbce->curl, CURLOPT_HTTP_VERSION, NUM2LONG(val));
     break;
   case CURLOPT_PROXY: {
     VALUE proxy_url = val;
@@ -3196,11 +3204,14 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
     } else {
       value = rb_funcall(val, rb_intern("to_i"), 0);
     }
-    curl_easy_setopt(rbce->curl, option, FIX2INT(value));
+    curl_easy_setopt(rbce->curl, option, NUM2LONG(value));
     } break;
   case CURLOPT_POST: {
     curl_easy_setopt(rbce->curl, CURLOPT_POST, rb_type(val) == T_TRUE);
   } break;
+  case CURLOPT_MAXCONNECTS: {
+    curl_easy_setopt(rbce->curl, CURLOPT_MAXCONNECTS, NUM2LONG(val));
+  } break;
   case CURLOPT_POSTFIELDS: {
     curl_easy_setopt(rbce->curl, CURLOPT_POSTFIELDS, NIL_P(val) ? NULL : StringValueCStr(val));
   } break;
@@ -3225,20 +3236,23 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
     CURB_OBJECT_HSETTER(ruby_curl_easy, cookiejar);
     } break;
   case CURLOPT_TCP_NODELAY: {
-    curl_easy_setopt(rbce->curl, CURLOPT_TCP_NODELAY, FIX2LONG(val));
+    curl_easy_setopt(rbce->curl, CURLOPT_TCP_NODELAY, NUM2LONG(val));
     } break;
   case CURLOPT_RESUME_FROM: {
-    curl_easy_setopt(rbce->curl, CURLOPT_RESUME_FROM, FIX2LONG(val));
+    curl_easy_setopt(rbce->curl, CURLOPT_RESUME_FROM, NUM2LONG(val));
     } break;
   case CURLOPT_FAILONERROR: {
-    curl_easy_setopt(rbce->curl, CURLOPT_FAILONERROR, FIX2LONG(val));
+    curl_easy_setopt(rbce->curl, CURLOPT_FAILONERROR, NUM2LONG(val));
     } break;
   case CURLOPT_SSL_CIPHER_LIST: {
     curl_easy_setopt(rbce->curl, CURLOPT_SSL_CIPHER_LIST, StringValueCStr(val));
     } break;
+  case CURLOPT_FORBID_REUSE: {
+    curl_easy_setopt(rbce->curl, CURLOPT_FORBID_REUSE, NUM2LONG(val));
+    } break;
 #if HAVE_CURLOPT_GSSAPI_DELEGATION
   case CURLOPT_GSSAPI_DELEGATION: {
-    curl_easy_setopt(rbce->curl, CURLOPT_GSSAPI_DELEGATION, FIX2LONG(val));
+    curl_easy_setopt(rbce->curl, CURLOPT_GSSAPI_DELEGATION, NUM2LONG(val));
     } break;
 #endif
 #if HAVE_CURLOPT_UNIX_SOCKET_PATH
@@ -3338,7 +3352,7 @@ static VALUE ruby_curl_easy_unescape(VALUE self, VALUE str) {
 #if (LIBCURL_VERSION_NUM >= 0x070f04)
   result = (char*)curl_easy_unescape(rbce->curl, StringValuePtr(str), (int)RSTRING_LEN(str), &rlen);
 #else
-  result = (char*)curl_unescape(StringValuePtr(str), RSTRING_LEN(str));
+  result = (char*)curl_unescape(StringValuePtr(str), (int)RSTRING_LEN(str));
   rlen = strlen(result);
 #endif
 
@@ -3358,7 +3372,7 @@ static VALUE ruby_curl_easy_unescape(VALUE self, VALUE str) {
  * translate an internal libcurl error to ruby error class
  */
 static VALUE ruby_curl_easy_error_message(VALUE klass, VALUE code) {
-  return rb_curl_easy_error(FIX2INT(code));
+  return rb_curl_easy_error(NUM2INT(code));
 }
 
 /* =================== INIT LIB =====================*/

data/ext/curb_macros.h

@@ -99,7 +99,7 @@
                                                                         \
             return oldproc;
 
-/* setter for numerics that are kept in c ints */
+/* setter for numerics that are kept in c longs */
 #define CURB_IMMED_SETTER(type, attr, nilval)                       \
             type *ptr;                                              \
                                                                     \
@@ -107,12 +107,12 @@
             if (attr == Qnil) {                                     \
               ptr->attr = nilval;                                   \
             } else {                                                \
-              ptr->attr = NUM2INT(attr);                            \
+              ptr->attr = NUM2LONG(attr);                           \
             }                                                       \
                                                                     \
             return attr;                                            \
 
-/* setter for numerics that are kept in c ints */
+/* setter for numerics that are kept in c longs */
 #define CURB_IMMED_GETTER(type, attr, nilval)                       \
             type *ptr;                                              \
                                                                     \
@@ -120,7 +120,7 @@
             if (ptr->attr == nilval) {                              \
               return Qnil;                                          \
             } else {                                                \
-              return INT2NUM(ptr->attr);                            \
+              return LONG2NUM(ptr->attr);                           \
             }
 
 /* special setter for port / port ranges */
@@ -131,7 +131,7 @@
             if (attr == Qnil) {                                     \
               ptr->attr = 0;                                        \
             } else {                                                \
-              int port = FIX2INT(attr);                             \
+              int port = NUM2INT(attr);                             \
                                                                     \
               if ((port) && ((port & 0xFFFF) == port)) {            \
                 ptr->attr = port;                                   \
@@ -150,10 +150,10 @@
             if (ptr->attr == 0) {                                   \
               return Qnil;                                          \
             } else {                                                \
-              return INT2FIX(ptr->attr);                            \
+              return INT2NUM(ptr->attr);                            \
             }
 
 #define CURB_DEFINE(name) \
-  rb_define_const(mCurl, #name, INT2FIX(name))
+  rb_define_const(mCurl, #name, LONG2NUM(name))
 
 #endif

data/ext/curb_multi.c

@@ -47,37 +47,41 @@ static VALUE callback_exception(VALUE unused) {
 } 
 
 static void curl_multi_mark(ruby_curl_multi *rbcm) {
-  rb_gc_mark(rbcm->requests);
+  if (!NIL_P(rbcm->requests)) rb_gc_mark(rbcm->requests);
 }
 
-static void curl_multi_flush_easy(VALUE key, VALUE easy, ruby_curl_multi *rbcm) {
+/* Hash#foreach callback for curl_multi_free */
+static int curl_multi_flush_easy(VALUE key, VALUE easy, ruby_curl_multi *rbcm) {
   CURLMcode result;
   ruby_curl_easy *rbce;
 
-  Data_Get_Struct(easy, ruby_curl_easy, rbce);
-  result = curl_multi_remove_handle(rbcm->handle, rbce->curl);
-  if (result != 0) {
-    raise_curl_multi_error_exception(result);
+  // sometimes the type is T_ZOMBIE, e.g. after Ruby has received the SIGTERM signal
+  if (rb_type(easy) == T_DATA) {
+    Data_Get_Struct(easy, ruby_curl_easy, rbce);
+
+    result = curl_multi_remove_handle(rbcm->handle, rbce->curl);
+    if (result != 0) {
+      raise_curl_multi_error_exception(result);
+    }
   }
-}
 
-static int
-rb_hash_clear_i(VALUE key, VALUE value, VALUE dummy) {
   return ST_DELETE;
 }
 
-static void curl_multi_free(ruby_curl_multi *rbcm) {
+void curl_multi_free(ruby_curl_multi *rbcm) {
   VALUE hash = rbcm->requests;
 
-  if (rbcm && !NIL_P(hash) && rb_type(hash) == T_HASH && RHASH_SIZE(hash) > 0) {
+  if (!NIL_P(hash) && rb_type(hash) == T_HASH && RHASH_SIZE(hash) > 0) {
 
-    rb_hash_foreach(hash, (int (*)())curl_multi_flush_easy, (VALUE)rbcm);
-    rb_hash_foreach(hash, rb_hash_clear_i, 0);
+    rb_hash_foreach(hash, curl_multi_flush_easy, (VALUE)rbcm);
     /* rb_hash_clear(rbcm->requests); */
 
     rbcm->requests = Qnil;
   }
-  curl_multi_cleanup(rbcm->handle);
+
+  if (rbcm->handle) {
+    curl_multi_cleanup(rbcm->handle);
+  }
   free(rbcm);
 }
 
@@ -116,7 +120,7 @@ VALUE ruby_curl_multi_new(VALUE klass) {
  *
  */
 VALUE ruby_curl_multi_set_default_timeout(VALUE klass, VALUE timeout) {
-  cCurlMutiDefaulttimeout = FIX2LONG(timeout);
+  cCurlMutiDefaulttimeout = NUM2LONG(timeout);
   return timeout;
 }
 
@@ -128,7 +132,7 @@ VALUE ruby_curl_multi_set_default_timeout(VALUE klass, VALUE timeout) {
  *
  */
 VALUE ruby_curl_multi_get_default_timeout(VALUE klass) {
-  return INT2FIX(cCurlMutiDefaulttimeout);
+  return LONG2NUM(cCurlMutiDefaulttimeout);
 }
 
 /* Hash#foreach callback for ruby_curl_multi_requests */
@@ -170,7 +174,7 @@ static VALUE ruby_curl_multi_idle(VALUE self) {
   
   Data_Get_Struct(self, ruby_curl_multi, rbcm);
   
-  if ( FIX2INT( rb_funcall(rbcm->requests, rb_intern("length"), 0) ) == 0 ) {
+  if (RHASH_SIZE(rbcm->requests) == 0) {
     return Qtrue;
   } else {
     return Qfalse;
@@ -189,7 +193,15 @@ static VALUE ruby_curl_multi_max_connects(VALUE self, VALUE count) {
   ruby_curl_multi *rbcm;
 
   Data_Get_Struct(self, ruby_curl_multi, rbcm);
-  curl_multi_setopt(rbcm->handle, CURLMOPT_MAXCONNECTS, NUM2INT(count));
+
+  if (!rbcm->handle) {
+    rbcm->handle = curl_multi_init();
+    if (!rbcm->handle) {
+      rb_raise(mCurlErrFailedInit, "Failed to initialize multi handle");
+    }
+  }
+
+  curl_multi_setopt(rbcm->handle, CURLMOPT_MAXCONNECTS, NUM2LONG(count));
 #endif
 
   return count;
@@ -200,20 +212,39 @@ static VALUE ruby_curl_multi_max_connects(VALUE self, VALUE count) {
  * multi = Curl::Multi.new
  * multi.pipeline = true
  *
- * Pass a long set to 1 to enable or 0 to disable. Enabling pipelining on a multi handle will make it
- * attempt to perform HTTP Pipelining as far as possible for transfers using this handle. This means
- * that if you add a second request that can use an already existing connection, the second request will
- * be "piped" on the same connection rather than being executed in parallel. (Added in 7.16.0)
+ * Pass a long set to 1 for HTTP/1.1 pipelining, 2 for HTTP/2 multiplexing, or 0 to disable.
+ *  Enabling pipelining on a multi handle will make it attempt to perform HTTP Pipelining as 
+ * far as possible for transfers using this handle. This means that if you add a second request 
+ * that can use an already existing connection, the second request will be "piped" on the same
+ * connection rather than being executed in parallel. (Added in 7.16.0, multiplex added in 7.43.0)
  *
  */
-static VALUE ruby_curl_multi_pipeline(VALUE self, VALUE onoff) {
+static VALUE ruby_curl_multi_pipeline(VALUE self, VALUE method) {
 #ifdef HAVE_CURLMOPT_PIPELINING
   ruby_curl_multi *rbcm;
 
+  long value;
+
+  if (method == Qtrue) {
+    value = 1;
+  } else if (method == Qfalse) {
+    value  = 0;
+  } else {
+    value = NUM2LONG(method);
+  } 
+
   Data_Get_Struct(self, ruby_curl_multi, rbcm);
-  curl_multi_setopt(rbcm->handle, CURLMOPT_PIPELINING, onoff == Qtrue ? 1 : 0);
+
+  if (!rbcm->handle) {
+    rbcm->handle = curl_multi_init();
+    if (!rbcm->handle) {
+      rb_raise(mCurlErrFailedInit, "Failed to initialize multi handle");
+    }
+  }
+
+  curl_multi_setopt(rbcm->handle, CURLMOPT_PIPELINING, value);
 #endif
-  return onoff;
+  return method == Qtrue ? 1 : 0;
 }
 
 /*
@@ -235,7 +266,7 @@ VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
   Data_Get_Struct(easy, ruby_curl_easy, rbce);
 
   // check if this curl handle has been added before adding again
-  r = rb_hash_aref(rbcm->requests, INT2NUM((int)rbce->curl));
+  r = rb_hash_aref(rbcm->requests, LONG2NUM((long)rbce->curl));
   if ( r != Qnil ) {
     return Qnil;
   }
@@ -243,6 +274,13 @@ VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
   /* setup the easy handle */
   ruby_curl_easy_setup( rbce );
 
+  if (!rbcm->handle) {
+    rbcm->handle = curl_multi_init();
+    if (!rbcm->handle) {
+      rb_raise(mCurlErrFailedInit, "Failed to initialize multi handle");
+    }
+  }
+
   mcode = curl_multi_add_handle(rbcm->handle, rbce->curl);
   if (mcode != CURLM_CALL_MULTI_PERFORM && mcode != CURLM_OK) {
     raise_curl_multi_error_exception(mcode);
@@ -254,7 +292,10 @@ VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
    * If this number is not correct, the next call to curl_multi_perform will correct it. */
   rbcm->running++;
 
-  rb_hash_aset( rbcm->requests, INT2NUM((int)rbce->curl), easy );
+  /* track a reference to associated multi handle */
+  rbce->multi = self;
+
+  rb_hash_aset( rbcm->requests, LONG2NUM((long)rbce->curl), easy );
 
   return self;
 }
@@ -278,6 +319,13 @@ VALUE ruby_curl_multi_remove(VALUE self, VALUE easy) {
 
   Data_Get_Struct(self, ruby_curl_multi, rbcm);
 
+  if (!rbcm->handle) {
+    rbcm->handle = curl_multi_init();
+    if (!rbcm->handle) {
+      rb_raise(mCurlErrFailedInit, "Failed to initialize multi handle");
+    }
+  }
+
   rb_curl_multi_remove(rbcm,easy);
 
   return self;
@@ -290,7 +338,7 @@ static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy) {
   Data_Get_Struct(easy, ruby_curl_easy, rbce);
 
   // check if this curl handle has been added before removing
-  r = rb_hash_aref(rbcm->requests, INT2NUM((int)rbce->curl));
+  r = rb_hash_aref(rbcm->requests, LONG2NUM((long)rbce->curl));
   if ( r == Qnil ) {
     return;
   }
@@ -304,8 +352,8 @@ static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy) {
 
   ruby_curl_easy_cleanup( easy, rbce );
 
-  // active should equal INT2FIX(RHASH(rbcm->requests)->tbl->num_entries)
-  r = rb_hash_delete( rbcm->requests, INT2NUM((int)rbce->curl) );
+  // active should equal LONG2NUM(RHASH(rbcm->requests)->tbl->num_entries)
+  r = rb_hash_delete( rbcm->requests, LONG2NUM((long)rbce->curl) );
   if( r != easy || r == Qnil ) {
     rb_warn("Possibly lost track of Curl::Easy VALUE, it may not be reclaimed by GC");
   }
@@ -328,6 +376,13 @@ static VALUE ruby_curl_multi_cancel(VALUE self) {
   ruby_curl_multi *rbcm;
 
   Data_Get_Struct(self, ruby_curl_multi, rbcm);
+
+  if (!rbcm->handle) {
+    rbcm->handle = curl_multi_init();
+    if (!rbcm->handle) {
+      rb_raise(mCurlErrFailedInit, "Failed to initialize multi handle");
+    }
+  }
   
   rb_hash_foreach( rbcm->requests, ruby_curl_multi_cancel_callback, (VALUE)rbcm );
   
@@ -450,10 +505,11 @@ static void rb_curl_multi_run(VALUE self, CURLM *multi_handle, int *still_runnin
     mcode = curl_multi_perform(multi_handle, still_running);
   } while (mcode == CURLM_CALL_MULTI_PERFORM);
 
+
   if (mcode != CURLM_OK) {
     raise_curl_multi_error_exception(mcode);
   }
-  
+
 }
 
 #ifdef _WIN32
@@ -517,7 +573,7 @@ static VALUE curb_select(void *args) {
 VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
   CURLMcode mcode;
   ruby_curl_multi *rbcm;
-  int maxfd, rc;
+  int maxfd, rc = -1;
   fd_set fdread, fdwrite, fdexcep;
 #ifdef _WIN32
   fd_set crt_fdread, crt_fdwrite, crt_fdexcep;
@@ -627,7 +683,15 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
 
   rb_curl_multi_read_info( self, rbcm->handle );
   if (block != Qnil) { rb_funcall(block, rb_intern("call"), 1, self);  }
-    
+
+  /* do early cleanup */
+  VALUE hash = rbcm->requests;
+  if (!NIL_P(hash) && rb_type(hash) == T_HASH && RHASH_SIZE(hash) > 0) {
+    rb_hash_foreach(hash, curl_multi_flush_easy, (VALUE)rbcm);
+  }
+  curl_multi_cleanup(rbcm->handle);
+  rbcm->handle = NULL;
+ 
   return Qtrue;
 }
 
@@ -646,7 +710,7 @@ void init_curb_multi() {
   rb_define_method(cCurlMulti, "requests", ruby_curl_multi_requests, 0);
   rb_define_method(cCurlMulti, "idle?", ruby_curl_multi_idle, 0);
   
-  /* Instnace methods */
+  /* Instance methods */
   rb_define_method(cCurlMulti, "max_connects=", ruby_curl_multi_max_connects, 1);
   rb_define_method(cCurlMulti, "pipeline=", ruby_curl_multi_pipeline, 1);
   rb_define_method(cCurlMulti, "add", ruby_curl_multi_add, 1);

data/ext/curb_upload.c

@@ -56,7 +56,7 @@ VALUE ruby_curl_upload_stream_get(VALUE self) {
 VALUE ruby_curl_upload_offset_set(VALUE self, VALUE offset) {
   ruby_curl_upload *rbcu;
   Data_Get_Struct(self, ruby_curl_upload, rbcu);
-  rbcu->offset = FIX2LONG(offset);
+  rbcu->offset = NUM2LONG(offset);
   return offset;
 }
 /*
@@ -66,7 +66,7 @@ VALUE ruby_curl_upload_offset_set(VALUE self, VALUE offset) {
 VALUE ruby_curl_upload_offset_get(VALUE self) {
   ruby_curl_upload *rbcu;
   Data_Get_Struct(self, ruby_curl_upload, rbcu);
-  return INT2FIX(rbcu->offset);
+  return LONG2NUM(rbcu->offset);
 }
 
 /* =================== INIT LIB =====================*/

data/ext/extconf.rb

@@ -321,6 +321,9 @@ have_constant "curl_sslversion_default"
 have_constant :CURL_SSLVERSION_TLSv1
 have_constant :CURL_SSLVERSION_SSLv2
 have_constant :CURL_SSLVERSION_SSLv3
+have_constant :CURL_SSLVERSION_TLSv1_0
+have_constant :CURL_SSLVERSION_TLSv1_1
+have_constant :CURL_SSLVERSION_TLSv1_2
 have_constant "curlopt_ssl_verifypeer"
 have_constant "curlopt_cainfo"
 have_constant "curlopt_issuercert"

data/lib/curl/easy.rb

@@ -6,7 +6,7 @@ module Curl
     alias body body_str
     alias head header_str
 
-    class Error < Exception
+    class Error < StandardError
       attr_accessor :message, :code
       def initialize(code, msg)
         self.message = msg
@@ -20,7 +20,7 @@ module Curl
     #
     def status
       # Matches the last HTTP Status - following the HTTP protocol specification 'Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF'
-      statuses = self.header_str.scan(/HTTP\/\d\.\d\s(\d+\s.+)\r\n/).map{ |match|  match[0] }
+      statuses = self.header_str.scan(/HTTP\/\d\.\d\s(\d+\s.*)\r\n/).map{ |match|  match[0] }
       statuses.last.strip
     end
 

data/lib/curl/multi.rb

@@ -22,7 +22,7 @@ module Curl
       #                     {: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|
+      #                    {:pipeline => Curl::CURLPIPE_HTTP1}) do|easy|
       #     easy_handle_on_request_complete
       #   end
       # 
@@ -46,7 +46,7 @@ module Curl
       #                    {:url => 'url2', :put_data => IO.read('filepath')},
       #                    {:url => 'url3', :put_data => "maybe another string or socket?"],
       #                    {:follow_location => true},
-      #                    {:pipeline => true }) do|easy|
+      #                    {:pipeline => Curl::CURLPIPE_HTTP1}) do|easy|
       #     easy_handle_on_request_complete
       #   end
       # 
@@ -74,7 +74,7 @@ module Curl
       #     :follow_location => true, :max_redirects => 3 },
       #   { :url => 'url3', :method => :put, :put_data => File.open('file.txt','rb') },
       #   { :url => 'url4', :method => :head }
-      # ], {:pipeline => true})
+      # ], {:pipeline => Curl::CURLPIPE_HTTP1})
       #
       # Blocking call to issue multiple HTTP requests with varying verb's.
       #

data/tests/tc_curl_multi.rb

@@ -109,8 +109,12 @@ class TestCurbCurlMulti < Test::Unit::TestCase
 
     assert(m.idle?, 'A new Curl::Multi handle should be idle')
 
+    assert_nil e.multi
+
     m.add(e)
 
+    assert_not_nil e.multi
+
     assert((not m.idle?), 'A Curl::Multi handle with a request should not be idle')
 
     m.perform

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: curb
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.2
 platform: ruby
 authors:
 - Ross Bamford
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-08 00:00:00.000000000 Z
+date: 2016-04-10 00:00:00.000000000 Z
 dependencies: []
 description: Curb (probably CUrl-RuBy or something) provides Ruby-language bindings
   for the libcurl(3), a fully-featured client-side URL transfer library. cURL and
@@ -70,7 +70,8 @@ files:
 - tests/timeout_server.rb
 - tests/unittests.rb
 homepage: http://curb.rubyforge.org/
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: