curb 0.4.8.0 → 0.5.1.0

data/ext/curb.h

@@ -20,11 +20,11 @@
 #include "curb_macros.h"
 
 // These should be managed from the Rake 'release' task.
-#define CURB_VERSION   "0.4.8.0"
-#define CURB_VER_NUM   480
+#define CURB_VERSION   "0.5.1.0"
+#define CURB_VER_NUM   510
 #define CURB_VER_MAJ   0
-#define CURB_VER_MIN   4
-#define CURB_VER_MIC   8
+#define CURB_VER_MIN   5
+#define CURB_VER_MIC   1
 #define CURB_VER_PATCH 0
 
 

data/ext/curb_config.h

@@ -1,5 +1,7 @@
 #ifndef CURB_CONFIG_H
 #define CURB_CONFIG_H
+#define  HAVE_CURL_CONFIG_CA 1
+#define  CURL_CONFIG_CA ""
 #define  HAVE_CURLINFO_REDIRECT_TIME 1
 #define  HAVE_CURLINFO_RESPONSE_CODE 1
 #define  HAVE_CURLINFO_FILETIME 1

data/ext/curb_easy.c

@@ -82,32 +82,6 @@ static size_t read_data_handler(void *ptr,
     return read_bytes;
   }
 
- // PutStream *pstream = (PutStream*)stream;
- // size_t sent_bytes = (size * nmemb);
- // size_t remaining = pstream->len - pstream->offset;
- /*
-
-  // amount remaining is less then the buffer to send  - can send it all
-  if( remaining < sent_bytes ) {
-    memcpy(ptr, pstream->buffer+pstream->offset, remaining);
-    sent_bytes = remaining;
-    pstream->offset += remaining;
-  }
-  else if( remaining > sent_bytes ) { // sent_bytes <= remaining - send what we can fit in the buffer(ptr)
-    memcpy(ptr, pstream->buffer+pstream->offset, sent_bytes);
-    pstream->offset += sent_bytes;
-  }
-  else { // they're equal
-    memcpy(ptr, pstream->buffer+pstream->offset, --sent_bytes);
-    pstream->offset += sent_bytes;
-  }
-  if (sent_bytes == 0) {
-    free(pstream);
-  }
-  */
-
-  //printf("sent_bytes: %ld of %ld\n", sent_bytes, remaining);
-  //return sent_bytes;
 }
 
 static size_t proc_data_handler(char *stream,
@@ -289,16 +263,16 @@ static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
 
   new_curl = Data_Wrap_Struct(klass, curl_easy_mark, curl_easy_free, rbce);
 
-  if (blk != Qnil) {
-    rb_funcall(blk, idCall, 1, new_curl);
-  }
-
   /* set the rbce pointer to the curl handle */
   ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)rbce);
   if (ecode != CURLE_OK) {
     raise_curl_easy_error_exception(ecode);
   }
 
+  if (blk != Qnil) {
+    rb_funcall(blk, idCall, 1, new_curl);
+  }
+
   return new_curl;
 }
 
@@ -731,6 +705,70 @@ static VALUE ruby_curl_easy_post_body_get(VALUE self) {
   CURB_OBJECT_GETTER(ruby_curl_easy, postdata_buffer);
 }
 
