curb 0.6.5.0 → 0.8.4

data/ext/curb_easy.h

@@ -11,6 +11,24 @@
 
 #include <curl/easy.h>
 
+#ifdef CURL_VERSION_SSL
+#if LIBCURL_VERSION_NUM >= 0x070b00
+#  if LIBCURL_VERSION_NUM <= 0x071004
+#    define CURB_FTPSSL         CURLOPT_FTP_SSL
+#    define CURB_FTPSSL_ALL     CURLFTPSSL_ALL
+#    define CURB_FTPSSL_TRY     CURLFTPSSL_TRY
+#    define CURB_FTPSSL_CONTROL CURLFTPSSL_CONTROL
+#    define CURB_FTPSSL_NONE    CURLFTPSSL_NONE
+#  else
+#    define CURB_FTPSSL         CURLOPT_USE_SSL
+#    define CURB_FTPSSL_ALL     CURLUSESSL_ALL
+#    define CURB_FTPSSL_TRY     CURLUSESSL_TRY
+#    define CURB_FTPSSL_CONTROL CURLUSESSL_CONTROL
+#    define CURB_FTPSSL_NONE    CURLUSESSL_NONE
+#  endif
+#endif
+#endif
+
 /* a lot of this *could* be kept in the handler itself,
  * but then we lose the ability to query it's status.
  */
