curb 0.7.15 → 1.0.0

data/ext/curb_multi.c

@@ -3,15 +3,18 @@
  * Licensed under the Ruby License. See LICENSE for details.
  *
  */
-
 #include "curb_config.h"
-#ifdef HAVE_RUBY19_ST_H
-  #include <ruby.h>
+#include <ruby.h>
+#ifdef HAVE_RUBY_ST_H
   #include <ruby/st.h>
 #else
-  #include <ruby.h>
   #include <st.h>
 #endif
+
+#ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL
+  #include <ruby/thread.h>
+#endif
+
 #include "curb_easy.h"
 #include "curb_errors.h"
 #include "curb_postfield.h"
@@ -34,47 +37,29 @@ static VALUE idCall;
 VALUE cCurlMulti;
 
 static long cCurlMutiDefaulttimeout = 100; /* milliseconds */
+static char cCurlMutiAutoClose = 0;
 
 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 );
+void curl_multi_free(ruby_curl_multi *rbcm) {
+  curl_multi_cleanup(rbcm->handle);
+  free(rbcm);
 }
 
-static void 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);
+static void ruby_curl_multi_init(ruby_curl_multi *rbcm) {
+  rbcm->handle = curl_multi_init();
+  if (!rbcm->handle) {
+    rb_raise(mCurlErrFailedInit, "Failed to initialize multi handle");
   }
-}
-
-static int
-rb_hash_clear_i(VALUE key, VALUE value, VALUE dummy) {
-  return ST_DELETE;
-}
-
-static void curl_multi_free(ruby_curl_multi *rbcm) {
 
-  if (rbcm && !rbcm->requests == Qnil && rb_type(rbcm->requests) == T_HASH && RHASH_LEN(rbcm->requests) > 0) {
-
-    rb_hash_foreach( rbcm->requests, (int (*)())curl_multi_flush_easy, (VALUE)rbcm );
-
-    rb_hash_foreach(rbcm->requests, rb_hash_clear_i, 0); //rb_hash_clear(rbcm->requests);
-    rbcm->requests = Qnil;
-  }
-  curl_multi_cleanup(rbcm->handle);
-  free(rbcm);
+  rbcm->active = 0;
+  rbcm->running = 0;
 }
 
 /*
@@ -84,23 +69,17 @@ static void curl_multi_free(ruby_curl_multi *rbcm) {
  * Create a new Curl::Multi instance
  */
 VALUE ruby_curl_multi_new(VALUE klass) {
-  VALUE new_curlm;
-
   ruby_curl_multi *rbcm = ALLOC(ruby_curl_multi);
 
-  rbcm->handle = curl_multi_init();
-  if (!rbcm->handle) {
-    rb_raise(mCurlErrFailedInit, "Failed to initialize multi handle");
-  }
-
-  rbcm->requests = rb_hash_new();
-
-  rbcm->active = 0;
-  rbcm->running = 0;
-
-  new_curlm = Data_Wrap_Struct(klass, curl_multi_mark, curl_multi_free, rbcm);
+  ruby_curl_multi_init(rbcm);
 
-  return new_curlm;
+  /*
+   * The mark routine will be called by the garbage collector during its ``mark'' phase.
+   * If your structure references other Ruby objects, then your mark function needs to
+   * identify these objects using rb_gc_mark(value). If the structure doesn't reference
+   * other Ruby objects, you can simply pass 0 as a function pointer.
+  */
+  return Data_Wrap_Struct(klass, 0, curl_multi_free, rbcm);
 }
 
 /*
@@ -112,7 +91,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;
 }
 
@@ -124,55 +103,39 @@ 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 */
-static int ruby_curl_multi_requests_callback(VALUE key, VALUE value, VALUE result_array) {
-  rb_ary_push(result_array, value);
-  
-  return ST_CONTINUE;
+/*
+ * call-seq:
+ *   Curl::Multi.autoclose = true => true
+ *
+ * Automatically close open connections after each request. Otherwise, the connection will remain open 
+ * for reuse until the next GC
+ *
+ */
+VALUE ruby_curl_multi_set_autoclose(VALUE klass, VALUE onoff) {
+  cCurlMutiAutoClose = ((onoff == Qtrue) ? 1 : 0);
+  return onoff;
 }
 
 /*
  * call-seq:
- *   multi.requests                                   => [#&lt;Curl::Easy...&gt;, ...]
- * 
- * Returns an array containing all the active requests on this Curl::Multi object.
+ *   Curl::Multi.autoclose => true|false
+ *
+ * Get the global default autoclose setting for all Curl::Multi Handles.
+ *
  */
-static VALUE ruby_curl_multi_requests(VALUE self) {
-  ruby_curl_multi *rbcm;
-  VALUE result_array;
-
-  Data_Get_Struct(self, ruby_curl_multi, rbcm);
-  
-  result_array = rb_ary_new();
-  
-  /* iterate over the requests hash, and stuff references into the array. */
-  rb_hash_foreach(rbcm->requests, ruby_curl_multi_requests_callback, result_array);
-  
-  return result_array;
+VALUE ruby_curl_multi_get_autoclose(VALUE klass) {
+  return cCurlMutiAutoClose == 1 ? Qtrue : Qfalse;
 }
 
 /*
  * call-seq:
- *   multi.idle?                                      => true or false
+ *   multi.requests                                   => [#&lt;Curl::Easy...&gt;, ...]
  * 
- * Returns whether or not this Curl::Multi handle is processing any requests.  E.g. this returns
- * true when multi.requests.length == 0.
+ * Returns an array containing all the active requests on this Curl::Multi object.
  */
-static VALUE ruby_curl_multi_idle(VALUE self) {
-  ruby_curl_multi *rbcm;
-  
-  Data_Get_Struct(self, ruby_curl_multi, rbcm);
-  
-  if ( FIX2INT( rb_funcall(rbcm->requests, rb_intern("length"), 0) ) == 0 ) {
-    return Qtrue;
-  } else {
-    return Qfalse;
-  }
-}
-
 /*
  * call-seq:
  * multi = Curl::Multi.new
@@ -185,7 +148,8 @@ 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));
+
+  curl_multi_setopt(rbcm->handle, CURLMOPT_MAXCONNECTS, NUM2LONG(count));
 #endif
 
   return count;
@@ -196,20 +160,31 @@ 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);
+  curl_multi_setopt(rbcm->handle, CURLMOPT_PIPELINING, value);
 #endif
-  return onoff;
+  return method == Qtrue ? 1 : 0;
 }
 
 /*
@@ -243,9 +218,8 @@ 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, easy, easy );
-
-  rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
+  /* track a reference to associated multi handle */
+  rbce->multi = self;
 
   return self;
 }
@@ -264,25 +238,20 @@ VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
  *
  * Will raise an exception if the easy handle is not found
  */
-VALUE ruby_curl_multi_remove(VALUE self, VALUE easy) {
+VALUE ruby_curl_multi_remove(VALUE self, VALUE rb_easy_handle) {
   ruby_curl_multi *rbcm;
-  ruby_curl_easy *rbce;
 
   Data_Get_Struct(self, ruby_curl_multi, rbcm);
 
-  Data_Get_Struct(easy, ruby_curl_easy, rbce);
-
-  rb_curl_multi_remove(rbcm,easy);
+  rb_curl_multi_remove(rbcm, rb_easy_handle);
 
   return self;
 }
 static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy) {
   CURLMcode result;
   ruby_curl_easy *rbce;
-  VALUE r;
 
   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);
@@ -291,43 +260,21 @@ static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy) {
   rbcm->active--;
 
   ruby_curl_easy_cleanup( easy, rbce );
-
-  // active should equal INT2FIX(RHASH(rbcm->requests)->tbl->num_entries)
-  r = rb_hash_delete( rbcm->requests, easy );
-  if( r != easy || r == Qnil ) {
-    rb_warn("Possibly lost track of Curl::Easy VALUE, it may not be reclaimed by GC");
-  }
 }
 
