curb 0.9.4 → 0.9.10

data/ext/curb_easy.h

@@ -55,6 +55,8 @@ typedef struct {
   unsigned long ftp_response_timeout;
   long low_speed_limit;
   long low_speed_time;
+  long max_send_speed_large;
+  long max_recv_speed_large;
   long ssl_version;
   long use_ssl;
   long ftp_filemethod;
@@ -76,7 +78,9 @@ typedef struct {
   char callback_active;
 
   struct curl_slist *curl_headers;
+  struct curl_slist *curl_proxy_headers;
   struct curl_slist *curl_ftp_commands;
+  struct curl_slist *curl_resolve;
 
   int last_result; /* last result code from multi loop */
 

data/ext/curb_errors.c

@@ -21,6 +21,7 @@ VALUE eCurlErrFileError;
 VALUE eCurlErrLDAPError;
 VALUE eCurlErrTelnetError;
 VALUE eCurlErrTFTPError;
+VALUE eCurlErrRTSPError;
 
 /* Specific libcurl errors */
 VALUE eCurlErrOK; /* not really an error but a return code */
@@ -127,6 +128,18 @@ VALUE mCurlErrUnknownOption;
 VALUE eCurlErrInvalidPostField;
 
 
+/* new errors */
+VALUE eCurlErrFTPPRETFailed;
+VALUE eCurlErrRTSPCseqError;
+VALUE eCurlErrRTSPSessionError;
+VALUE eCurlErrFTPBadFileList;
+VALUE eCurlErrChunkFailed;
+VALUE eCurlErrNoConnectionAvailable;
+VALUE eCurlErrSSLPinnedPubKeyNotMatch;
+VALUE eCurlErrSSLInvalidCertStatus;
+VALUE eCurlErrHTTP2Stream;
+
+
 VALUE rb_curl_easy_error(CURLcode code) {
   VALUE exclz;
   const char *exmsg = NULL;
@@ -294,9 +307,11 @@ VALUE rb_curl_easy_error(CURLcode code) {
       exclz = eCurlErrObsolete;
       break;
 #endif
+#if LIBCURL_VERSION_NUM < 0x073e00
     case CURLE_SSL_PEER_CERTIFICATE:    /* 51 - peer's certificate wasn't ok */
       exclz = eCurlErrSSLPeerCertificate;
       break;
+#endif
     case CURLE_GOT_NOTHING:             /* 52 - when this is a specific error */
       exclz = eCurlErrGotNothing;
       break;
@@ -321,8 +336,13 @@ VALUE rb_curl_easy_error(CURLcode code) {
     case CURLE_SSL_CIPHER:              /* 59 - couldn't use specified cipher */
       exclz = eCurlErrSSLCipher;
       break;
+#if LIBCURL_VERSION_NUM >= 0x073e00
+    case CURLE_PEER_FAILED_VERIFICATION:              /* 60 - problem with the CA cert (path?) */
+      exclz = eCurlErrSSLPeerCertificate;
+#else
     case CURLE_SSL_CACERT:              /* 60 - problem with the CA cert (path?) */
       exclz = eCurlErrSSLCACertificate;
+#endif
       break;
     case CURLE_BAD_CONTENT_ENCODING:    /* 61 - Unrecognized transfer encoding */
       exclz = eCurlErrBadContentEncoding;
@@ -445,6 +465,61 @@ VALUE rb_curl_easy_error(CURLcode code) {
       exclz = eCurlErrSSLIssuerError;
       break;
 #endif
+
+#ifdef  HAVE_CURLE_FTP_PRET_FAILED
+    case CURLE_FTP_PRET_FAILED:  /* 84 */
+      exclz = eCurlErrFTPPRETFailed;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_RTSP_CSEQ_ERROR
+    case CURLE_RTSP_CSEQ_ERROR:  /* 85 */
+      exclz = eCurlErrRTSPCseqError;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_RTSP_SESSION_ERROR
+    case CURLE_RTSP_SESSION_ERROR:  /* 86 */
+      exclz = eCurlErrRTSPSessionError;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_FTP_BAD_FILE_LIST
+    case CURLE_FTP_BAD_FILE_LIST:  /* 87 */
+      exclz = eCurlErrFTPBadFileList;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_CHUNK_FAILED
+    case CURLE_CHUNK_FAILED:  /* 88 */
+      exclz = eCurlErrChunkFailed;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_NO_CONNECTION_AVAILABLE
+    case CURLE_NO_CONNECTION_AVAILABLE:  /* 89 */
+      exclz = eCurlErrNoConnectionAvailable;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_SSL_PINNEDPUBKEYNOTMATCH
+    case CURLE_SSL_PINNEDPUBKEYNOTMATCH:  /* 90 */
+      exclz = eCurlErrSSLPinnedPubKeyNotMatch;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_SSL_INVALIDCERTSTATUS
+    case CURLE_SSL_INVALIDCERTSTATUS:  /* 91 */
+      exclz = eCurlErrSSLInvalidCertStatus;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_HTTP2_STREAM
+    case CURLE_HTTP2_STREAM:  /* 92 */
+      exclz = eCurlErrHTTP2Stream;
+      break;
+#endif
+
     default:
       exclz = eCurlErrError;
       exmsg = "Unknown error result from libcurl";
@@ -532,6 +607,7 @@ void init_curb_errors() {
   eCurlErrLDAPError = rb_define_class_under(mCurlErr, "LDAPError", eCurlErrError);
   eCurlErrTelnetError = rb_define_class_under(mCurlErr, "TelnetError", eCurlErrError);
   eCurlErrTFTPError = rb_define_class_under(mCurlErr, "TFTPError", eCurlErrError);
+  eCurlErrRTSPError = rb_define_class_under(mCurlErr, "RTSPError", eCurlErrError);
 
   eCurlErrOK = rb_define_class_under(mCurlErr, "CurlOK", eCurlErrError);
   eCurlErrUnsupportedProtocol = rb_define_class_under(mCurlErr, "UnsupportedProtocolError", eCurlErrError);
@@ -657,4 +733,14 @@ void init_curb_errors() {
   eCurlErrTFTPNoSuchUser = rb_define_class_under(mCurlErr, "NoSuchUserError", eCurlErrTFTPError);
 
   eCurlErrInvalidPostField = rb_define_class_under(mCurlErr, "InvalidPostFieldError", eCurlErrError);
+
+  eCurlErrFTPPRETFailed = rb_define_class_under(mCurlErr, "PPRETFailedError", eCurlErrFTPError);
+  eCurlErrRTSPCseqError = rb_define_class_under(mCurlErr, "CseqError", eCurlErrRTSPError);
+  eCurlErrRTSPSessionError = rb_define_class_under(mCurlErr, "SessionError", eCurlErrRTSPError);
+  eCurlErrFTPBadFileList = rb_define_class_under(mCurlErr, "BadFileListError", eCurlErrFTPError);
+  eCurlErrChunkFailed = rb_define_class_under(mCurlErr, "ChunkFailedError", eCurlErrError);
+  eCurlErrNoConnectionAvailable = rb_define_class_under(mCurlErr, "NoConnectionAvailableError", eCurlErrError);
+  eCurlErrSSLPinnedPubKeyNotMatch = rb_define_class_under(mCurlErr, "SSLPinnedPubKeyNotMatchError", eCurlErrError);
+  eCurlErrSSLInvalidCertStatus = rb_define_class_under(mCurlErr, "SSLInvalidCertStatusError", eCurlErrError);
+  eCurlErrHTTP2Stream = rb_define_class_under(mCurlErr, "HTTP2StreamError", eCurlErrHTTPError);
 }

data/ext/curb_multi.c

@@ -37,6 +37,7 @@ 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);
@@ -44,43 +45,21 @@ static void rb_curl_multi_run(VALUE self, CURLM *multi_handle, int *still_runnin
 
 static VALUE callback_exception(VALUE unused) {
   return Qfalse;
-} 
-
-static void curl_multi_mark(ruby_curl_multi *rbcm) {
-  if (!NIL_P(rbcm->requests)) rb_gc_mark(rbcm->requests);
-}
-
-/* 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;
-
-  // 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);
-    }
-  }
-
-  return ST_DELETE;
 }
 
 void curl_multi_free(ruby_curl_multi *rbcm) {
-  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);
-    /* rb_hash_clear(rbcm->requests); */
+  curl_multi_cleanup(rbcm->handle);
+  free(rbcm);
+}
 
-    rbcm->requests = Qnil;
+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");
   }
 
-  curl_multi_cleanup(rbcm->handle);
-  free(rbcm);
+  rbcm->active = 0;
+  rbcm->running = 0;
 }
 
 /*
@@ -90,23 +69,17 @@ 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");
-  }
+  ruby_curl_multi_init(rbcm);
 
-  rbcm->requests = rb_hash_new();
-
-  rbcm->active = 0;
-  rbcm->running = 0;
-
-  new_curlm = Data_Wrap_Struct(klass, curl_multi_mark, curl_multi_free, 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);
 }
 
 /*
@@ -133,52 +106,36 @@ VALUE ruby_curl_multi_get_default_timeout(VALUE klass) {
   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                                   => [#<Curl::Easy...>, ...]
- * 
- * 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                                   => [#<Curl::Easy...>, ...]
  * 
- * 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 (RHASH_SIZE(rbcm->requests) == 0) {
-    return Qtrue;
-  } else {
-    return Qfalse;
-  }
-}
-
 /*
  * call-seq:
  * multi = Curl::Multi.new
@@ -241,19 +198,12 @@ static VALUE ruby_curl_multi_pipeline(VALUE self, VALUE method) {
  */
 VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
   CURLMcode mcode;
-  VALUE r;
   ruby_curl_easy *rbce;
   ruby_curl_multi *rbcm;
 
   Data_Get_Struct(self, ruby_curl_multi, rbcm);
   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, LONG2NUM((long)rbce->curl));
-  if ( r != Qnil ) {
-    return Qnil;
-  }
-
   /* setup the easy handle */
   ruby_curl_easy_setup( rbce );
 
@@ -271,8 +221,6 @@ VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
   /* track a reference to associated multi handle */
   rbce->multi = self;
 
-  rb_hash_aset( rbcm->requests, LONG2NUM((long)rbce->curl), easy );
-
   return self;
 }
 
@@ -290,28 +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;
 
   Data_Get_Struct(self, ruby_curl_multi, rbcm);
 
-  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);
-
-  // check if this curl handle has been added before removing
-  r = rb_hash_aref(rbcm->requests, LONG2NUM((long)rbce->curl));
-  if ( r == Qnil ) {
-    return;
-  }
-
   result = curl_multi_remove_handle(rbcm->handle, rbce->curl);
   if (result != 0) {
     raise_curl_multi_error_exception(result);
@@ -320,36 +260,6 @@ static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy) {
   rbcm->active--;
 
   ruby_curl_easy_cleanup( easy, rbce );
-
-  // 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");
-  }
-}
-
-/* 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;
-}
-
-/*
- * 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;
 }
 
 // on_success, on_failure, on_complete
@@ -361,7 +271,6 @@ static VALUE call_status_handler2(VALUE ary) {
 }
 
 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;
@@ -373,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) {
@@ -436,26 +346,30 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
     //rb_funcall( rb_easy_get("failure_proc"), idCall, 2, easy, rb_curl_easy_error(result) );
   }
 
-  if (val == Qfalse) {
-    rb_warn("uncaught exception from callback");
-  }
-
 }
 
 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);
   }
 }
 
@@ -463,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
@@ -541,6 +473,7 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
 #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;
@@ -552,10 +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 );
-  if (block != Qnil) { rb_funcall(block, rb_intern("call"), 1, self);  }
- 
+
+  // 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) {
 
@@ -597,7 +543,7 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
 
       if (maxfd == -1) {
         /* libcurl recommends sleeping for 100ms */
-        rb_thread_wait_for(rb_time_timeval(DBL2NUM(0.1)));
+        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);  }
@@ -610,12 +556,15 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
       create_crt_fd(&fdexcep, &crt_fdexcep);
 #endif
 
-#if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
+
+#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
@@ -626,8 +575,6 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
       rc = rb_thread_select(maxfd+1, &fdread, &fdwrite, &fdexcep, &tv);
 #endif
 
-#endif
-
 #ifdef _WIN32
       cleanup_crt_fd(&fdread, &crt_fdread);
       cleanup_crt_fd(&fdwrite, &crt_fdwrite);
@@ -653,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);
-  
+  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);
 }