+/*
+ * call-seq:
+ *   easy.put_data = data                             => ""
+ * 
+ * Points this Curl::Easy instance to data to be uploaded via PUT.  This
+ * sets the request to a PUT type request - useful if you want to PUT via
+ * a multi handle.
+ */
+static VALUE ruby_curl_easy_put_data_set(VALUE self, VALUE data) {
+  ruby_curl_easy *rbce;
+  CURL *curl;
+  
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+
+  VALUE upload = ruby_curl_upload_new(cCurlUpload);
+  ruby_curl_upload_stream_set(upload,data);
+
+  curl = rbce->curl;
+  rbce->upload = upload; /* keep the upload object alive as long as
+                            the easy handle is active or until the upload
+                            is complete or terminated... */
+
+  curl_easy_setopt(curl, CURLOPT_NOBODY,0);
+  curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
+  curl_easy_setopt(curl, CURLOPT_READFUNCTION, (curl_read_callback)read_data_handler);
+  curl_easy_setopt(curl, CURLOPT_READDATA, rbce);
+
+  /* 
+   * we need to set specific headers for the PUT to work... so
+   * convert the internal headers structure to a HASH if one is set
+   */
+  if (rbce->headers != Qnil) {
+    if (rb_type(rbce->headers) == T_ARRAY || rb_type(rbce->headers) == T_STRING) {
+      rb_raise(rb_eRuntimeError, "Must set headers as a HASH to modify the headers in an PUT request");
+    }
+  }
+
+  if (rb_respond_to(data, rb_intern("read"))) {
+    VALUE stat = rb_funcall(data, rb_intern("stat"), 0);
+    if( stat ) {
+      if( rb_hash_aref(rbce->headers, rb_str_new2("Expect")) == Qnil ) {
+        rb_hash_aset(rbce->headers, rb_str_new2("Expect"), rb_str_new2(""));
+      }
+      VALUE size = rb_funcall(stat, rb_intern("size"), 0);
+      curl_easy_setopt(curl, CURLOPT_INFILESIZE, FIX2INT(size));
+    }
+    else if( rb_hash_aref(rbce->headers, rb_str_new2("Transfer-Encoding")) == Qnil ) {
+      rb_hash_aset(rbce->headers, rb_str_new2("Transfer-Encoding"), rb_str_new2("chunked"));
+    }
+  }
+  else if (rb_respond_to(data, rb_intern("to_s"))) {
+    curl_easy_setopt(curl, CURLOPT_INFILESIZE, RSTRING_LEN(data));
+    if( rb_hash_aref(rbce->headers, rb_str_new2("Expect")) == Qnil ) {
+      rb_hash_aset(rbce->headers, rb_str_new2("Expect"), rb_str_new2(""));
+    }
+  }
+  else {
+    rb_raise(rb_eRuntimeError, "PUT data must respond to read or to_s");
+  }
+  
+  // if we made it this far, all should be well.
+  return data;
+}
+
 /* ================== IMMED ATTRS ==================*/
 
 /*
@@ -1631,8 +1669,11 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
     }
   }
   if (rbce->cacert != Qnil) {
-    // XXX: This should really be using the output of 'curl-config --ca'
+#ifdef HAVE_CURL_CONFIG_CA
+    curl_easy_setopt(curl, CURLOPT_CAINFO, CURL_CONFIG_CA);
+#else
     curl_easy_setopt(curl, CURLOPT_CAINFO, "/usr/local/share/curl/curl-ca-bundle.crt");
+#endif
   }
   
   /* Set the user-agent string if specified */
@@ -1640,7 +1681,6 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
     curl_easy_setopt(curl, CURLOPT_USERAGENT, StringValuePtr(rbce->useragent));
   }
 
-
   /* Setup HTTP headers if necessary */
   curl_easy_setopt(curl, CURLOPT_HTTPHEADER, NULL);   // XXX: maybe we shouldn't be clearing this?
 
@@ -1667,6 +1707,8 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
  */
 VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce, VALUE bodybuf, VALUE headerbuf, struct curl_slist *headers ) {
 
+  CURL *curl = rbce->curl;
+  
   // Free everything up
   if (headers) {
     curl_slist_free_all(headers);
@@ -1701,6 +1743,15 @@ VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce, VALUE bodybuf, V
   } else {
     rbce->header_data = Qnil;
   }
+  
+  // clean up a PUT request's curl options.
+  if (rbce->upload != Qnil) {
+    rbce->upload = Qnil; // set the upload object to Qnil to let the GC clean up
+    curl_easy_setopt(curl, CURLOPT_UPLOAD, 0);
+    curl_easy_setopt(curl, CURLOPT_READFUNCTION, NULL);
+    curl_easy_setopt(curl, CURLOPT_READDATA, NULL);
+    curl_easy_setopt(curl, CURLOPT_INFILESIZE, 0);
+  }
 
   return Qnil;
 }