-/* Hash#foreach callback for ruby_curl_multi_cancel */
-static int ruby_curl_multi_cancel_callback(VALUE key, VALUE value, ruby_curl_multi *rbcm) {
-  rb_curl_multi_remove(rbcm, value);
-  
-  return ST_CONTINUE;
+// 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));
 }
-
-/*
- * call-seq:
- *   multi.cancel!
- * 
- * Cancels all requests currently being made on this Curl::Multi handle.  
- */
-static VALUE ruby_curl_multi_cancel(VALUE self) {
-  ruby_curl_multi *rbcm;
-
-  Data_Get_Struct(self, ruby_curl_multi, rbcm);
-  
-  rb_hash_foreach( rbcm->requests, ruby_curl_multi_cancel_callback, (VALUE)rbcm );
-  
-  /* for chaining */
-  return self;
+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, val = Qtrue;
 
   CURLcode ecode = curl_easy_getinfo(easy_handle, CURLINFO_PRIVATE, (char**)&easy);
 
@@ -335,7 +282,8 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
 
   rbce->last_result = result; /* save the last easy result code */
 
-  ruby_curl_multi_remove( self, easy );
+  // remove the easy handle from multi on completion so it can be reused again
+  rb_funcall(self, rb_intern("remove"), 1, easy);
 
   /* after running a request cleanup the headers, these are set before each request */
   if (rbce->curl_headers) {
@@ -348,42 +296,80 @@ 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);
+    rbce->callback_active = 1;
+    val = rb_rescue(call_status_handler1, callargs, callback_exception, Qnil);
+    rbce->callback_active = 0;
+    //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));
+      rbce->callback_active = 1;
+      val = rb_rescue(call_status_handler2, callargs, callback_exception, Qnil);
+      rbce->callback_active = 0;
+      //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);
+    rbce->callback_active = 1;
+    val = rb_rescue(call_status_handler1, callargs, callback_exception, Qnil);
+    rbce->callback_active = 0;
+    //rb_funcall( rb_easy_get("success_proc"), idCall, 1, easy );
+  }
+  else if (!rb_easy_nil("redirect_proc") &&
+          (response_code >= 300 && response_code < 400)) {
+    rbce->callback_active = 1;
+    callargs = rb_ary_new3(3, rb_easy_get("redirect_proc"), easy, rb_curl_easy_error(result));
+    rbce->callback_active = 0;
+    val = rb_rescue(call_status_handler2, callargs, callback_exception, Qnil);
+  }
+  else if (!rb_easy_nil("missing_proc") &&
+          (response_code >= 400 && response_code < 500)) {
+    rbce->callback_active = 1;
+    callargs = rb_ary_new3(3, rb_easy_get("missing_proc"), easy, rb_curl_easy_error(result));
+    rbce->callback_active = 0;
+    val = rb_rescue(call_status_handler2, callargs, callback_exception, Qnil);
   }
   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) );