@@ -19,6 +37,7 @@ typedef struct {
   CURL *curl;
 
   VALUE opts; /* rather then allocate everything we might need to store, allocate a Hash and only store objects we actually use... */
+  VALUE multi; /* keep a multi handle alive for each easy handle not being used by a multi handle.  This improves easy performance when not within a multi context */
 
   /* Other opts */
   unsigned short local_port;       // 0 is no port
@@ -32,6 +51,12 @@ typedef struct {
   unsigned long connect_timeout;
   long dns_cache_timeout;
   unsigned long ftp_response_timeout;
+  long low_speed_limit;
+  long low_speed_time;
+  long ssl_version;
+  long use_ssl;
+  long ftp_filemethod;
+  unsigned short resolve_mode;
 
   /* bool flags */
   char proxy_tunnel;
@@ -45,7 +70,11 @@ typedef struct {
   char verbose;
   char multipart_form_post;
   char enable_cookies;
+  char ignore_content_length;
+  char callback_active;
+
   struct curl_slist *curl_headers;
+  struct curl_slist *curl_ftp_commands;
 
   int last_result; /* last result code from multi loop */
 
@@ -53,8 +82,8 @@ typedef struct {
 
 extern VALUE cCurlEasy;
 
-VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce, struct curl_slist **headers);
-VALUE ruby_curl_easy_cleanup(VALUE self, ruby_curl_easy *rbce, struct curl_slist *headers);
+VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce);
+VALUE ruby_curl_easy_cleanup(VALUE self, ruby_curl_easy *rbce);
 
 void init_curb_easy();
 

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;
@@ -110,6 +111,7 @@ VALUE eCurlErrSSLCRLBadfile;
 VALUE eCurlErrSSLIssuerError;
 
 /* multi errors */
+VALUE mCurlErrFailedInit;
 VALUE mCurlErrCallMultiPerform;
 VALUE mCurlErrBadHandle;
 VALUE mCurlErrBadEasyHandle;
@@ -140,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;
@@ -278,9 +286,11 @@ VALUE rb_curl_easy_error(CURLcode code) {
     case CURLE_TELNET_OPTION_SYNTAX:    /* 49 - Malformed telnet option */
       exclz = eCurlErrTelnetBadOptionSyntax;
       break;
+#ifdef HAVE_CURLE_OBSOLETE
     case CURLE_OBSOLETE:                /* 50 - NOT USED */
       exclz = eCurlErrObsolete;
       break;
+#endif
     case CURLE_SSL_PEER_CERTIFICATE:    /* 51 - peer's certificate wasn't ok */
       exclz = eCurlErrSSLPeerCertificate;
       break;
@@ -449,7 +459,8 @@ VALUE rb_curl_easy_error(CURLcode code) {
 /* rb_raise an approriate exception for the supplied CURLcode */
 void raise_curl_easy_error_exception(CURLcode code) {
   VALUE obj = rb_curl_easy_error(code);
-  rb_raise(rb_ary_entry(obj,0), RSTRING_PTR(rb_ary_entry(obj,1)));
+  VALUE exmsg = rb_ary_entry(obj,1);
+  rb_raise(rb_ary_entry(obj,0), "CURLError: %s", StringValueCStr(exmsg));
 }
 VALUE rb_curl_multi_error(CURLMcode code) {
   VALUE exclz;
@@ -499,7 +510,8 @@ VALUE rb_curl_multi_error(CURLMcode code) {
 }
 void raise_curl_multi_error_exception(CURLMcode code) {
   VALUE obj = rb_curl_multi_error(code);
-  rb_raise(rb_ary_entry(obj,0), RSTRING_PTR(rb_ary_entry(obj,1)));
+  VALUE exmsg = rb_ary_entry(obj,1);
+  rb_raise(rb_ary_entry(obj,0), "CURLError: %s", StringValueCStr(exmsg));
 }
 
 void init_curb_errors() {
@@ -517,6 +529,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);
@@ -605,6 +618,7 @@ void init_curb_errors() {
   eCurlErrSSLShutdownFailed  = rb_define_class_under(mCurlErr, "SSLShutdownFailed", eCurlErrError);
   eCurlErrSSH                = rb_define_class_under(mCurlErr, "SSH", eCurlErrError);
 
+  mCurlErrFailedInit         = rb_define_class_under(mCurlErr, "MultiInitError", eCurlErrError);
   mCurlErrCallMultiPerform   = rb_define_class_under(mCurlErr, "MultiPerform", eCurlErrError);
   mCurlErrBadHandle          = rb_define_class_under(mCurlErr, "MultiBadHandle", eCurlErrError);
   mCurlErrBadEasyHandle      = rb_define_class_under(mCurlErr, "MultiBadEasyHandle", eCurlErrError);

data/ext/curb_errors.h

@@ -108,6 +108,7 @@ extern VALUE eCurlErrSSLCRLBadfile;
 extern VALUE eCurlErrSSLIssuerError;
 
 /* multi errors */
+extern VALUE mCurlErrFailedInit;
 extern VALUE mCurlErrCallMultiPerform;
 extern VALUE mCurlErrBadHandle;
 extern VALUE mCurlErrBadEasyHandle;

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>
@@ -19,6 +18,11 @@
 
 #include <errno.h>
 
+#ifdef _WIN32
+  // for O_RDWR and O_BINARY
+  #include <fcntl.h>
+#endif
+
 extern VALUE mCurl;
 static VALUE idCall;
 
@@ -28,16 +32,18 @@ static VALUE idCall;
 
 VALUE cCurlMulti;
 
+static long cCurlMutiDefaulttimeout = 100; /* milliseconds */
+
 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) {
@@ -81,6 +87,9 @@ VALUE ruby_curl_multi_new(VALUE klass) {
   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();
 
@@ -92,6 +101,30 @@ VALUE ruby_curl_multi_new(VALUE klass) {
   return new_curlm;
 }
 
+/*
+ * call-seq:
+ *   Curl::Multi.default_timeout = 4 => 4
+ *
+ * Set the global default time out for all Curl::Multi Handles.  This value is used
+ * when libcurl cannot determine a timeout value when calling curl_multi_timeout.
+ *
+ */
+VALUE ruby_curl_multi_set_default_timeout(VALUE klass, VALUE timeout) {
+  cCurlMutiDefaulttimeout = FIX2LONG(timeout);
+  return timeout;
+}
+
+/*
+ * call-seq:
+ *   Curl::Multi.default_timeout = 4 => 4
+ *
+ * Get the global default time out for all Curl::Multi Handles.
+ *
+ */
+VALUE ruby_curl_multi_get_default_timeout(VALUE klass) {
+  return INT2FIX(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);
@@ -194,14 +227,14 @@ VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
   Data_Get_Struct(self, ruby_curl_multi, rbcm);
   Data_Get_Struct(easy, ruby_curl_easy, rbce);
 
+  /* setup the easy handle */
+  ruby_curl_easy_setup( rbce );
+
   mcode = curl_multi_add_handle(rbcm->handle, rbce->curl);
   if (mcode != CURLM_CALL_MULTI_PERFORM && mcode != CURLM_OK) {
     raise_curl_multi_error_exception(mcode);
   }
 
-  /* setup the easy handle */
-  ruby_curl_easy_setup( rbce, &(rbce->curl_headers) );
-
   rbcm->active++;
 
   /* Increase the running count, so that the perform loop keeps running.
@@ -253,7 +286,7 @@ static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy) {
 
   rbcm->active--;
 
-  ruby_curl_easy_cleanup( easy, rbce, rbce->curl_headers );
+  ruby_curl_easy_cleanup( easy, rbce );
 
   // active should equal INT2FIX(RHASH(rbcm->requests)->tbl->num_entries)
   r = rb_hash_delete( rbcm->requests, easy );
@@ -286,44 +319,96 @@ 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, val = Qtrue;
 
   CURLcode ecode = curl_easy_getinfo(easy_handle, CURLINFO_PRIVATE, (char**)&easy);
 
   Data_Get_Struct(easy, ruby_curl_easy, rbce);
 
-  if (ecode != 0) {
-    raise_curl_easy_error_exception(ecode);
-  }
-
   rbce->last_result = result; /* save the last easy result code */
 
   ruby_curl_multi_remove( self, easy );
 
+  /* after running a request cleanup the headers, these are set before each request */
+  if (rbce->curl_headers) {
+    curl_slist_free_all(rbce->curl_headers);
+    rbce->curl_headers = NULL;
+  }
+
+  if (ecode != 0) {
+    raise_curl_easy_error_exception(ecode);
+  }
+
   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) );
   }
+
+  if (val == Qfalse) {
+    rb_warn("uncaught exception from callback");
+      // exception was raised?
+    //fprintf(stderr, "exception raised from callback\n");
+  }
+
 }
 
 static void rb_curl_multi_read_info(VALUE self, CURLM *multi_handle) {
@@ -354,9 +439,51 @@ static void rb_curl_multi_run(VALUE self, CURLM *multi_handle, int *still_runnin
   if (mcode != CURLM_OK) {
     raise_curl_multi_error_exception(mcode);
   }
+  
+}
+
+#ifdef _WIN32
+void create_crt_fd(fd_set *os_set, fd_set *crt_set)
+{
+  int i;
+  crt_set->fd_count = os_set->fd_count;
+  for (i = 0; i < os_set->fd_count; i++) {
+    WSAPROTOCOL_INFO wsa_pi;
+    // dupicate the SOCKET
+    int r = WSADuplicateSocket(os_set->fd_array[i], GetCurrentProcessId(), &wsa_pi);
+    SOCKET s = WSASocket(wsa_pi.iAddressFamily, wsa_pi.iSocketType, wsa_pi.iProtocol, &wsa_pi, 0, 0);
+    // create the CRT fd so ruby can get back to the SOCKET
+    int fd = _open_osfhandle(s, O_RDWR|O_BINARY);
+    os_set->fd_array[i] = s;
+    crt_set->fd_array[i] = fd;
+  }
+}
 
-  rb_curl_multi_read_info( self, multi_handle );
+void cleanup_crt_fd(fd_set *os_set, fd_set *crt_set)
+{
+  int i;
+  for (i = 0; i < os_set->fd_count; i++) {
+    // cleanup the CRT fd
+    _close(crt_set->fd_array[i]);
+    // cleanup the duplicated SOCKET
+    closesocket(os_set->fd_array[i]);
+  }
 }
+#endif
+
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+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:
@@ -378,75 +505,108 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
   ruby_curl_multi *rbcm;
   int maxfd, rc;
   fd_set fdread, fdwrite, fdexcep;
-
+#ifdef _WIN32
+  fd_set crt_fdread, crt_fdwrite, crt_fdexcep;
+#endif
   long timeout_milliseconds;
   struct timeval tv = {0, 0};
   VALUE block = Qnil;
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+  struct _select_set fdset_args;
+#endif
 
   rb_scan_args(argc, argv, "0&", &block);
 
   Data_Get_Struct(self, ruby_curl_multi, rbcm);
 
+  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) {
+
+#ifdef HAVE_CURL_MULTI_TIMEOUT
+      /* get the curl suggested time out */
+      mcode = curl_multi_timeout(rbcm->handle, &timeout_milliseconds);
+      if (mcode != CURLM_OK) {
+        raise_curl_multi_error_exception(mcode);
+      }
+#else
+      /* libcurl doesn't have a timeout method defined, initialize to -1 we'll pick up the default later */
+      timeout_milliseconds = -1;
+#endif
+
+      if (timeout_milliseconds == 0) { /* no delay */
+        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;
+      }
 
-  while(rbcm->running) {
-    FD_ZERO(&fdread);
-    FD_ZERO(&fdwrite);
-    FD_ZERO(&fdexcep);
+      if (timeout_milliseconds < 0 || timeout_milliseconds > cCurlMutiDefaulttimeout) {
+        timeout_milliseconds = cCurlMutiDefaulttimeout; /* libcurl doesn't know how long to wait, use a default timeout */
+                                                        /* or buggy versions libcurl sometimes reports huge timeouts... let's cap it */
+      }
 
-    /* load the fd sets from the multi handle */
-    mcode = curl_multi_fdset(rbcm->handle, &fdread, &fdwrite, &fdexcep, &maxfd);
-    if (mcode != CURLM_OK) {
-      raise_curl_multi_error_exception(mcode);
-    }
+      tv.tv_sec  = 0; /* never wait longer than 1 second */
+      tv.tv_usec = (int)(timeout_milliseconds * 1000); /* XXX: int is the right type for OSX, what about linux? */
 
-#ifdef HAVE_CURL_MULTI_TIMEOUT
-    /* get the curl suggested time out */
-    mcode = curl_multi_timeout(rbcm->handle, &timeout_milliseconds);
-    if (mcode != CURLM_OK) {
-      raise_curl_multi_error_exception(mcode);
-    }
+      FD_ZERO(&fdread);
+      FD_ZERO(&fdwrite);
+      FD_ZERO(&fdexcep);
+
+      /* load the fd sets from the multi handle */
+      mcode = curl_multi_fdset(rbcm->handle, &fdread, &fdwrite, &fdexcep, &maxfd);
+      if (mcode != CURLM_OK) {
+        raise_curl_multi_error_exception(mcode);
+      }
+
+#ifdef _WIN32
+      create_crt_fd(&fdread, &crt_fdread);
+      create_crt_fd(&fdwrite, &crt_fdwrite);
+      create_crt_fd(&fdexcep, &crt_fdexcep);
+#endif
+
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+      fdset_args.maxfd = maxfd+1;
+      fdset_args.fdread = &fdread;
+      fdset_args.fdwrite = &fdwrite;
+      fdset_args.fdexcep = &fdexcep;
+      fdset_args.tv = &tv;
+      rc = rb_thread_blocking_region(curb_select, &fdset_args, RUBY_UBF_IO, 0);
 #else
-    /* libcurl doesn't have a timeout method defined... make a wild guess */
-    timeout_milliseconds = -1;
+      rc = rb_thread_select(maxfd+1, &fdread, &fdwrite, &fdexcep, &tv);
 #endif
-    //printf("libcurl says wait: %ld ms or %ld s\n", timeout_milliseconds, timeout_milliseconds/1000);
 
-    if (timeout_milliseconds == 0) { /* no delay */
-      rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
-      continue;
-    }
-    else if(timeout_milliseconds < 0) {
-      timeout_milliseconds = 500; /* wait half a second, libcurl doesn't know how long to wait */
-    }
-#ifdef __APPLE_CC__
-    if(timeout_milliseconds > 1000) {
-      timeout_milliseconds = 1000; /* apple libcurl sometimes reports huge timeouts... let's cap it */
-    }
+#ifdef _WIN32
+      cleanup_crt_fd(&fdread, &crt_fdread);
+      cleanup_crt_fd(&fdwrite, &crt_fdwrite);
+      cleanup_crt_fd(&fdexcep, &crt_fdexcep);
 #endif
 
-    tv.tv_sec = timeout_milliseconds / 1000; // convert milliseconds to seconds
-    tv.tv_usec = (timeout_milliseconds % 1000) * 1000; // get the remainder of milliseconds and convert to micro seconds
-
-    rc = rb_thread_select(maxfd+1, &fdread, &fdwrite, &fdexcep, &tv);
-    switch(rc) {
-    case -1:
-      rb_raise(rb_eRuntimeError, "select(): %s", strerror(errno));
-      break;
-    case 0:
-      if (block != Qnil) {
-        rb_funcall(block, rb_intern("call"), 1, self); 
+      switch(rc) {
+      case -1:
+        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) );
+        rb_curl_multi_read_info( self, rbcm->handle );
+        if (block != Qnil) { rb_funcall(block, rb_intern("call"), 1, self);  }
+        break;
       }
-//      if (rb_block_given_p()) {
-//        rb_yield(self);
-//      }
-    default: 
-      rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
-      break;
     }
 
-  }
+  } while( rbcm->running );
 
+  rb_curl_multi_read_info( self, rbcm->handle );
+  if (block != Qnil) { rb_funcall(block, rb_intern("call"), 1, self);  }
+    
   return Qtrue;
 }
 
@@ -458,6 +618,8 @@ void init_curb_multi() {
 
   /* 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);