@@ -1719,7 +1770,7 @@ static VALUE handle_perform(VALUE self, ruby_curl_easy *rbce) {
 
   VALUE multi = ruby_curl_multi_new(cCurlMulti);
   ruby_curl_multi_add(multi, self);
-  VALUE ret = ruby_curl_multi_perform(multi);
+  VALUE ret = rb_funcall(multi, rb_intern("perform"), 0);
 
   /* check for errors in the easy response and raise exceptions if anything went wrong and their is no on_failure handler */
   if( rbce->last_result != 0 && rbce->failure_proc == Qnil ) {
@@ -1822,9 +1873,7 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
   rb_scan_args(argc, argv, "*", &args_ary);
 
   Data_Get_Struct(self, ruby_curl_easy, rbce);
-  curl = curl_easy_duphandle(rbce->curl);
-  curl_easy_cleanup(rbce->curl);
-  rbce->curl = curl;
+  curl = rbce->curl;
 
   if (rbce->multipart_form_post) {
     VALUE ret;
@@ -1878,7 +1927,10 @@ static VALUE ruby_curl_easy_perform_head(VALUE self) {
 
   curl_easy_setopt(curl, CURLOPT_NOBODY, 1);
 
-  return handle_perform(self,rbce);
+  VALUE ret = handle_perform(self,rbce);
+
+  curl_easy_setopt(curl, CURLOPT_NOBODY, 0);
+  return ret;
 }
 
 /*
@@ -1914,62 +1966,25 @@ static VALUE ruby_curl_easy_set_head_option(VALUE self, VALUE onoff) {
 static VALUE ruby_curl_easy_perform_put(VALUE self, VALUE data) {
   ruby_curl_easy *rbce;
   CURL *curl;
-
+  
   Data_Get_Struct(self, ruby_curl_easy, rbce);
-
-  VALUE upload = ruby_curl_upload_new(cCurlUpload);
-  ruby_curl_upload_stream_set(upload,data);
-
   curl = rbce->curl;
-  rbce->upload = upload; /* keep the upload object alive as long as
-                            the easy handle is active or until the upload
-                            is complete or terminated... */
-
-  curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
-  curl_easy_setopt(curl, CURLOPT_READFUNCTION, (curl_read_callback)read_data_handler);
-  curl_easy_setopt(curl, CURLOPT_READDATA, rbce);
-
-  /* 
-   * we need to set specific headers for the PUT to work... so
-   * convert the internal headers structure to a HASH if one is set
-   */
-  if (rbce->headers != Qnil) {
-    if (rb_type(rbce->headers) == T_ARRAY || rb_type(rbce->headers) == T_STRING) {
-      rb_raise(rb_eRuntimeError, "Must set headers as a HASH to modify the headers in an http_put request");
-    }
-  }
-
-  if (rb_respond_to(data, rb_intern("read"))) {
-    VALUE stat = rb_funcall(data, rb_intern("stat"), 0);
-    if( stat ) {
-      if( rb_hash_aref(rbce->headers, rb_str_new2("Expect")) == Qnil ) {
-        rb_hash_aset(rbce->headers, rb_str_new2("Expect"), rb_str_new2(""));
-      }
-      VALUE size = rb_funcall(stat, rb_intern("size"), 0);
-      curl_easy_setopt(curl, CURLOPT_INFILESIZE, FIX2INT(size));
-    }
-    else if( rb_hash_aref(rbce->headers, rb_str_new2("Transfer-Encoding")) == Qnil ) {
-      rb_hash_aset(rbce->headers, rb_str_new2("Transfer-Encoding"), rb_str_new2("chunked"));
-    }
-  }
-  else if (rb_respond_to(data, rb_intern("to_s"))) {
-    curl_easy_setopt(curl, CURLOPT_INFILESIZE, RSTRING_LEN(data));
-    if( rb_hash_aref(rbce->headers, rb_str_new2("Expect")) == Qnil ) {
-      rb_hash_aset(rbce->headers, rb_str_new2("Expect"), rb_str_new2(""));
-    }
-  }
-  else {
-    rb_raise(rb_eRuntimeError, "PUT data must respond to read or to_s");
-  }
-
-  VALUE ret = handle_perform(self, rbce);
-  /* cleanup  */
-  curl_easy_setopt(curl, CURLOPT_UPLOAD, 0);
-  curl_easy_setopt(curl, CURLOPT_READFUNCTION, NULL);
-  curl_easy_setopt(curl, CURLOPT_READDATA, NULL);
-  curl_easy_setopt(curl, CURLOPT_INFILESIZE, 0);
+  
+  ruby_curl_easy_put_data_set(self, data);
+  
+  return handle_perform(self, rbce);
+}
 
-  return ret;
+/*
+ * call-seq:
+ *   Curl::Easy.http_put(url, data) {|c| ... }
+ *
+ * see easy.http_put
+ */
+static VALUE ruby_curl_easy_class_perform_put(VALUE klass, VALUE url, VALUE data) {
+  VALUE c = ruby_curl_easy_new(1, &url, klass);
+  ruby_curl_easy_perform_put(c, data);
+  return c;
 }
 
 /* =================== DATA FUNCS =============== */
@@ -2531,6 +2546,21 @@ static VALUE ruby_curl_easy_ftp_entry_path_get(VALUE self) {
 #endif
 }
 
+/*
+ * call-seq:
+ *   easy.inspect                                => "#<Curl::Easy http://google.com/>"
+ */
+static VALUE ruby_curl_easy_inspect(VALUE self) {
+  char buf[64];
+  ruby_curl_easy *rbce;
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  // "#<Net::HTTP http://www.google.com/:80 open=false>"
+  snprintf(buf,sizeof(buf),"#<Curl::Easy %s", RSTRING_PTR(rbce->url));
+  size_t r = strlen(buf);
+  buf[r-1] = '>';
+  return rb_str_new(buf,r);
+}
+
 
 /* ================== ESCAPING FUNCS ==============*/
 
@@ -2629,10 +2659,6 @@ static VALUE ruby_curl_easy_class_perform(int argc, VALUE *argv, VALUE klass) {
 static VALUE ruby_curl_easy_class_perform_get(int argc, VALUE *argv, VALUE klass) {
   VALUE c = ruby_curl_easy_new(argc, argv, klass);
 
-  if (rb_block_given_p()) {
-    rb_yield(c);
-  }
-
   ruby_curl_easy_perform_get(c);
   return c;
 }
@@ -2650,10 +2676,6 @@ static VALUE ruby_curl_easy_class_perform_get(int argc, VALUE *argv, VALUE klass
 static VALUE ruby_curl_easy_class_perform_delete(int argc, VALUE *argv, VALUE klass) {
   VALUE c = ruby_curl_easy_new(argc, argv, klass);
 
-  if (rb_block_given_p()) {
-    rb_yield(c);
-  }
-
   ruby_curl_easy_perform_delete(c);
   return c;
 }
@@ -2671,11 +2693,8 @@ static VALUE ruby_curl_easy_class_perform_delete(int argc, VALUE *argv, VALUE kl
 static VALUE ruby_curl_easy_class_perform_head(int argc, VALUE *argv, VALUE klass) {
   VALUE c = ruby_curl_easy_new(argc, argv, klass);
 
-  if (rb_block_given_p()) {
-    rb_yield(c);
-  }
-
   ruby_curl_easy_perform_head(c);
+
   return c;
 }
 
@@ -2731,6 +2750,7 @@ void init_curb_easy() {
   rb_define_singleton_method(cCurlEasy, "http_get", ruby_curl_easy_class_perform_get, -1);
   rb_define_singleton_method(cCurlEasy, "http_post", ruby_curl_easy_class_perform_post, -1);
   rb_define_singleton_method(cCurlEasy, "http_head", ruby_curl_easy_class_perform_head, -1);
+  rb_define_singleton_method(cCurlEasy, "http_put", ruby_curl_easy_class_perform_put, 2);
 
   /* Attributes for config next perform */
   rb_define_method(cCurlEasy, "url=", ruby_curl_easy_url_set, 1);
@@ -2764,6 +2784,7 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "useragent", ruby_curl_easy_useragent_get, 0);
   rb_define_method(cCurlEasy, "post_body=", ruby_curl_easy_post_body_set, 1);
   rb_define_method(cCurlEasy, "post_body", ruby_curl_easy_post_body_get, 0);
+  rb_define_method(cCurlEasy, "put_data=", ruby_curl_easy_put_data_set, 1);
 
   rb_define_method(cCurlEasy, "local_port=", ruby_curl_easy_local_port_set, 1);
   rb_define_method(cCurlEasy, "local_port", ruby_curl_easy_local_port_get, 0);
@@ -2855,6 +2876,7 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "os_errno", ruby_curl_easy_os_errno_get, 0);
   rb_define_method(cCurlEasy, "num_connects", ruby_curl_easy_num_connects_get, 0);
   rb_define_method(cCurlEasy, "ftp_entry_path", ruby_curl_easy_ftp_entry_path_get, 0);
+  rb_define_method(cCurlEasy, "inspect", ruby_curl_easy_inspect, 0);
 
   /* Curl utils */
   rb_define_method(cCurlEasy, "escape", ruby_curl_easy_escape, 1);

data/ext/curb_multi.c

@@ -57,6 +57,11 @@ static void curl_multi_flush_easy(VALUE key, VALUE easy, ruby_curl_multi *rbcm)
   }
 }
 
+static int
+rb_hash_clear_i(VALUE key, VALUE value, VALUE dummy) {
+  return ST_DELETE;
+}
+
 static void curl_multi_free(ruby_curl_multi *rbcm) {
 
   //printf("hash entries: %d\n", RHASH(rbcm->requests)->tbl->num_entries );
@@ -64,7 +69,7 @@ static void curl_multi_free(ruby_curl_multi *rbcm) {
 
     rb_hash_foreach( rbcm->requests, (int (*)())curl_multi_flush_easy, (VALUE)rbcm );
 
-    //rb_hash_clear(rbcm->requests)
+    rb_hash_foreach(rbcm->requests, rb_hash_clear_i, 0); //rb_hash_clear(rbcm->requests);
     rbcm->requests = Qnil;
   }
   curl_multi_cleanup(rbcm->handle);
@@ -296,55 +301,57 @@ static VALUE ruby_curl_multi_cancel(VALUE self) {
   return self;
 }
 
-static void rb_curl_multi_read_info(VALUE self, CURLM *multi_handle) {
-  int msgs_left, result;
-  CURLMsg *msg;
-  CURLcode ecode;
-  CURL *easy_handle;
+static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int result) {
+
+  long response_code = -1;
   ruby_curl_easy *rbce = NULL;
 
-  /* check for finished easy handles and remove from the multi handle */
-  while ((msg = curl_multi_info_read(multi_handle, &msgs_left))) {
+  CURLcode ecode = curl_easy_getinfo(easy_handle, CURLINFO_PRIVATE, (char**)&rbce);
 
-    if (msg->msg != CURLMSG_DONE) {
-      continue;
-    }
+  if (ecode != 0) {
+    raise_curl_easy_error_exception(ecode);
+  }
 
-    easy_handle = msg->easy_handle;
-    result = msg->data.result;
-    if (easy_handle) {
-      ecode = curl_easy_getinfo(easy_handle, CURLINFO_PRIVATE, (char**)&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, rbce->self );
+  rbce->last_result = result; /* save the last easy result code */
 
-      if (rbce->complete_proc != Qnil) {
-        rb_funcall( rbce->complete_proc, idCall, 1, rbce->self );
-      }
+  ruby_curl_multi_remove( self, rbce->self );
+
+  if (rbce->complete_proc != Qnil) {
+    rb_funcall( rbce->complete_proc, idCall, 1, rbce->self );
+  }
 
-      long response_code = -1;
-      curl_easy_getinfo(rbce->curl, CURLINFO_RESPONSE_CODE, &response_code);
+  curl_easy_getinfo(rbce->curl, CURLINFO_RESPONSE_CODE, &response_code);
 
-      if (result != 0) {
-        if (rbce->failure_proc != Qnil) {
-          rb_funcall( rbce->failure_proc, idCall, 2, rbce->self, rb_curl_easy_error(result) );
-        }
-      }
-      else if (rbce->success_proc != Qnil &&
-              ((response_code >= 200 && response_code < 300) || response_code == 0)) {
-        /* NOTE: we allow response_code == 0, in the case the file is being read from disk */
-        rb_funcall( rbce->success_proc, idCall, 1, rbce->self );
-      }
-      else if (rbce->failure_proc != Qnil &&
-              (response_code >= 300 && response_code <= 999)) {
-        rb_funcall( rbce->failure_proc, idCall, 2, rbce->self, rb_curl_easy_error(result) );
-      }
-      rbce->self = Qnil;
+  if (result != 0) {
+    if (rbce->failure_proc != Qnil) {
+      rb_funcall( rbce->failure_proc, idCall, 2, rbce->self, rb_curl_easy_error(result) );
     }
-    else {
-      //printf( "missing easy handle\n" );
+  }
+  else if (rbce->success_proc != Qnil &&
+          ((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, rbce->self );
+  }
+  else if (rbce->failure_proc != Qnil &&
+          (response_code >= 300 && response_code <= 999)) {
+    rb_funcall( rbce->failure_proc, idCall, 2, rbce->self, rb_curl_easy_error(result) );
+  }
+  rbce->self = Qnil;
+}
+
+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);
+      }
     }
   }
 }
@@ -379,17 +386,19 @@ static void rb_curl_multi_run(VALUE self, CURLM *multi_handle, int *still_runnin
  *
  * Run multi handles, looping selecting when data can be transfered
  */
-VALUE ruby_curl_multi_perform(VALUE self) {
+VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
   CURLMcode mcode;
   ruby_curl_multi *rbcm;
   int maxfd, rc;
   fd_set fdread, fdwrite, fdexcep;
 
-  long timeout;
+  long timeout_milliseconds;
   struct timeval tv = {0, 0};
+  VALUE block = Qnil;
+
+  rb_scan_args(argc, argv, "0&", &block);
 
   Data_Get_Struct(self, ruby_curl_multi, rbcm);
-  //rb_gc_mark(self);
 
   rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
 
@@ -406,37 +415,49 @@ VALUE ruby_curl_multi_perform(VALUE self) {
 
 #ifdef HAVE_CURL_MULTI_TIMEOUT
     /* get the curl suggested time out */
-    mcode = curl_multi_timeout(rbcm->handle, &timeout);
+    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 = 1; /* wait a second */
+    timeout_milliseconds = -1;
 #endif
+    //printf("libcurl says wait: %ld ms or %ld s\n", timeout_milliseconds, timeout_milliseconds/1000);
 
-    if (timeout == 0) { /* no delay */
+    if (timeout_milliseconds == 0) { /* no delay */
       rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
       continue;
     }
-    else if (timeout == -1) {
-      timeout = 1; /* wait a second */
+    else if(timeout_milliseconds < 0) {
+      timeout_milliseconds = 500; /* wait half a second, libcurl doesn't know how long to wait */
     }
-
-    if (rb_block_given_p()) {
-      rb_yield(self);
+#ifdef __APPLE_CC__
+    if(timeout_milliseconds > 1000) {
+      timeout_milliseconds = 1000; /* apple libcurl sometimes reports huge timeouts... let's cap it */
     }
+#endif
 
-    tv.tv_sec = timeout / 1000;
-    tv.tv_usec = (timeout * 1000) % 1000000;
+    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);
-    if (rc < 0) {
+    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 (rb_block_given_p()) {
+//        rb_yield(self);
+//      }
+    default: 
+      rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
+      break;
     }
 
-    rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
-
   }
 
   return Qtrue;
@@ -461,5 +482,5 @@ void init_curb_multi() {
   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, "perform", ruby_curl_multi_perform, 0);
+  rb_define_method(cCurlMulti, "perform", ruby_curl_multi_perform, -1);
 }

data/ext/curb_multi.h

@@ -21,7 +21,7 @@ typedef struct {
 extern VALUE cCurlMulti;
 void init_curb_multi();
 VALUE ruby_curl_multi_new(VALUE klass);
-VALUE ruby_curl_multi_perform(VALUE self);
+VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self);
 VALUE ruby_curl_multi_add(VALUE self, VALUE easy);
 VALUE ruby_curl_multi_remove(VALUE self, VALUE easy);
 

data/ext/curb_postfield.c

@@ -143,7 +143,7 @@ void append_to_form(VALUE self,
   }
   
   if (result != 0) {
-    char *reason;
+    const char *reason = NULL;
     
     switch (result) {
       case CURL_FORMADD_MEMORY:

data/ext/extconf.rb

@@ -5,6 +5,9 @@ dir_config('curl')
 if find_executable('curl-config')
   $CFLAGS << " #{`curl-config --cflags`.strip}"
   $LIBS << " #{`curl-config --libs`.strip}"
+  ca_bundle_path=`curl-config --ca`.strip
+  $defs.push( %{-D HAVE_CURL_CONFIG_CA} )
+  $defs.push( %{-D CURL_CONFIG_CA='#{ca_bundle_path.inspect}'} )
 elsif !have_library('curl') or !have_header('curl/curl.h')
   fail <<-EOM
   Can't find libcurl or curl/curl.h

data/tests/bug_curb_easy_blocks_ruby_threads.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), 'helper')
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
 require 'webrick'
 class ::WEBrick::HTTPServer ; def access_log(config, req, res) ; end ; end
 class ::WEBrick::BasicLog ; def log(level, data) ; end ; end

data/tests/bug_instance_post_differs_from_class_post.rb

@@ -23,7 +23,7 @@
 #   instance httppost. This bug is intermittent, but results in an
 #   exception from the first post when it occurs.
 #   
-require File.join(File.dirname(__FILE__), 'helper')
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
 
 class BugTestInstancePostDiffersFromClassPost < Test::Unit::TestCase
   def test_bug

data/tests/helper.rb

@@ -72,7 +72,15 @@ class TestServlet < WEBrick::HTTPServlet::AbstractServlet
   end
 
   def do_POST(req,res)
-    respond_with("POST\n#{req.body}",req,res)
+    if req.body
+      params = {}
+      req.body.split('&').map{|s| k,v=s.split('='); params[k] = v }
+    end
+    if params and params['s'] == '500'
+      res.status = 500
+    else
+      respond_with("POST\n#{req.body}",req,res)
+    end
   end
 
   def do_PUT(req,res)

data/tests/require_last_or_segfault_script.rb

@@ -21,8 +21,8 @@
 #  Aborted
 #  ------------------------------------------------------------------
 #
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'ext'))
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'ext')))
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
 require 'curb'
 require 'uri'
  

data/tests/tc_curl_download.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), 'helper')
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
 
 class TestCurbCurlDownload < Test::Unit::TestCase
   include TestServerMethods 