+          (response_code >= 500 && response_code <= 999)) {
+    callargs = rb_ary_new3(3, rb_easy_get("failure_proc"), easy, rb_curl_easy_error(result));
+    rbce->callback_active = 1;
+    val = rb_rescue(call_status_handler2, callargs, callback_exception, Qnil);
+    rbce->callback_active = 0;
+    //rb_funcall( rb_easy_get("failure_proc"), idCall, 2, easy, rb_curl_easy_error(result) );
   }
 
 }
 
 static void rb_curl_multi_read_info(VALUE self, CURLM *multi_handle) {
-  int msgs_left, result;
-  CURLMsg *msg;
-  CURL *easy_handle;
-
-  /* check for finished easy handles and remove from the multi handle */
-  while ((msg = curl_multi_info_read(multi_handle, &msgs_left))) {
-    if (msg->msg == CURLMSG_DONE) {
-      easy_handle = msg->easy_handle;
-      result = msg->data.result;
-      if (easy_handle) {
-        rb_curl_mutli_handle_complete(self, easy_handle, result);
-      }
-    }
+  int msgs_left;
+
+  CURLcode c_easy_result;
+  CURLMsg *c_multi_result; // for picking up messages with the transfer status
+  CURL *c_easy_handle;
+
+  /* Check for finished easy handles and remove from the multi handle.
+   * curl_multi_info_read will query for messages from individual handles.
+   *
+   * The messages fetched with this function are removed from the curl internal
+   * queue and when there are no messages left it will return NULL (and break
+   * the loop effectively).
+   */
+  while ((c_multi_result = curl_multi_info_read(multi_handle, &msgs_left))) {
+    // A message is there, but we really care only about transfer completetion.
+    if (c_multi_result->msg != CURLMSG_DONE) continue;
+
+    c_easy_handle = c_multi_result->easy_handle;
+    c_easy_result = c_multi_result->data.result; /* return code for transfer */
+
+    rb_curl_mutli_handle_complete(self, c_easy_handle, c_easy_result);
   }
 }
 
@@ -391,14 +377,32 @@ static void rb_curl_multi_read_info(VALUE self, CURLM *multi_handle) {
 static void rb_curl_multi_run(VALUE self, CURLM *multi_handle, int *still_running) {
   CURLMcode mcode;
 
+  /*
+   * curl_multi_perform will return CURLM_CALL_MULTI_PERFORM only when it wants to be called again immediately.
+   * When things are fine and there is nothing immediate it wants done, it'll return CURLM_OK.
+   *
+   * It will perform all pending actions on all added easy handles attached to this multi handle. We will loop
+   * here as long as mcode is CURLM_CALL_MULTIPERFORM.
+   */
   do {
     mcode = curl_multi_perform(multi_handle, still_running);
   } while (mcode == CURLM_CALL_MULTI_PERFORM);
 
+  /*
+   * Nothing more to do, check if an error occured in the loop above and raise an exception if necessary.
+   */
+
   if (mcode != CURLM_OK) {
     raise_curl_multi_error_exception(mcode);
   }
-  
+
+  /*
+   * Everything is ok, but this does not mean all the transfers are completed.
+   * There is no data to read or write available for Curl at the moment.
+   *
+   * At this point we can return control to the caller to do something else while
+   * curl is waiting for more actions to queue.
+   */
 }
 
 #ifdef _WIN32
@@ -430,6 +434,20 @@ void cleanup_crt_fd(fd_set *os_set, fd_set *crt_set)
 }
 #endif
 
+#if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
+struct _select_set {
+  int maxfd;
+  fd_set *fdread, *fdwrite, *fdexcep;
+  struct timeval *tv;
+};
+
+static VALUE curb_select(void *args) {
+  struct _select_set* set = args;
+  int rc = select(set->maxfd, set->fdread, set->fdwrite, set->fdexcep, set->tv);
+  return INT2FIX(rc);
+}
+#endif
+
 /*
  * call-seq:
  * multi = Curl::Multi.new
@@ -448,15 +466,18 @@ void cleanup_crt_fd(fd_set *os_set, fd_set *crt_set)
 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;
 #endif
-
   long timeout_milliseconds;
   struct timeval tv = {0, 0};
+  struct timeval tv_100ms = {0, 100000};
   VALUE block = Qnil;
+#if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
+  struct _select_set fdset_args;
+#endif
 
   rb_scan_args(argc, argv, "0&", &block);
 
@@ -464,8 +485,23 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
 
   timeout_milliseconds = cCurlMutiDefaulttimeout;
 
+  // Run curl_multi_perform for the first time to get the ball rolling
   rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
- 
+
+  // Check the easy handles for new messages one more time before yielding
+  // control to passed ruby block.
+  //
+  // This call will block until all queued messages are processed and if any
+  // handle completed the transfer we will run the on_complete callback here too.
+  rb_curl_multi_read_info( self, rbcm->handle );
+
+  // There are no more messages to handle by curl and we can run the ruby block
+  // passed to perform method.
+  // When the block completes curl will resume.
+  if (block != Qnil) {
+    rb_funcall(block, rb_intern("call"), 1, self);
+  }
+
   do {
     while (rbcm->running) {
 
@@ -505,13 +541,39 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
         raise_curl_multi_error_exception(mcode);
       }
 
+      if (maxfd == -1) {
+        /* libcurl recommends sleeping for 100ms */
+        rb_thread_wait_for(tv_100ms);
+        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);  }
+        continue;
+      }
+
 #ifdef _WIN32
       create_crt_fd(&fdread, &crt_fdread);
       create_crt_fd(&fdwrite, &crt_fdwrite);
       create_crt_fd(&fdexcep, &crt_fdexcep);
 #endif
 
