curb 0.5.8.0-x86-linux → 0.7.7-x86-linux

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.
  */
@@ -18,33 +36,8 @@ typedef struct {
   /* The handler */
   CURL *curl;
 
-  /* Objects we associate */
-  VALUE url;
-  VALUE proxy_url;
-
-  VALUE body_proc;
-  VALUE header_proc;
-  VALUE body_data;      /* Holds the response body from the last call to curl_easy_perform */
-  VALUE header_data;    /* unless a block is supplied (they'll be nil)      */
-  VALUE progress_proc;
-  VALUE debug_proc;
-  VALUE interface_hm;
-  VALUE userpwd;
-  VALUE proxypwd;
-  VALUE headers;        /* ruby array of strings with headers to set */
-  VALUE cookies;        /* string */
-  VALUE cookiefile;     /* filename */
-  VALUE cookiejar;      /* filename */
-  VALUE cert;
-  VALUE cacert;
-  VALUE certpassword;
-  VALUE certtype;
-  VALUE encoding;
-  VALUE useragent;
-
-  VALUE success_proc;
-  VALUE failure_proc;
-  VALUE complete_proc;
+  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
@@ -58,6 +51,9 @@ typedef struct {
   unsigned long connect_timeout;
   long dns_cache_timeout;
   unsigned long ftp_response_timeout;
+  long ssl_version;
+  long use_ssl;
+  long ftp_filemethod;
 
   /* bool flags */
   char proxy_tunnel;
@@ -71,23 +67,8 @@ typedef struct {
   char verbose;
   char multipart_form_post;
   char enable_cookies;
-
-  /* this is sometimes used as a buffer for a form data string,
-   * which we alloc in C and need to hang around for the call,
-   * and in case it's asked for before the next call.
-   */
-  VALUE postdata_buffer;
-
-  /* when added to a multi handle these buffers are needed
-   * when the easy handle isn't supplied the body proc
-   * or a custom http header is passed.
-   */
-  VALUE bodybuf;
-  VALUE headerbuf;
   struct curl_slist *curl_headers;
-
-  VALUE self; /* pointer to self, used by multi interface */
-  VALUE upload; /* pointer to an active upload otherwise Qnil */
+  struct curl_slist *curl_ftp_commands;
 
   int last_result; /* last result code from multi loop */
 
@@ -95,8 +76,8 @@ typedef struct {
 
 extern VALUE cCurlEasy;
 
-VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce, VALUE *bodybuf, VALUE *headerbuf, struct curl_slist **headers);
-VALUE ruby_curl_easy_cleanup(VALUE self, ruby_curl_easy *rbce, VALUE bodybuf, VALUE headerbuf, 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

@@ -23,6 +23,7 @@ VALUE eCurlErrTelnetError;
 VALUE eCurlErrTFTPError;
 
 /* Specific libcurl errors */
+VALUE eCurlErrOK; /* not really an error but a return code */
 VALUE eCurlErrUnsupportedProtocol;
 VALUE eCurlErrFailedInit;
 VALUE eCurlErrMalformedURL;
@@ -109,6 +110,7 @@ VALUE eCurlErrSSLCRLBadfile;
 VALUE eCurlErrSSLIssuerError;
 
 /* multi errors */
+VALUE mCurlErrFailedInit;
 VALUE mCurlErrCallMultiPerform;
 VALUE mCurlErrBadHandle;
 VALUE mCurlErrBadEasyHandle;
@@ -127,6 +129,9 @@ VALUE rb_curl_easy_error(CURLcode code) {
   VALUE results;
 
   switch (code) {
+    case CURLE_OK:                      /* 0 */
+      exclz = eCurlErrOK;
+      break;
     case CURLE_UNSUPPORTED_PROTOCOL:    /* 1 */
       exclz = eCurlErrUnsupportedProtocol;
       break;
@@ -509,6 +514,7 @@ void init_curb_errors() {
   eCurlErrTelnetError = rb_define_class_under(mCurlErr, "TelnetError", eCurlErrError);
   eCurlErrTFTPError = rb_define_class_under(mCurlErr, "TFTPError", eCurlErrError);
 
+  eCurlErrOK = rb_define_class_under(mCurlErr, "CurlOK", eCurlErrError);
   eCurlErrUnsupportedProtocol = rb_define_class_under(mCurlErr, "UnsupportedProtocolError", eCurlErrError);
   eCurlErrFailedInit = rb_define_class_under(mCurlErr, "FailedInitError", eCurlErrError);
   eCurlErrMalformedURL = rb_define_class_under(mCurlErr, "MalformedURLError", eCurlErrError);
@@ -600,6 +606,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,17 @@
 #ifndef __CURB_MACROS_H
 #define __CURB_MACROS_H
 
+#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))
+#define rb_easy_del(key) rb_hash_delete(rbce->opts, rb_easy_hkey(key))
+#define rb_easy_nil(key) (rb_hash_aref(rbce->opts, rb_easy_hkey(key)) == Qnil)
+#define rb_easy_type_check(key,type) (rb_type(rb_hash_aref(rbce->opts, rb_easy_hkey(key))) == type)
+
+// TODO: rb_sym_to_s may not be defined?
+#define rb_easy_get_str(key) \
+  RSTRING_PTR((rb_easy_type_check(key,T_STRING) ? rb_easy_get(key) : rb_str_to_str(rb_easy_get(key))))
+
 /* getter/setter macros for various things */
 /* setter for anything that stores a ruby VALUE in the struct */
 #define CURB_OBJECT_SETTER(type, attr)                              \
@@ -25,6 +36,22 @@
             Data_Get_Struct(self, type, ptr);                       \
             return ptr->attr; 
 
+/* setter for anything that stores a ruby VALUE in the struct opts hash */
+#define CURB_OBJECT_HSETTER(type, attr)                             \
+            type *ptr;                                              \
+                                                                    \
+            Data_Get_Struct(self, type, ptr);                       \
+            rb_hash_aset(ptr->opts, rb_easy_hkey(#attr), attr);       \
+                                                                    \
+            return attr;
+
+/* getter for anything that stores a ruby VALUE in the struct opts hash */
+#define CURB_OBJECT_HGETTER(type, attr)                              \
+            type *ptr;                                              \
+                                                                    \
+            Data_Get_Struct(self, type, ptr);                       \
+            return rb_hash_aref(ptr->opts, rb_easy_hkey(#attr)); 
+
 /* setter for bool flags */
 #define CURB_BOOLEAN_SETTER(type, attr)                             \
             type *ptr;                                              \
@@ -57,6 +84,20 @@
                                                                     \
             return oldproc;                                         \
 
+/* special setter for on_event handlers that take a block, same as above but stores int he opts hash */
+#define CURB_HANDLER_PROC_HSETTER(type, handler)                        \
+            type *ptr;                                                  \
+            VALUE oldproc, newproc;                                     \
+                                                                        \
+            Data_Get_Struct(self, type, ptr);                           \
+                                                                        \
+            oldproc = rb_hash_aref(ptr->opts, rb_easy_hkey(#handler));   \
+            rb_scan_args(argc, argv, "0&", &newproc);                   \
+                                                                        \
+            rb_hash_aset(ptr->opts, rb_easy_hkey(#handler), newproc);    \
+                                                                        \
+            return oldproc;
+
 /* setter for numerics that are kept in c ints */
 #define CURB_IMMED_SETTER(type, attr, nilval)                       \
             type *ptr;                                              \

data/ext/curb_multi.c

@@ -28,11 +28,13 @@ 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) {
-  //printf( "mark easy: 0x%X\n", (long)rbeasy );
   rb_gc_mark(rbeasy);
 }
 
@@ -42,20 +44,14 @@ static void curl_multi_mark(ruby_curl_multi *rbcm) {
 }
 
 static void curl_multi_flush_easy(VALUE key, VALUE easy, ruby_curl_multi *rbcm) {
-  //rb_curl_multi_remove(rbcm, 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);
   }
-  // XXX: easy handle may not be finished yet... so don't clean it GC pass will get it next time
-  r = rb_hash_delete( rbcm->requests, easy );
-  if( r != easy || r == Qnil ) {
-    rb_raise(rb_eRuntimeError, "Critical:: Unable to remove easy from requests");
-  }
 }
 
 static int
@@ -65,7 +61,6 @@ rb_hash_clear_i(VALUE key, VALUE value, VALUE dummy) {
 
 static void curl_multi_free(ruby_curl_multi *rbcm) {
 
-  //printf("hash entries: %d\n", RHASH(rbcm->requests)->tbl->num_entries );
   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 );
@@ -89,6 +84,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();
 
@@ -100,7 +98,31 @@ VALUE ruby_curl_multi_new(VALUE klass) {
   return new_curlm;
 }
 
-// Hash#foreach callback for ruby_curl_multi_requests
+/*
+ * 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);
   
@@ -121,8 +143,8 @@ static VALUE ruby_curl_multi_requests(VALUE self) {
   
   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 );
+  /* 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;
 }
@@ -202,17 +224,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);
   }
 
-  /* save a pointer to self */
-  rbce->self = easy;
-
-  /* setup the easy handle */
-  ruby_curl_easy_setup( rbce, &(rbce->bodybuf), &(rbce->headerbuf), &(rbce->curl_headers) );
-
   rbcm->active++;
 
   /* Increase the running count, so that the perform loop keeps running.
@@ -221,6 +240,8 @@ VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
 
   rb_hash_aset( rbcm->requests, easy, easy );
 
+  rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
+
   return self;
 }
 
@@ -264,18 +285,16 @@ static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy) {
 
   rbcm->active--;
 
-  ruby_curl_easy_cleanup( easy, rbce, rbce->bodybuf, rbce->headerbuf, rbce->curl_headers );
-  rbce->headerbuf = Qnil;
-  rbce->bodybuf = Qnil;
+  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_raise(rb_eRuntimeError, "Critical:: Unable to remove easy from requests");
+    rb_warn("Possibly lost track of Curl::Easy VALUE, it may not be reclaimed by GC");
   }
 }
 
-// Hash#foreach callback for ruby_curl_multi_cancel
+/* 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);
   
@@ -295,48 +314,47 @@ static VALUE ruby_curl_multi_cancel(VALUE self) {
   
   rb_hash_foreach( rbcm->requests, ruby_curl_multi_cancel_callback, (VALUE)rbcm );
   
-  // for chaining
+  /* for chaining */
   return self;
 }
 
 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 ref;
-  CURLcode ecode = curl_easy_getinfo(easy_handle, CURLINFO_PRIVATE, (char**)&rbce);
 
-  if (ecode != 0) {
-    raise_curl_easy_error_exception(ecode);
-  }
+  CURLcode ecode = curl_easy_getinfo(easy_handle, CURLINFO_PRIVATE, (char**)&easy);
+
+  Data_Get_Struct(easy, ruby_curl_easy, rbce);
 
   rbce->last_result = result; /* save the last easy result code */
 
-  ruby_curl_multi_remove( self, rbce->self );
+  ruby_curl_multi_remove( self, easy );
+
+  if (ecode != 0) {
+    raise_curl_easy_error_exception(ecode);
+  }
 
-  if (rbce->complete_proc != Qnil) {
-    rb_funcall( rbce->complete_proc, idCall, 1, rbce->self );
+  if (!rb_easy_nil("complete_proc")) {
+    rb_funcall( rb_easy_get("complete_proc"), idCall, 1, easy );
   }
 
   curl_easy_getinfo(rbce->curl, CURLINFO_RESPONSE_CODE, &response_code);
 
-  ref = rbce->self;
-  /* break reference */
-  rbce->self = Qnil;
-
   if (result != 0) {
-    if (rbce->failure_proc != Qnil) {
-      rb_funcall( rbce->failure_proc, idCall, 2, ref, rb_curl_easy_error(result) );
+    if (!rb_easy_nil("failure_proc")) {
+      rb_funcall( rb_easy_get("failure_proc"), idCall, 2, easy, rb_curl_easy_error(result) );
     }
   }
-  else if (rbce->success_proc != Qnil &&
+  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( rbce->success_proc, idCall, 1, ref );
+    rb_funcall( rb_easy_get("success_proc"), idCall, 1, easy );
   }
-  else if (rbce->failure_proc != Qnil &&
+  else if (!rb_easy_nil("failure_proc") &&
           (response_code >= 300 && response_code <= 999)) {
-    rb_funcall( rbce->failure_proc, idCall, 2, ref, rb_curl_easy_error(result) );
+    rb_funcall( rb_easy_get("failure_proc"), idCall, 2, easy, rb_curl_easy_error(result) );
   }
 }
 
@@ -368,8 +386,7 @@ static void rb_curl_multi_run(VALUE self, CURLM *multi_handle, int *still_runnin
   if (mcode != CURLM_OK) {
     raise_curl_multi_error_exception(mcode);
   }
-
-  rb_curl_multi_read_info( self, multi_handle );
+  
 }
 
 /*
@@ -401,66 +418,72 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
 
   Data_Get_Struct(self, ruby_curl_multi, rbcm);
 
-  rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
-
-  while(rbcm->running) {
-    FD_ZERO(&fdread);
-    FD_ZERO(&fdwrite);
-    FD_ZERO(&fdexcep);
+  timeout_milliseconds = cCurlMutiDefaulttimeout;
 
-    /* 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);
-    }
+  rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
+ 
+  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);
-    }
+      /* 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... make a wild guess */
-    timeout_milliseconds = -1;
+      /* libcurl doesn't have a timeout method defined, initialize to -1 we'll pick up the default later */
+      timeout_milliseconds = -1;
 #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 */
-    }
-#endif
+      if (timeout_milliseconds == 0) { /* no delay */
+        rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
+        continue;
+      }
+      else if (timeout_milliseconds < 0) {
+        timeout_milliseconds = cCurlMutiDefaulttimeout; /* libcurl doesn't know how long to wait, use a default timeout */
+      }
 
-    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); 
+      if (timeout_milliseconds > cCurlMutiDefaulttimeout) {
+        timeout_milliseconds = cCurlMutiDefaulttimeout; /* buggy versions libcurl sometimes reports huge timeouts... let's cap it */
       }
-//      if (rb_block_given_p()) {
-//        rb_yield(self);
-//      }
-    default: 
-      rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
-      break;
-    }
 
-  }
+      tv.tv_sec  = 0; /* never wait longer than 1 second */
+      tv.tv_usec = timeout_milliseconds * 1000;
 
+      if (timeout_milliseconds == 0) { /* no delay */
+        rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
+        continue;
+      }
+
+      if (block != Qnil) { rb_funcall(block, rb_intern("call"), 1, self);  }
+
+      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);
+      }
+
+      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:
+        rb_curl_multi_read_info( self, rbcm->handle );
+        if (block != Qnil) { rb_funcall(block, rb_intern("call"), 1, self);  }
+      default: 
+        rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
+        break;
+      }
+    }
+    rb_curl_multi_read_info( self, rbcm->handle );
+    if (block != Qnil) { rb_funcall(block, rb_intern("call"), 1, self);  }
+  } while( rbcm->running );
+    
   return Qtrue;
 }
 
@@ -472,6 +495,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);