data/tests/tc_curl_easy.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), 'helper')
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
 
 class TestCurbCurlEasy < Test::Unit::TestCase
   def test_class_perform_01   
@@ -68,6 +68,14 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_match(/^# DO NOT REMOVE THIS COMMENT/, c.body_str)
   end
 
+  # test invalid use of new
+  def test_new_06
+    Curl::Easy.new(TestServlet.url) do|curl|
+      curl.http_post
+      assert_equal "POST\n", curl.body_str
+    end
+  end
+
   def test_escape
     c = Curl::Easy.new
     
@@ -499,6 +507,19 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     curl.http_post
     assert_equal "POST\n", curl.body_str
   end
+
+  def test_post_remote_is_easy_handle
+    # see: http://pastie.org/560852 and
+    # http://groups.google.com/group/curb---ruby-libcurl-bindings/browse_thread/thread/216bb2d9b037f347?hl=en
+    [:post, :get,:head,:delete].each do |method|
+      count = 0
+      curl = Curl::Easy.send("http_#{method}", TestServlet.url) do|c|
+        count += 1
+        assert_equal Curl::Easy, c.class
+      end
+      assert_equal 1, count, "For request method: #{method.to_s.upcase}"
+    end
+  end
   
   def test_post_with_body_remote
     curl = Curl::Easy.new(TestServlet.url)
@@ -555,6 +576,16 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_match /^PUT/, curl.body_str
     assert_match /message$/, curl.body_str
     assert_match /application\/json/, curl.header_str
+  end 
+  
+  def test_put_data
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.put_data = 'message'
+    
+    curl.perform
+    
+    assert_match /^PUT/, curl.body_str
+    assert_match /message$/, curl.body_str
   end
 
   def test_put_remote_file
@@ -564,6 +595,16 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     end
     assert_equal "PUT\n#{File.read(__FILE__)}", curl.body_str
   end
+  
+  def test_put_class_method
+    count = 0
+    curl = Curl::Easy.http_put(TestServlet.url,File.open(__FILE__,'rb')) do|c|
+      count += 1
+      assert_equal Curl::Easy, c.class
+    end
+    assert_equal 1, count
+    assert_equal "PUT\n#{File.read(__FILE__)}", curl.body_str
+  end
 
   # Generate a self-signed cert with
   # openssl req -new -newkey rsa:1024 -days 365 -nodes -x509 \

data/tests/tc_curl_multi.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), 'helper')
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
 
 class TestCurbCurlMulti < Test::Unit::TestCase
   def teardown