+
+#if (defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL))
+      fdset_args.maxfd = maxfd+1;
+      fdset_args.fdread = &fdread;
+      fdset_args.fdwrite = &fdwrite;
+      fdset_args.fdexcep = &fdexcep;
+      fdset_args.tv = &tv;
+#endif
+
+#ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL
+      rc = (int)(VALUE) rb_thread_call_without_gvl((void *(*)(void *))curb_select, &fdset_args, RUBY_UBF_IO, 0);
+#elif HAVE_RB_THREAD_BLOCKING_REGION
+      rc = rb_thread_blocking_region(curb_select, &fdset_args, RUBY_UBF_IO, 0);
+#elif HAVE_RB_THREAD_FD_SELECT
+      rc = rb_thread_fd_select(maxfd+1, &fdread, &fdwrite, &fdexcep, &tv);
+#else
       rc = rb_thread_select(maxfd+1, &fdread, &fdwrite, &fdexcep, &tv);
+#endif
 
 #ifdef _WIN32
       cleanup_crt_fd(&fdread, &crt_fdread);
@@ -521,8 +583,10 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
 
       switch(rc) {
       case -1:
-        rb_raise(rb_eRuntimeError, "select(): %s", strerror(errno));
-        break;
+        if(errno != EINTR) {
+          rb_raise(rb_eRuntimeError, "select(): %s", strerror(errno));
+          break;
+        }
       case 0: /* timeout */
       default: /* action */
         rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
@@ -536,30 +600,44 @@ 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);  }
-    
+  if (cCurlMutiAutoClose  == 1) {
+    rb_funcall(self, rb_intern("close"), 0);
+  }
   return Qtrue;
 }
 
