curb 0.9.11 → 1.0.5

data/ext/curb_easy.c

@@ -34,7 +34,7 @@ static FILE * rb_io_stdio_file(rb_io_t *fptr) {
 
 /* ================== CURL HANDLER FUNCS ==============*/
 
-static VALUE callback_exception(VALUE unused) {
+static VALUE callback_exception(VALUE unused, VALUE exception) {
   return Qfalse;
 }
 
@@ -268,6 +268,8 @@ void curl_easy_free(ruby_curl_easy *rbce) {
 static void ruby_curl_easy_zero(ruby_curl_easy *rbce) {
   rbce->opts = rb_hash_new();
 
+  memset(rbce->err_buf, 0, sizeof(rbce->err_buf));
+
   rbce->curl_headers = NULL;
   rbce->curl_proxy_headers = NULL;
   rbce->curl_ftp_commands = NULL;
@@ -327,9 +329,9 @@ static VALUE ruby_curl_easy_allocate(VALUE klass) {
 
 /*
  * call-seq:
- *   Curl::Easy.new                                   => #<Curl::Easy...>
- *   Curl::Easy.new(url = nil)                        => #<Curl::Easy...>
- *   Curl::Easy.new(url = nil) { |self| ... }         => #<Curl::Easy...>
+ *   Curl::Easy.new                                   => #<Curl::Easy...>
+ *   Curl::Easy.new(url = nil)                        => #<Curl::Easy...>
+ *   Curl::Easy.new(url = nil) { |self| ... }         => #<Curl::Easy...>
  *
  * Initialize a new Curl::Easy instance, optionally supplying the URL.
  * The block form allows further configuration to be supplied before
@@ -355,8 +357,9 @@ static VALUE ruby_curl_easy_initialize(int argc, VALUE *argv, VALUE self) {
 
   ruby_curl_easy_zero(rbce);
 
-  rb_easy_set("url", url);
+  curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, &rbce->err_buf);
 
+  rb_easy_set("url", url);
 
   /* set the pointer to the curl handle */
   ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)self);
@@ -373,8 +376,8 @@ static VALUE ruby_curl_easy_initialize(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.clone                                       => #&lt;easy clone&gt;
- *   easy.dup                                         => #&lt;easy clone&gt;
+ *   easy.clone                                       => <easy clone>
+ *   easy.dup                                         => <easy clone>
  *
  * Clone this Curl::Easy instance, creating a new instance.
  * This method duplicates the underlying CURL* handle.
@@ -392,6 +395,8 @@ static VALUE ruby_curl_easy_clone(VALUE self) {
   newrbce->curl_ftp_commands = NULL;
   newrbce->curl_resolve = NULL;
 
+  curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, &rbce->err_buf);
+
   return Data_Wrap_Struct(cCurlEasy, curl_easy_mark, curl_easy_free, newrbce);
 }
 
@@ -461,7 +466,9 @@ static VALUE ruby_curl_easy_reset(VALUE self) {
   curl_easy_reset(rbce->curl);
   ruby_curl_easy_zero(rbce);
 
-  /* rest clobbers the private setting, so reset it to self */
+  curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, &rbce->err_buf);
+
+  /* reset clobbers the private setting, so reset it to self */
   ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)self);
   if (ecode != CURLE_OK) {
     raise_curl_easy_error_exception(ecode);
@@ -950,7 +957,7 @@ static VALUE ruby_curl_easy_ftp_commands_set(VALUE self, VALUE ftp_commands) {
 }
 
 /*
- * call-seq
+ * call-seq:
  *   easy.ftp_commands                                => array or nil
  */
 static VALUE ruby_curl_easy_ftp_commands_get(VALUE self) {
@@ -969,7 +976,7 @@ static VALUE ruby_curl_easy_resolve_set(VALUE self, VALUE resolve) {
 }
 
 /*
- * call-seq
+ * call-seq:
  *   easy.resolve                                => array or nil
  */
 static VALUE ruby_curl_easy_resolve_get(VALUE self) {
@@ -1304,7 +1311,7 @@ static VALUE ruby_curl_easy_connect_timeout_set(VALUE self, VALUE connect_timeou
  * Obtain the maximum time in seconds that you allow the connection to the
  * server to take.
  */
-static VALUE ruby_curl_easy_connect_timeout_get(VALUE self, VALUE connect_timeout) {
+static VALUE ruby_curl_easy_connect_timeout_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, connect_timeout, 0);
 }
 
@@ -1330,7 +1337,7 @@ static VALUE ruby_curl_easy_connect_timeout_ms_set(VALUE self, VALUE connect_tim
  * Obtain the maximum time in milliseconds that you allow the connection to the
  * server to take.
  */
-static VALUE ruby_curl_easy_connect_timeout_ms_get(VALUE self, VALUE connect_timeout_ms) {
+static VALUE ruby_curl_easy_connect_timeout_ms_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, connect_timeout_ms, 0);
 }
 
@@ -1353,7 +1360,7 @@ static VALUE ruby_curl_easy_dns_cache_timeout_set(VALUE self, VALUE dns_cache_ti
  *
  * Obtain the dns cache timeout in seconds.
  */
-static VALUE ruby_curl_easy_dns_cache_timeout_get(VALUE self, VALUE dns_cache_timeout) {
+static VALUE ruby_curl_easy_dns_cache_timeout_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, dns_cache_timeout, -1);
 }
 
@@ -1380,7 +1387,7 @@ static VALUE ruby_curl_easy_ftp_response_timeout_set(VALUE self, VALUE ftp_respo
  *
  * Obtain the maximum time that libcurl will wait for FTP command responses.
  */
-static VALUE ruby_curl_easy_ftp_response_timeout_get(VALUE self, VALUE ftp_response_timeout) {
+static VALUE ruby_curl_easy_ftp_response_timeout_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, ftp_response_timeout, 0);
 }
 
@@ -1403,7 +1410,7 @@ static VALUE ruby_curl_easy_low_speed_limit_set(VALUE self, VALUE low_speed_limi
  * Obtain the minimum transfer speed over +low_speed+time+ below which the
  * transfer will be aborted.
  */
-static VALUE ruby_curl_easy_low_speed_limit_get(VALUE self, VALUE low_speed_limit) {
+static VALUE ruby_curl_easy_low_speed_limit_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, low_speed_limit, 0);
 }
 
@@ -1425,7 +1432,7 @@ static VALUE ruby_curl_easy_low_speed_time_set(VALUE self, VALUE low_speed_time)
  * Obtain the time that the transfer should be below +low_speed_limit+ for
  * the library to abort it.
  */
-static VALUE ruby_curl_easy_low_speed_time_get(VALUE self, VALUE low_speed_time) {
+static VALUE ruby_curl_easy_low_speed_time_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, low_speed_time, 0);
 }
 
@@ -1445,7 +1452,7 @@ static VALUE ruby_curl_easy_max_send_speed_large_set(VALUE self, VALUE max_send_
  *
  * Get the maximal sending transfer speed (in bytes per second) 
  */
-static VALUE ruby_curl_easy_max_send_speed_large_get(VALUE self, VALUE max_send_speed_large) {
+static VALUE ruby_curl_easy_max_send_speed_large_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, max_send_speed_large, 0);
 }
 
@@ -1465,7 +1472,7 @@ static VALUE ruby_curl_easy_max_recv_speed_large_set(VALUE self, VALUE max_recv_
  *
  * Get the maximal receiving transfer speed (in bytes per second) 
  */
-static VALUE ruby_curl_easy_max_recv_speed_large_get(VALUE self, VALUE max_recv_speed_large) {
+static VALUE ruby_curl_easy_max_recv_speed_large_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, max_recv_speed_large, 0);
 }
 
@@ -1489,7 +1496,7 @@ static VALUE ruby_curl_easy_username_set(VALUE self, VALUE username) {
  *
  * Get the current username
  */
-static VALUE ruby_curl_easy_username_get(VALUE self, VALUE username) {
+static VALUE ruby_curl_easy_username_get(VALUE self) {
 #if HAVE_CURLOPT_USERNAME
   CURB_OBJECT_HGETTER(ruby_curl_easy, username);
 #else
@@ -1517,7 +1524,7 @@ static VALUE ruby_curl_easy_password_set(VALUE self, VALUE password) {
  *
  * Get the current password
  */
-static VALUE ruby_curl_easy_password_get(VALUE self, VALUE password) {
+static VALUE ruby_curl_easy_password_get(VALUE self) {
 #if HAVE_CURLOPT_PASSWORD
   CURB_OBJECT_HGETTER(ruby_curl_easy, password);
 #else
@@ -1539,6 +1546,7 @@ static VALUE ruby_curl_easy_password_get(VALUE self, VALUE password) {
  *   Curl::CURL_SSLVERSION_TLSv1_0
  *   Curl::CURL_SSLVERSION_TLSv1_1
  *   Curl::CURL_SSLVERSION_TLSv1_2
+ *   Curl::CURL_SSLVERSION_TLSv1_3
  */
 static VALUE ruby_curl_easy_ssl_version_set(VALUE self, VALUE ssl_version) {
   CURB_IMMED_SETTER(ruby_curl_easy, ssl_version, -1);
@@ -1550,7 +1558,7 @@ static VALUE ruby_curl_easy_ssl_version_set(VALUE self, VALUE ssl_version) {
  *
  * Get the version of SSL/TLS that libcurl will attempt to use.
  */
-static VALUE ruby_curl_easy_ssl_version_get(VALUE self, VALUE ssl_version) {
+static VALUE ruby_curl_easy_ssl_version_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, ssl_version, -1);
 }
 
@@ -1571,7 +1579,7 @@ static VALUE ruby_curl_easy_use_ssl_set(VALUE self, VALUE use_ssl) {
  *
  * Get the desired level for using SSL on FTP connections.
  */
-static VALUE ruby_curl_easy_use_ssl_get(VALUE self, VALUE use_ssl) {
+static VALUE ruby_curl_easy_use_ssl_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, use_ssl, -1);
 }
 
@@ -1587,12 +1595,12 @@ static VALUE ruby_curl_easy_ftp_filemethod_set(VALUE self, VALUE ftp_filemethod)
 }
 
 /*
- * call-seq
+ * call-seq:
  *   easy.ftp_filemethod                              => fixnum
  *
  * Get the configuration for how libcurl will reach files on the server.
  */
-static VALUE ruby_curl_easy_ftp_filemethod_get(VALUE self, VALUE ftp_filemethod) {
+static VALUE ruby_curl_easy_ftp_filemethod_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, ftp_filemethod, -1);
 }
 
@@ -1959,7 +1967,7 @@ static VALUE ruby_curl_easy_resolve_mode_set(VALUE self, VALUE resolve_mode) {
 
 /*
  * call-seq:
- *   easy.on_body { |body_data| ... }                 => &lt;old handler&gt;
+ *   easy.on_body { |body_data| ... }                 => <old handler>
  *
  * Assign or remove the +on_body+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1978,7 +1986,7 @@ static VALUE ruby_curl_easy_on_body_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_success { |easy| ... }                   => &lt;old handler&gt;
+ *   easy.on_success { |easy| ... }                   => <old handler>
  *
  * Assign or remove the +on_success+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1993,7 +2001,7 @@ static VALUE ruby_curl_easy_on_success_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_failure {|easy,code| ... }               => &lt;old handler&gt;
+ *   easy.on_failure {|easy,code| ... }               => <old handler>
  *
  * Assign or remove the +on_failure+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -2008,7 +2016,7 @@ static VALUE ruby_curl_easy_on_failure_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *  easy.on_missing {|easy,code| ... }                => &lt;old handler;&gt;
+ *  easy.on_missing {|easy,code| ... }                => <old handler;>
  *
  *  Assign or remove the on_missing handler for this Curl::Easy instance.
  *  To remove a previously-supplied handler, call this method with no attached
@@ -2023,7 +2031,7 @@ static VALUE ruby_curl_easy_on_missing_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *  easy.on_redirect {|easy,code| ... }                => &lt;old handler;&gt;
+ *  easy.on_redirect {|easy,code| ... }                => <old handler;>
  *
  *  Assign or remove the on_redirect handler for this Curl::Easy instance.
  *  To remove a previously-supplied handler, call this method with no attached
@@ -2038,7 +2046,7 @@ static VALUE ruby_curl_easy_on_redirect_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_complete {|easy| ... }                   => &lt;old handler&gt;
+ *   easy.on_complete {|easy| ... }                   => <old handler>
  *
  * Assign or remove the +on_complete+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -2052,7 +2060,7 @@ static VALUE ruby_curl_easy_on_complete_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_header { |header_data| ... }             => &lt;old handler&gt;
+ *   easy.on_header { |header_data| ... }             => <old handler>
  *
  * Assign or remove the +on_header+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -2068,7 +2076,7 @@ static VALUE ruby_curl_easy_on_header_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_progress { |dl_total, dl_now, ul_total, ul_now| ... } => &lt;old handler&gt;
+ *   easy.on_progress { |dl_total, dl_now, ul_total, ul_now| ... } => <old handler>
  *
  * Assign or remove the +on_progress+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -2089,7 +2097,7 @@ static VALUE ruby_curl_easy_on_progress_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_debug { |type, data| ... }               => &lt;old handler&gt;
+ *   easy.on_debug { |type, data| ... }               => <old handler>
  *
  * Assign or remove the +on_debug+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -2114,7 +2122,7 @@ static VALUE ruby_curl_easy_on_debug_set(int argc, VALUE *argv, VALUE self) {
 /***********************************************
  * This is an rb_iterate callback used to set up http headers.
  */
-static VALUE cb_each_http_header(VALUE header, VALUE wrap) {
+static VALUE cb_each_http_header(VALUE header, VALUE wrap, int _c, const VALUE *_ptr, VALUE unused) {
   struct curl_slist **list;
   VALUE header_str = Qnil;
 
@@ -2128,11 +2136,14 @@ static VALUE cb_each_http_header(VALUE header, VALUE wrap) {
 
     name = rb_obj_as_string(rb_ary_entry(header, 0));
     value = rb_obj_as_string(rb_ary_entry(header, 1));
-
-    // This is a bit inefficient, but we don't want to be modifying
-    // the actual values in the original hash.
-    header_str = rb_str_plus(name, rb_str_new2(": "));
-    header_str = rb_str_plus(header_str, value);
+    if (rb_str_strlen(value) == 0) { // removing the header e.g. Accept: with nothing trailing should remove it see: https://curl.se/libcurl/c/CURLOPT_HTTPHEADER.html
+      header_str = rb_str_plus(name, rb_str_new2(":"));
+    } else {
+      // This is a bit inefficient, but we don't want to be modifying
+      // the actual values in the original hash.
+      header_str = rb_str_plus(name, rb_str_new2(": "));
+      header_str = rb_str_plus(header_str, value);
+    }
   } else {
     header_str = rb_obj_as_string(header);
   }
@@ -2146,7 +2157,7 @@ static VALUE cb_each_http_header(VALUE header, VALUE wrap) {
 /***********************************************
  * This is an rb_iterate callback used to set up http proxy headers.
  */
-static VALUE cb_each_http_proxy_header(VALUE proxy_header, VALUE wrap) {
+static VALUE cb_each_http_proxy_header(VALUE proxy_header, VALUE wrap, int _c, const VALUE *_ptr, VALUE unused) {
   struct curl_slist **list;
   VALUE proxy_header_str = Qnil;
 
@@ -2178,7 +2189,7 @@ static VALUE cb_each_http_proxy_header(VALUE proxy_header, VALUE wrap) {
 /***********************************************
  * This is an rb_iterate callback used to set up ftp commands.
  */
-static VALUE cb_each_ftp_command(VALUE ftp_command, VALUE wrap) {
+static VALUE cb_each_ftp_command(VALUE ftp_command, VALUE wrap, int _c, const VALUE *_ptr, VALUE unused) {
   struct curl_slist **list;
   VALUE ftp_command_string;
   Data_Get_Struct(wrap, struct curl_slist *, list);
@@ -2192,7 +2203,7 @@ static VALUE cb_each_ftp_command(VALUE ftp_command, VALUE wrap) {
 /***********************************************
  * This is an rb_iterate callback used to set up the resolve list.
  */
-static VALUE cb_each_resolve(VALUE resolve, VALUE wrap) {
+static VALUE cb_each_resolve(VALUE resolve, VALUE wrap, int _c, const VALUE *_ptr, VALUE unused) {
   struct curl_slist **list;
   VALUE resolve_string;
   Data_Get_Struct(wrap, struct curl_slist *, list);
@@ -2591,7 +2602,7 @@ VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce ) {
   }
 
   // set values on cleanup to nil
-  rb_easy_del("multi");
+  //rb_easy_del("multi");
 
   return Qnil;
 }
@@ -2607,6 +2618,8 @@ static VALUE ruby_curl_easy_perform_verb_str(VALUE self, const char *verb) {
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl = rbce->curl;
 
+  memset(rbce->err_buf, 0, sizeof(rbce->err_buf));
+
   curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, verb);
 
   retval = rb_funcall(self, rb_intern("perform"), 0);
@@ -2672,6 +2685,8 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl = rbce->curl;
 
+  memset(rbce->err_buf, 0, sizeof(rbce->err_buf));
+
   curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, NULL);
 
   if (rbce->multipart_form_post) {
@@ -2743,6 +2758,8 @@ static VALUE ruby_curl_easy_perform_put(VALUE self, VALUE data) {
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl = rbce->curl;
 
+  memset(rbce->err_buf, 0, sizeof(rbce->err_buf));
+
   curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, NULL);
   ruby_curl_easy_put_data_set(self, data);
 
@@ -2761,6 +2778,10 @@ static VALUE ruby_curl_easy_perform_put(VALUE self, VALUE data) {
  * your own body handler, this string will be empty.
  */
 static VALUE ruby_curl_easy_body_str_get(VALUE self) {
+  /*
+     TODO: can we force_encoding on the return here if we see charset=utf-8 in the content-type header?
+     Content-Type: application/json; charset=utf-8
+  */
   CURB_OBJECT_HGETTER(ruby_curl_easy, body_data);
 }
 
@@ -2955,7 +2976,7 @@ static VALUE ruby_curl_easy_connect_time_get(VALUE self) {
  * Retrieve the time, in seconds, it took from the start until the SSL/SSH
  * connect/handshake to the remote host was completed. This time is most often
  * very near to the pre transfer time, except for cases such as HTTP
- * pippelining where the pretransfer time can be delayed due to waits in line
+ * pipelining where the pretransfer time can be delayed due to waits in line
  * for the pipeline and more.
  */
 #if defined(HAVE_CURLINFO_APPCONNECT_TIME)
@@ -3448,6 +3469,21 @@ static VALUE ruby_curl_easy_last_result(VALUE self) {
   return LONG2NUM(rbce->last_result);
 }
 
+/*
+ * call-seq:
+ *   easy.last_error                                     => "Error details" or nil
+ */
+static VALUE ruby_curl_easy_last_error(VALUE self) {
+  ruby_curl_easy *rbce;
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+
+  if (rbce->err_buf[0]) {    // curl returns NULL or empty string if none
+    return rb_str_new2(rbce->err_buf);
+  } else {
+    return Qnil;
+  }
+}
+
 /*
  * call-seq:
  *   easy.setopt Fixnum, value  => value
@@ -3546,6 +3582,9 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
   case CURLOPT_TCP_NODELAY: {
     curl_easy_setopt(rbce->curl, CURLOPT_TCP_NODELAY, NUM2LONG(val));
     } break;
+  case CURLOPT_RANGE: {
+    curl_easy_setopt(rbce->curl, CURLOPT_RANGE, StringValueCStr(val));
+    } break;
   case CURLOPT_RESUME_FROM: {
     curl_easy_setopt(rbce->curl, CURLOPT_RESUME_FROM, NUM2LONG(val));
     } break;
@@ -3606,6 +3645,20 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
     GetOpenFile(val, open_f_ptr);
     curl_easy_setopt(rbce->curl, CURLOPT_STDERR, rb_io_stdio_file(open_f_ptr));
     break;
+  case CURLOPT_PROTOCOLS:
+  case CURLOPT_REDIR_PROTOCOLS:
+    curl_easy_setopt(rbce->curl, option, NUM2LONG(val));
+    break;
+#if HAVE_CURLOPT_SSL_SESSIONID_CACHE
+  case CURLOPT_SSL_SESSIONID_CACHE:
+    curl_easy_setopt(rbce->curl, CURLOPT_SSL_SESSIONID_CACHE, NUM2LONG(val));
+    break;
+#endif
+#if HAVE_CURLOPT_PROXY_SSL_VERIFYHOST
+  case CURLOPT_PROXY_SSL_VERIFYHOST:
+    curl_easy_setopt(rbce->curl, CURLOPT_PROXY_SSL_VERIFYHOST, NUM2LONG(val));
+    break;
+#endif
   default:
     rb_raise(rb_eTypeError, "Curb unsupported option");
   }
@@ -3722,6 +3775,7 @@ static VALUE ruby_curl_easy_error_message(VALUE klass, VALUE code) {
 }
 
 /* =================== INIT LIB =====================*/
+// TODO: https://bugs.ruby-lang.org/issues/18007
 void init_curb_easy() {
   idCall = rb_intern("call");
   idJoin = rb_intern("join");
@@ -3867,6 +3921,7 @@ void init_curb_easy() {
 
   rb_define_method(cCurlEasy, "last_effective_url", ruby_curl_easy_last_effective_url_get, 0);
   rb_define_method(cCurlEasy, "response_code", ruby_curl_easy_response_code_get, 0);
+  rb_define_method(cCurlEasy, "code", ruby_curl_easy_response_code_get, 0);
 #if defined(HAVE_CURLINFO_PRIMARY_IP)
   rb_define_method(cCurlEasy, "primary_ip", ruby_curl_easy_primary_ip_get, 0);
 #endif
@@ -3913,6 +3968,7 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "multi", ruby_curl_easy_multi_get, 0);
   rb_define_method(cCurlEasy, "multi=", ruby_curl_easy_multi_set, 1);
   rb_define_method(cCurlEasy, "last_result", ruby_curl_easy_last_result, 0);
+  rb_define_method(cCurlEasy, "last_error", ruby_curl_easy_last_error, 0);
 
   rb_define_method(cCurlEasy, "setopt", ruby_curl_easy_set_opt, 2);
   rb_define_method(cCurlEasy, "getinfo", ruby_curl_easy_get_opt, 1);

data/ext/curb_easy.h

@@ -36,6 +36,9 @@ typedef struct {
   /* The handler */
   CURL *curl;
 
+  /* Buffer for error details from CURLOPT_ERRORBUFFER */
+  char err_buf[CURL_ERROR_SIZE];
+
   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 */
 

data/ext/curb_macros.h

@@ -156,4 +156,16 @@
 #define CURB_DEFINE(name) \
   rb_define_const(mCurl, #name, LONG2NUM(name))
 
+/* copy and raise exception */
+#define CURB_CHECK_RB_CALLBACK_RAISE(did_raise) \
+  VALUE exception = rb_hash_aref(did_raise, rb_easy_hkey("error")); \
+  if (FIX2INT(rb_hash_size(did_raise)) > 0 && exception != Qnil) { \
+    rb_hash_clear(did_raise); \
+    VALUE message   = rb_funcall(exception, rb_intern("message"), 0); \
+    VALUE aborted_exception = rb_exc_new_str(eCurlErrAbortedByCallback, message); \
+    VALUE backtrace = rb_funcall(exception, rb_intern("backtrace"), 0); \
+    rb_funcall(aborted_exception,  rb_intern("set_backtrace"), 1, backtrace); \
+    rb_exc_raise(aborted_exception); \
+  }
+
 #endif

data/ext/curb_multi.c

@@ -43,8 +43,25 @@ 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 VALUE callback_exception(VALUE unused) {
-  return Qfalse;
+static VALUE callback_exception(VALUE did_raise, VALUE exception) {
+  // TODO: we could have an option to enable exception reporting
+/*  VALUE ret = rb_funcall(exception, rb_intern("message"), 0);
+  VALUE trace = rb_funcall(exception, rb_intern("backtrace"), 0);
+  if (RB_TYPE_P(trace, T_ARRAY) && RARRAY_LEN(trace) > 0) {
+    printf("we got an exception: %s:%d\n", StringValueCStr(ret), RARRAY_LEN(trace));
+    VALUE sep = rb_str_new_cstr("\n");
+    VALUE trace_lines = rb_ary_join(trace, sep);
+    if (RB_TYPE_P(trace_lines, T_STRING)) {
+      printf("%s\n", StringValueCStr(trace_lines));
+    } else {
+      printf("trace is not a string??\n");
+    }
+  } else {
+    printf("we got an exception: %s\nno stack available\n", StringValueCStr(ret));
+  }
+  */
+  rb_hash_aset(did_raise, rb_easy_hkey("error"), exception);
+  return exception;
 }
 
 void curl_multi_free(ruby_curl_multi *rbcm) {
@@ -64,7 +81,7 @@ static void ruby_curl_multi_init(ruby_curl_multi *rbcm) {
 
 /*
  * call-seq:
- *   Curl::Multi.new                                   => #<Curl::Easy...>
+ *   Curl::Multi.new                                   => #<Curl::Easy...>
  *
  * Create a new Curl::Multi instance
  */
@@ -132,7 +149,7 @@ VALUE ruby_curl_multi_get_autoclose(VALUE klass) {
 
 /*
  * call-seq:
- *   multi.requests                                   => [#&lt;Curl::Easy...&gt;, ...]
+ *   multi.requests                                   => [#<Curl::Easy...>, ...]
  * 
  * Returns an array containing all the active requests on this Curl::Multi object.
  */
@@ -274,7 +291,7 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
   long response_code = -1;
   VALUE easy;
   ruby_curl_easy *rbce = NULL;
-  VALUE callargs, val = Qtrue;
+  VALUE callargs;
 
   CURLcode ecode = curl_easy_getinfo(easy_handle, CURLINFO_PRIVATE, (char**)&easy);
 
@@ -295,55 +312,62 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
     raise_curl_easy_error_exception(ecode);
   }
 
+  VALUE did_raise = rb_hash_new();
+
   if (!rb_easy_nil("complete_proc")) {
     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);
+    rb_rescue(call_status_handler1, callargs, callback_exception, did_raise);
     rbce->callback_active = 0;
-    //rb_funcall( rb_easy_get("complete_proc"), idCall, 1, easy );
+    CURB_CHECK_RB_CALLBACK_RAISE(did_raise);
   }
 
+#ifdef HAVE_CURLINFO_RESPONSE_CODE
   curl_easy_getinfo(rbce->curl, CURLINFO_RESPONSE_CODE, &response_code);
+#else
+  // old libcurl
+  curl_easy_getinfo(rbce->curl, CURLINFO_HTTP_CODE, &response_code);
+#endif
+  long redirect_count;
+  curl_easy_getinfo(rbce->curl, CURLINFO_REDIRECT_COUNT, &redirect_count);
 
   if (result != 0) {
     if (!rb_easy_nil("failure_proc")) {
       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);
+      rb_rescue(call_status_handler2, callargs, callback_exception, did_raise);
       rbce->callback_active = 0;
-      //rb_funcall( rb_easy_get("failure_proc"), idCall, 2, easy, rb_curl_easy_error(result) );
+      CURB_CHECK_RB_CALLBACK_RAISE(did_raise);
     }
-  }
-  else if (!rb_easy_nil("success_proc") &&
+  } 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 */
     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);
+    rb_rescue(call_status_handler1, callargs, callback_exception, did_raise);
     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)) {
+    CURB_CHECK_RB_CALLBACK_RAISE(did_raise);
+
+  } else if (!rb_easy_nil("redirect_proc") && ((response_code >= 300 && response_code < 400) || redirect_count > 0) ) {
     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") &&
+    rb_rescue(call_status_handler2, callargs, callback_exception, did_raise);
+    CURB_CHECK_RB_CALLBACK_RAISE(did_raise);
+  } 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") &&
+    rb_rescue(call_status_handler2, callargs, callback_exception, did_raise);
+    CURB_CHECK_RB_CALLBACK_RAISE(did_raise);
+  } else if (!rb_easy_nil("failure_proc") &&
           (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);
+    rb_rescue(call_status_handler2, callargs, callback_exception, did_raise);
     rbce->callback_active = 0;
-    //rb_funcall( rb_easy_get("failure_proc"), idCall, 2, easy, rb_curl_easy_error(result) );
+    CURB_CHECK_RB_CALLBACK_RAISE(did_raise);
   }
 
 }
@@ -627,6 +651,8 @@ void init_curb_multi() {
   idCall = rb_intern("call");
   cCurlMulti = rb_define_class_under(mCurl, "Multi", rb_cObject);
 
+  rb_undef_alloc_func(cCurlMulti);
+
   /* 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);