@@ -54,6 +54,8 @@ class TestCurbCurlMulti < Test::Unit::TestCase
 
   end
 
+  # NOTE: if this test runs slowly on Mac OSX, it is probably due to the use of a port install curl+ssl+ares install
+  # on my MacBook, this causes curl_easy_init to take nearly 0.01 seconds / * 100 below is 1 second too many!
   def test_n_requests
     n = 100
     m = Curl::Multi.new
@@ -220,6 +222,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     m = nil
   end
 
+  # This tests whether, ruby's GC will trash an out of scope easy handle
   class TestForScope
     attr_reader :buf
 
@@ -299,6 +302,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     Dir[File.dirname(__FILE__) + "/../ext/*.c"].each do|path|
       urls << root_uri + File.basename(path)
     end
+    urls = urls[0..(urls.size/2)] # keep it fast, webrick...
     Curl::Multi.get(urls, {:follow_location => true}, {:pipeline => true}) do|curl|
       assert_equal 200, curl.response_code
     end
@@ -321,6 +325,26 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     end
   end
 
+  def test_mutli_recieves_500
+    m = Curl::Multi.new
+    e = Curl::Easy.new("http://127.0.0.1:9129/methods")
+    failure = false
+    e.post_body = "hello=world&s=500"
+    e.on_failure{|c,r| failure = true }
+    e.on_success{|c| failure = false }
+    m.add(e)
+    m.perform
+    assert failure
+    e2 = Curl::Easy.new(TestServlet.url)
+    e2.post_body = "hello=world"
+    e2.on_failure{|c,r| failure = true }
+    m.add(e2)
+    m.perform
+    failure = false
+    assert !failure
+    assert_equal "POST\nhello=world", e2.body_str
+  end
+
   include TestServerMethods 
 
   def setup

data/tests/tc_curl_postfield.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), 'helper')
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
 
 class TestCurbCurlPostfield < Test::Unit::TestCase
   def test_private_new

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: curb
 version: !ruby/object:Gem::Version 
-  version: 0.4.8.0
+  version: 0.5.1.0
 platform: ruby
 authors: 
 - Ross Bamford
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-21 00:00:00 -04:00
+date: 2009-08-11 00:00:00 -04:00
 default_executable: 
 dependencies: []