+/*
+ * call-seq:
+ *
+ * multi.close
+ * after closing the multi handle all connections will be closed and the handle will no longer be usable
+ *
+ */
+VALUE ruby_curl_multi_close(VALUE self) {
+  ruby_curl_multi *rbcm;
+  Data_Get_Struct(self, ruby_curl_multi, rbcm);
+  curl_multi_cleanup(rbcm->handle);
+  ruby_curl_multi_init(rbcm);
+  return self;
+}
+
+
 /* =================== INIT LIB =====================*/
 void init_curb_multi() {
   idCall = rb_intern("call");
-
   cCurlMulti = rb_define_class_under(mCurl, "Multi", rb_cObject);
 
   /* Class methods */
   rb_define_singleton_method(cCurlMulti, "new", ruby_curl_multi_new, 0);
   rb_define_singleton_method(cCurlMulti, "default_timeout=", ruby_curl_multi_set_default_timeout, 1);
   rb_define_singleton_method(cCurlMulti, "default_timeout", ruby_curl_multi_get_default_timeout, 0);
-  
-  /* "Attributes" */
-  rb_define_method(cCurlMulti, "requests", ruby_curl_multi_requests, 0);
-  rb_define_method(cCurlMulti, "idle?", ruby_curl_multi_idle, 0);
-  
-  /* Instnace methods */
+  rb_define_singleton_method(cCurlMulti, "autoclose=", ruby_curl_multi_set_autoclose, 1);
+  rb_define_singleton_method(cCurlMulti, "autoclose", ruby_curl_multi_get_autoclose, 0);
+  /* 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);
-  rb_define_method(cCurlMulti, "remove", ruby_curl_multi_remove, 1);
-  rb_define_method(cCurlMulti, "cancel!", ruby_curl_multi_cancel, 0);
+  rb_define_method(cCurlMulti, "_add", ruby_curl_multi_add, 1);
+  rb_define_method(cCurlMulti, "_remove", ruby_curl_multi_remove, 1);
   rb_define_method(cCurlMulti, "perform", ruby_curl_multi_perform, -1);
+  rb_define_method(cCurlMulti, "_close", ruby_curl_multi_close, 0);
 }

data/ext/curb_multi.h

@@ -14,7 +14,6 @@
 typedef struct {
   int active;
   int running;
-  VALUE requests; /* hash of handles currently added */
   CURLM *handle;
 } ruby_curl_multi;
 

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 =====================*/