patron 0.13.4 → 0.14.0

data/ext/patron/session_ext.c

@@ -24,12 +24,15 @@ static VALUE ePartialFileError = Qnil;
 static VALUE eTimeoutError = Qnil;
 static VALUE eTooManyRedirects = Qnil;
 static VALUE eAborted = Qnil;
+static VALUE eClientCertificateError = Qnil;
 
 struct patron_curl_state {
   CURL* handle;
   CURL* base_handle;
   CURLSH* share;
-  char* upload_buf;
+  /* The String libcurl reads the request body from. CURLOPT_POSTFIELDS does not copy,
+     so the String has to stay alive (and marked) until cleanup() */
+  VALUE upload_data;
   FILE* download_file;
   FILE* debug_file;
   FILE* request_body_file;
@@ -39,13 +42,21 @@ struct patron_curl_state {
   struct curl_httppost* last;
   membuffer header_buffer;
   membuffer body_buffer;
-  size_t download_byte_limit;
+  curl_off_t download_byte_limit;
   VALUE user_progress_blk;
+  /* A non-local exit (raise, Thread#raise, Thread#kill...) from the progress proc can't
+     unwind through libcurl's frames, so it is parked here and resumed after perform() */
+  int pending_tag;
+  VALUE pending_exception;
+  /* Set while a request is in flight. There is one handle and one set of buffers per
+     Session, and the transfer runs without the GVL, so a second thread entering
+     handle_request would corrupt the first one's request */
+  volatile int busy;
   int interrupt;
-  size_t dltotal;
-  size_t dlnow;
-  size_t ultotal;
-  size_t ulnow;
+  curl_off_t dltotal;
+  curl_off_t dlnow;
+  curl_off_t ultotal;
+  curl_off_t ulnow;
 };
 
 
@@ -74,16 +85,33 @@ static size_t file_write_handler(void* stream, size_t size, size_t nmemb, FILE*
   }
 }
 
-static int call_user_rb_progress_blk(void* vd_curl_state) {
+static VALUE call_user_rb_progress_blk_unprotected(VALUE vd_curl_state) {
   struct patron_curl_state* state = (struct patron_curl_state*)vd_curl_state;
-  // Invoke the block with the array
-  rb_funcall(state->user_progress_blk,
+  return rb_funcall(state->user_progress_blk,
     rb_intern("call"), 4,
-    LONG2NUM(state->dltotal),
-    LONG2NUM(state->dlnow),
-    LONG2NUM(state->ultotal),
-    LONG2NUM(state->ulnow));
-  return 0;
+    LL2NUM(state->dltotal),
+    LL2NUM(state->dlnow),
+    LL2NUM(state->ultotal),
+    LL2NUM(state->ulnow));
+}
+
+/* Runs with the GVL re-acquired, from inside a libcurl callback. Whatever the proc
+   throws must not propagate from here (see pending_tag), so park it and tell libcurl
+   to abort the transfer instead. */
+static void *call_user_rb_progress_blk(void *vd_curl_state) {
+  struct patron_curl_state* state = (struct patron_curl_state*)vd_curl_state;
+  int tag = 0;
+
+  rb_protect(call_user_rb_progress_blk_unprotected, (VALUE)state, &tag);
+  if (tag) {
+    /* Whatever rb_protect caught stays in the errinfo of the thread: for a throw (which is
+       how Timeout.timeout unwinds on Rubies before 3.1) it is not an Exception and can't be
+       put back with rb_set_errinfo, so we only hold a reference to keep it marked */
+    state->pending_tag = tag;
+    state->pending_exception = rb_errinfo();
+    state->interrupt = INTERRUPT_ABORT;
+  }
+  return NULL;
 }
 
 
@@ -92,7 +120,7 @@ static int call_user_rb_progress_blk(void* vd_curl_state) {
  * user calls the "interrupt" method on the session or when the Ruby interpreter
  * is attempting to exit.
  */
-static int session_progress_handler(void* clientp, size_t dltotal, size_t dlnow, size_t ultotal, size_t ulnow) {
+static int session_progress_handler(void* clientp, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow) {
   struct patron_curl_state* state = (struct patron_curl_state*) clientp;
   state->dltotal = dltotal;
   state->dlnow = dlnow;
@@ -102,8 +130,8 @@ static int session_progress_handler(void* clientp, size_t dltotal, size_t dlnow,
   // If a progress proc has been set, re-acquire the GIL and call it using
   // `call_user_rb_progress_blk`. TODO: use the retval of that proc
   // to permit premature abort 
-  if(RTEST(state->user_progress_blk)) {
-    rb_thread_call_with_gvl((void *(*)(void *)) call_user_rb_progress_blk, (void*)state);
+  if(RTEST(state->user_progress_blk) && !state->pending_tag) {
+    rb_thread_call_with_gvl(call_user_rb_progress_blk, state);
   }
 
   // Set the interrupt if the download byte limit has been reached
@@ -120,6 +148,13 @@ static int session_progress_handler(void* clientp, size_t dltotal, size_t dlnow,
   return state->interrupt;
 }
 
+#if LIBCURL_VERSION_NUM < 0x072000
+/* Before 7.32.0 there is only CURLOPT_PROGRESSFUNCTION, which hands over doubles */
+static int session_legacy_progress_handler(void* clientp, double dltotal, double dlnow, double ultotal, double ulnow) {
+  return session_progress_handler(clientp, (curl_off_t) dltotal, (curl_off_t) dlnow, (curl_off_t) ultotal, (curl_off_t) ulnow);
+}
+#endif
+
 
 /*
   List of active curl sessions, used exclusively to be able to set interrupts
@@ -177,7 +212,9 @@ static void session_close_debug_file(struct patron_curl_state *curl) {
 }
 
 /* Cleans up the patron_curl_state data when the Session object is garbage collected. */
-void session_free(struct patron_curl_state *state) {
+static void session_free(void *ptr) {
+  struct patron_curl_state *state = ptr;
+
   curl_easy_cleanup(state->base_handle);
   curl_share_cleanup(state->share);
 
@@ -188,16 +225,39 @@ void session_free(struct patron_curl_state *state) {
 
   cs_list_remove(state);
 
-  free(state);
+  ruby_xfree(state);
+}
+
+static void session_mark(void *ptr) {
+  struct patron_curl_state *state = ptr;
+
+  rb_gc_mark(state->user_progress_blk);
+  rb_gc_mark(state->upload_data);
+  rb_gc_mark(state->pending_exception);
 }
 
+static size_t session_memsize(const void *ptr) {
+  const struct patron_curl_state *state = ptr;
+
+  return sizeof(*state) + state->header_buffer.capacity + state->body_buffer.capacity;
+}
+
+static const rb_data_type_t patron_session_data_type = {
+  "Patron::Session",
+  {session_mark, session_free, session_memsize,},
+  0, 0, RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 /* Allocates patron_curl_state data needed for a new Session object. */
 VALUE session_alloc(VALUE klass) {
   struct patron_curl_state* state;
-  VALUE obj = Data_Make_Struct(klass, struct patron_curl_state, NULL, session_free, state);
+  VALUE obj = TypedData_Make_Struct(klass, struct patron_curl_state, &patron_session_data_type, state);
 
   membuffer_init(&state->header_buffer);
   membuffer_init(&state->body_buffer);
+  state->user_progress_blk = Qnil;
+  state->upload_data = Qnil;
+  state->pending_exception = Qnil;
   cs_list_append(state);
 
   /*
@@ -207,12 +267,20 @@ VALUE session_alloc(VALUE klass) {
     gets accessed over and over with requests.
   */
   state->share = curl_share_init();
+  if (!state->share) {
+    rb_raise(rb_eNoMemError, "libcurl could not allocate a share handle");
+  }
   curl_share_setopt(state->share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
   curl_share_setopt(state->share, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
   curl_share_setopt(state->share, CURLSHOPT_SHARE, CURL_LOCK_DATA_SSL_SESSION);
   curl_share_setopt(state->share, CURLSHOPT_SHARE, CURL_LOCK_DATA_CONNECT);
   curl_share_setopt(state->share, CURLSHOPT_SHARE, CURL_LOCK_DATA_PSL);
   state->base_handle = curl_easy_init();
+  if (!state->base_handle) {
+    /* obj is already allocated, so session_free() will release the share; curl_share_cleanup(NULL)
+       and curl_easy_cleanup(NULL) are no-ops, which keeps that path safe for a half-built state */
+    rb_raise(rb_eNoMemError, "libcurl could not allocate an easy handle");
+  }
   curl_easy_setopt(state->base_handle, CURLOPT_SHARE, state->share);
   curl_easy_setopt(state->base_handle, CURLOPT_WRITEFUNCTION, &session_write_handler);
   curl_easy_setopt(state->base_handle, CURLOPT_WRITEDATA, &state->body_buffer);
@@ -224,7 +292,7 @@ VALUE session_alloc(VALUE klass) {
   /* this is libCURLv7.32.0 or later, supports CURLOPT_XFERINFOFUNCTION */
   curl_easy_setopt(state->base_handle, CURLOPT_XFERINFOFUNCTION, &session_progress_handler);
 #else
-  curl_easy_setopt(state->base_handle, CURLOPT_PROGRESSFUNCTION, &session_progress_handler);
+  curl_easy_setopt(state->base_handle, CURLOPT_PROGRESSFUNCTION, &session_legacy_progress_handler);
 #endif
   curl_easy_setopt(state->base_handle, CURLOPT_PROGRESSDATA, state);
 #ifdef CURLPROTO_HTTP
@@ -241,7 +309,7 @@ VALUE session_alloc(VALUE klass) {
 /* Return the patron_curl_state from the ruby VALUE which is the Session instance. */
 static struct patron_curl_state* get_patron_curl_state(VALUE self) {
   struct patron_curl_state* state;
-  Data_Get_Struct(self, struct patron_curl_state, state);
+  TypedData_Get_Struct(self, struct patron_curl_state, &patron_session_data_type, state);
   return state;
 }
 
@@ -293,14 +361,17 @@ static VALUE session_escape(VALUE self, VALUE value) {
 #endif
   escaped = curl_easy_escape(curl,
                              RSTRING_PTR(string),
-                             (int) RSTRING_LEN(string));
-
-  retval = rb_str_new2(escaped);
+                             rb_long2int(RSTRING_LEN(string)));
 #if LIBCURL_VERSION_NUM >= 0x075200
   /* this is libCURLv7.82.0 or later, the curl parameter is ignored */
 #else
   curl_easy_cleanup(curl);
 #endif
+  if (!escaped) {
+    rb_raise(ePatronError, "libcurl could not escape the string");
+  }
+
+  retval = rb_str_new2(escaped);
   curl_free(escaped);
 
   return retval;
@@ -315,6 +386,7 @@ static VALUE session_escape(VALUE self, VALUE value) {
 static VALUE session_unescape(VALUE self, VALUE value) {
   VALUE string = StringValue(value);
   char* unescaped = NULL;
+  int unescaped_len = 0;
   VALUE retval = Qnil;
 
 #if LIBCURL_VERSION_NUM >= 0x075200
@@ -323,18 +395,22 @@ static VALUE session_unescape(VALUE self, VALUE value) {
 #else
   CURL *curl = curl_easy_init();
 #endif
+  /* Ask for the length: the decoded bytes may contain NUL ("%00"), so strlen would cut it short */
   unescaped = curl_easy_unescape(curl,
                                  RSTRING_PTR(string),
-                                 (int) RSTRING_LEN(string),
-                                 NULL);
-
-  retval = rb_str_new2(unescaped);
-  curl_free(unescaped);
+                                 rb_long2int(RSTRING_LEN(string)),
+                                 &unescaped_len);
 #if LIBCURL_VERSION_NUM >= 0x075200
   /* this is libCURLv7.82.0 or later, the curl parameter is ignored */
 #else
   curl_easy_cleanup(curl);
 #endif
+  if (!unescaped) {
+    rb_raise(ePatronError, "libcurl could not unescape the string");
+  }
+
+  retval = rb_str_new(unescaped, unescaped_len);
+  curl_free(unescaped);
 
   return retval;
 }
@@ -375,8 +451,18 @@ static int formadd_values(VALUE data_key, VALUE data_value, VALUE self) {
   VALUE name = rb_obj_as_string(data_key);
   VALUE value = rb_obj_as_string(data_value);
 
-  curl_formadd(&state->post, &state->last, CURLFORM_PTRNAME, RSTRING_PTR(name),
-                CURLFORM_PTRCONTENTS, RSTRING_PTR(value), CURLFORM_END);
+  /* COPY* makes libcurl copy both strings: the PTR* variants would keep pointers into
+     Strings nothing holds on to (a Symbol key gets stringified into a temporary), and
+     PTRCONTENTS stops at the first NUL byte. Passing the length keeps binary values intact. */
+  curl_formadd(&state->post, &state->last,
+                CURLFORM_COPYNAME, RSTRING_PTR(name), CURLFORM_NAMELENGTH, (long) RSTRING_LEN(name),
+                CURLFORM_COPYCONTENTS, RSTRING_PTR(value),
+#if LIBCURL_VERSION_NUM >= 0x072E00
+                CURLFORM_CONTENTLEN, (curl_off_t) RSTRING_LEN(value),
+#else
+                CURLFORM_CONTENTSLENGTH, (long) RSTRING_LEN(value),
+#endif
+                CURLFORM_END);
 
   return 0;
 }
@@ -386,19 +472,24 @@ static int formadd_files(VALUE data_key, VALUE data_value, VALUE self) {
   VALUE name = rb_obj_as_string(data_key);
   VALUE value = rb_obj_as_string(data_value);
 
-  curl_formadd(&state->post, &state->last, CURLFORM_PTRNAME, RSTRING_PTR(name),
-                CURLFORM_FILE, RSTRING_PTR(value), CURLFORM_END);
+  curl_formadd(&state->post, &state->last,
+                CURLFORM_COPYNAME, RSTRING_PTR(name), CURLFORM_NAMELENGTH, (long) RSTRING_LEN(name),
+                CURLFORM_FILE, StringValueCStr(value), CURLFORM_END);
 
   return 0;
 }
 
-// Set the given char pointer and it's length to be the CURL request body
-static void set_curl_request_body(CURL* curl, char* buf, curl_off_t len) {
-  curl_easy_setopt(curl, CURLOPT_POSTFIELDS, buf);
+// Use the given String as the CURL request body. The String is kept in the state
+// so that it outlives the (GVL-less) transfer which reads from its buffer.
+static void set_curl_request_body(struct patron_curl_state* state, VALUE data) {
+  CURL* curl = state->handle;
+  StringValue(data);
+  state->upload_data = data;
+  curl_easy_setopt(curl, CURLOPT_POSTFIELDS, RSTRING_PTR(state->upload_data));
   #ifdef CURLOPT_POSTFIELDSIZE_LARGE
-    curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE_LARGE, len);
+    curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE_LARGE, (curl_off_t) RSTRING_LEN(state->upload_data));
   #else
-    curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, len);
+    curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, (long) RSTRING_LEN(state->upload_data));
   #endif
 }
 
@@ -407,7 +498,7 @@ static void set_chunked_encoding(struct patron_curl_state *state) {
 }
 
 static FILE* open_file(VALUE filename, const char* perms) {
-  FILE* handle = fopen(StringValuePtr(filename), perms);
+  FILE* handle = fopen(StringValueCStr(filename), perms);
   if (!handle) {
     rb_raise(rb_eArgError, "Unable to open specified file.");
   }
@@ -437,7 +528,6 @@ static long floating_rb_seconds_to_milliseconds(VALUE r_seconds) {
 }
 
 static void set_request_body(struct patron_curl_state* state, VALUE stringable_or_file) {
-  CURL* curl = state->handle;
   if(rb_respond_to(stringable_or_file, rb_intern("to_path"))) {
     // Set up a file read callback (read the entire request body from a file).
     // Instead of using the Ruby file reads, use #to_path to obtain the
@@ -447,10 +537,7 @@ static void set_request_body(struct patron_curl_state* state, VALUE stringable_o
     set_request_body_file(state, r_path_str);
   } else {
     // Set the request body from a String
-    VALUE data = rb_funcall(stringable_or_file, rb_intern("to_s"), 0);
-    long len = RSTRING_LEN(data);
-    state->upload_buf = StringValuePtr(data);
-    set_curl_request_body(curl, state->upload_buf, len);
+    set_curl_request_body(state, rb_funcall(stringable_or_file, rb_intern("to_s"), 0));
   }
 }
 
@@ -474,18 +561,28 @@ static void set_options_from_request(VALUE self, VALUE request) {
   VALUE insecure              = Qnil;
   VALUE cacert                = Qnil;
   VALUE ssl_version           = Qnil;
+  VALUE ssl_cert              = Qnil;
+  VALUE ssl_cert_type         = Qnil;
+  VALUE ssl_key               = Qnil;
+  VALUE ssl_key_password      = Qnil;
   VALUE http_version          = Qnil;
   VALUE buffer_size           = Qnil;
-  VALUE action_name           = rb_funcall(request, rb_intern("action"), 0);
-  VALUE a_c_encoding          = rb_funcall(request, rb_intern("automatic_content_encoding"), 0);
-  VALUE download_byte_limit   = rb_funcall(request, rb_intern("download_byte_limit"), 0);
-  VALUE maybe_progress_proc   = rb_funcall(request, rb_intern("progress_callback"), 0);
+  VALUE action_name           = Qnil;
+  VALUE a_c_encoding          = Qnil;
+  VALUE download_byte_limit   = Qnil;
+  VALUE maybe_progress_proc   = Qnil;
 
+  /* Assign before anything can raise, so that cleanup() frees this handle and not a stale one */
   state->handle = curl;
+  action_name         = rb_funcall(request, rb_intern("action"), 0);
+  a_c_encoding        = rb_funcall(request, rb_intern("automatic_content_encoding"), 0);
+  download_byte_limit = rb_funcall(request, rb_intern("download_byte_limit"), 0);
+  maybe_progress_proc = rb_funcall(request, rb_intern("progress_callback"), 0);
+
   curl_easy_setopt(curl, CURLOPT_SHARE, state->share);
 
   if (RTEST(download_byte_limit)) {
-    state->download_byte_limit = FIX2INT(download_byte_limit);
+    state->download_byte_limit = (curl_off_t) NUM2LL(download_byte_limit);
   } else {
     state->download_byte_limit = 0;
   }
@@ -571,11 +668,8 @@ static void set_options_from_request(VALUE self, VALUE request) {
   } else if (action == rb_intern("delete")) {
       VALUE data = rb_funcall(request, rb_intern("upload_data"), 0);
       if (RTEST(data)) {
-        long len = RSTRING_LEN(data);
-        state->upload_buf = StringValuePtr(data);
         curl_easy_setopt(curl, CURLOPT_POST, 1);
-        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, state->upload_buf);
-        curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, len);
+        set_request_body(state, data);
       }
       curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
 
@@ -621,22 +715,22 @@ static void set_options_from_request(VALUE self, VALUE request) {
 
   timeout = rb_funcall(request, rb_intern("dns_cache_timeout"), 0);
   if (RTEST(timeout)) {
-    curl_easy_setopt(curl, CURLOPT_DNS_CACHE_TIMEOUT, FIX2INT(timeout));
+    curl_easy_setopt(curl, CURLOPT_DNS_CACHE_TIMEOUT, NUM2LONG(timeout));
   }
 
   VALUE low_speed_time = rb_funcall(request, rb_intern("low_speed_time"), 0);
   if(RTEST(low_speed_time)) {
-    curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, FIX2LONG(low_speed_time));
+    curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, NUM2LONG(low_speed_time));
   }
 
   VALUE low_speed_limit_bytes_per_second = rb_funcall(request, rb_intern("low_speed_limit"), 0);
   if(RTEST(low_speed_limit_bytes_per_second)) {
-    curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, FIX2LONG(low_speed_limit_bytes_per_second));
+    curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, NUM2LONG(low_speed_limit_bytes_per_second));
   }
 
   redirects = rb_funcall(request, rb_intern("max_redirects"), 0);
   if (RTEST(redirects)) {
-    int r = FIX2INT(redirects);
+    long r = NUM2LONG(redirects);
     curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, r == 0 ? 0 : 1);
     curl_easy_setopt(curl, CURLOPT_MAXREDIRS, r);
   }
@@ -736,9 +830,33 @@ static void set_options_from_request(VALUE self, VALUE request) {
     }
   }
 
+  ssl_cert = rb_funcall(request, rb_intern("ssl_cert"), 0);
+  if(RTEST(ssl_cert)) {
+    ssl_cert = FilePathValue(ssl_cert);
+    curl_easy_setopt(curl, CURLOPT_SSLCERT, StringValueCStr(ssl_cert));
+  }
+
+  ssl_cert_type = rb_funcall(request, rb_intern("ssl_cert_type"), 0);
+  if(RTEST(ssl_cert_type)) {
+    ssl_cert_type = rb_obj_as_string(ssl_cert_type);
+    curl_easy_setopt(curl, CURLOPT_SSLCERTTYPE, StringValueCStr(ssl_cert_type));
+  }
+
+  ssl_key = rb_funcall(request, rb_intern("ssl_key"), 0);
+  if(RTEST(ssl_key)) {
+    ssl_key = FilePathValue(ssl_key);
+    curl_easy_setopt(curl, CURLOPT_SSLKEY, StringValueCStr(ssl_key));
+  }
+
+  ssl_key_password = rb_funcall(request, rb_intern("ssl_key_password"), 0);
+  if(RTEST(ssl_key_password)) {
+    curl_easy_setopt(curl, CURLOPT_KEYPASSWD, StringValueCStr(ssl_key_password));
+  }
+
   cacert = rb_funcall(request, rb_intern("cacert"), 0);
   if(RTEST(cacert)) {
-    curl_easy_setopt(curl, CURLOPT_CAINFO, StringValuePtr(cacert));
+    cacert = FilePathValue(cacert);
+    curl_easy_setopt(curl, CURLOPT_CAINFO, StringValueCStr(cacert));
   }
 
   buffer_size = rb_funcall(request, rb_intern("buffer_size"), 0);
@@ -747,6 +865,28 @@ static void set_options_from_request(VALUE self, VALUE request) {
   }
 }
 
+/* Store one of curl's transfer marks (seconds since the request started) under +key+. */
+static void set_timing(CURL* curl, VALUE timings, const char* key, CURLINFO info) {
+  double seconds = 0;
+  if (curl_easy_getinfo(curl, info, &seconds) == CURLE_OK) {
+    rb_hash_aset(timings, ID2SYM(rb_intern(key)), rb_float_new(seconds));
+  }
+}
+
+/* curl's cumulative transfer marks: namelookup <= connect <= appconnect <= pretransfer
+ * <= starttransfer <= total. They are read after the transfer, so they cost no GVL time. */
+static VALUE create_timings(CURL* curl) {
+  VALUE timings = rb_hash_new();
+  set_timing(curl, timings, "namelookup",    CURLINFO_NAMELOOKUP_TIME);
+  set_timing(curl, timings, "connect",       CURLINFO_CONNECT_TIME);
+  set_timing(curl, timings, "appconnect",    CURLINFO_APPCONNECT_TIME);
+  set_timing(curl, timings, "pretransfer",   CURLINFO_PRETRANSFER_TIME);
+  set_timing(curl, timings, "starttransfer", CURLINFO_STARTTRANSFER_TIME);
+  set_timing(curl, timings, "redirect",      CURLINFO_REDIRECT_TIME);
+  set_timing(curl, timings, "total",         CURLINFO_TOTAL_TIME);
+  return timings;
+}
+
 /* Use the info in a Curl handle to create a new Response object. */
 static VALUE create_response(VALUE self, CURL* curl, VALUE header_buffer, VALUE body_buffer) {
   VALUE args[6] = { Qnil, Qnil, Qnil, Qnil, Qnil, Qnil };
@@ -754,6 +894,7 @@ static VALUE create_response(VALUE self, CURL* curl, VALUE header_buffer, VALUE
   long code = 0;
   long count = 0;
   VALUE responseKlass = Qnil;
+  VALUE response = Qnil;
   
   curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &effective_url);
   args[0] = rb_str_new2(effective_url);
@@ -769,7 +910,10 @@ static VALUE create_response(VALUE self, CURL* curl, VALUE header_buffer, VALUE
   args[5] = rb_funcall(self, rb_intern("default_response_charset"), 0);
   
   responseKlass = rb_funcall(self, rb_intern("response_class"), 0);
-  return rb_class_new_instance(6, args, responseKlass);
+  response = rb_class_new_instance(6, args, responseKlass);
+  /* Set after construction so custom response classes keep their #initialize signature. */
+  rb_iv_set(response, "@timings", create_timings(curl));
+  return response;
 }
 
 /* Raise an exception based on the Curl error code. */
@@ -784,6 +928,7 @@ static VALUE select_error(CURLcode code) {
     case CURLE_OPERATION_TIMEDOUT:    error = eTimeoutError;        break;
     case CURLE_TOO_MANY_REDIRECTS:    error = eTooManyRedirects;    break;
     case CURLE_ABORTED_BY_CALLBACK:   error = eAborted;             break;
+    case CURLE_SSL_CERTPROBLEM:       error = eClientCertificateError; break;
     default: error = ePatronError;
   }
 
@@ -791,6 +936,18 @@ static VALUE select_error(CURLcode code) {
 }
 
 
+struct perform_context {
+  CURL *curl;
+  CURLcode code;
+};
+
+static void *perform_without_gvl(void *ptr) {
+  struct perform_context *context = ptr;
+
+  context->code = curl_easy_perform(context->curl);
+  return NULL;
+}
+
 /* Uses as the unblocking function when the thread running Patron gets
    signaled. The important difference with session_interrupt is that we
    are not allowed to touch any Ruby structures while outside the GIL,
@@ -805,16 +962,30 @@ void session_ubf_abort(void* patron_state) {
 static VALUE perform_request(VALUE self) {
   struct patron_curl_state *state = get_patron_curl_state(self);
   CURL* curl = state->handle;
-  CURLcode ret = 0;
+  struct perform_context context = {curl, 0};
 
   state->interrupt = 0;            /* clear the interrupt flag */
+  state->pending_tag = 0;
+  state->pending_exception = Qnil;
+
+  rb_thread_call_without_gvl(perform_without_gvl, &context, session_ubf_abort, state);
+
+  /* The progress proc threw: resume that exit now that libcurl is done with the handle.
+     cleanup() still runs, since we are inside the rb_ensure of session_handle_request. */
+  if (state->pending_tag) {
+    int tag = state->pending_tag;
+    VALUE exception = state->pending_exception;
+    state->pending_tag = 0;
+    state->pending_exception = Qnil;
+    /* errinfo is only an Exception for a raise; a throw leaves an internal object there and
+       Thread#kill a Fixnum, both of which rb_obj_is_kind_of must not be asked about */
+    if (RB_TYPE_P(exception, T_OBJECT) && rb_obj_is_kind_of(exception, rb_eException)) {
+      rb_exc_raise(exception);
+    }
+    rb_jump_tag(tag);
+  }
 
-  ret = (CURLcode) rb_thread_call_without_gvl(
-          (void *(*)(void *)) curl_easy_perform, curl,
-          session_ubf_abort, (void*)state
-        );
-
-  if (CURLE_OK == ret) {
+  if (CURLE_OK == context.code) {
     VALUE header_str = membuffer_to_rb_str(&state->header_buffer);
     VALUE body_str = Qnil;
     if (!state->download_file) { body_str = membuffer_to_rb_str(&state->body_buffer); }
@@ -823,16 +994,27 @@ static VALUE perform_request(VALUE self) {
     
     return create_response(self, curl, header_str, body_str);
   } else {
-    rb_raise(select_error(ret), "%s", state->error_buf);
+    rb_raise(select_error(context.code), "%s", state->error_buf);
   }
 }
 
+/* Setting the options can raise too (a Request attribute of the wrong type, say),
+ * and this needs to run under rb_ensure so that the half-configured handle, headers and
+ * open files get cleaned up instead of leaking into the next request on this Session.
+ */
+static VALUE prepare_and_perform_request(VALUE args) {
+  VALUE self = rb_ary_entry(args, 0);
+  set_options_from_request(self, rb_ary_entry(args, 1));
+  return perform_request(self);
+}
+
 /* Cleanup after each request by resetting the Curl handle and deallocating
  * all request related objects such as the header slist.
  */
 static VALUE cleanup(VALUE self) {
   struct patron_curl_state *state = get_patron_curl_state(self);
   curl_easy_cleanup(state->handle);
+  state->handle = NULL;
 
   if (state->headers) {
     curl_slist_free_all(state->headers);
@@ -858,7 +1040,10 @@ static VALUE cleanup(VALUE self) {
     state->last = NULL;
   }
 
-  state->upload_buf = NULL;
+  state->upload_data = Qnil;
+  state->pending_tag = 0;
+  state->pending_exception = Qnil;
+  state->busy = 0;
 
   return Qnil;
 }
@@ -877,8 +1062,16 @@ static VALUE cleanup(VALUE self) {
  * @return [Patron::Response] the result of calling `response_class` on the Session
  */
 static VALUE session_handle_request(VALUE self, VALUE request) {
-  set_options_from_request(self, request);
-  return rb_ensure(&perform_request, self, &cleanup, self);
+  struct patron_curl_state *state = get_patron_curl_state(self);
+  VALUE args = Qnil;
+
+  if (state->busy) {
+    rb_raise(ePatronError, "Session is already performing a request on another thread; use one Session per thread");
+  }
+  state->busy = 1;
+
+  args = rb_ary_new3(2, self, request);
+  return rb_ensure(&prepare_and_perform_request, args, &cleanup, self);
 }
 
 /* Interrupt any currently executing request. This will cause the current
@@ -908,8 +1101,8 @@ static VALUE add_cookie_file(VALUE self, VALUE file) {
   char* file_path = NULL;
 
   // FIXME: http://websystemsengineering.blogspot.nl/2013/03/curloptcookiefile-vs-curloptcookiejar.html
-  file_path = RSTRING_PTR(file);
-  if (file_path != NULL && strlen(file_path) != 0) {
+  file_path = StringValueCStr(file);
+  if (strlen(file_path) != 0) {
     curl_easy_setopt(curl, CURLOPT_COOKIEJAR, file_path);
   }
   curl_easy_setopt(curl, CURLOPT_COOKIEFILE, file_path);
@@ -926,11 +1119,11 @@ static VALUE add_cookie_file(VALUE self, VALUE file) {
 static VALUE set_debug_file(VALUE self, VALUE file) {
   struct patron_curl_state *state = get_patron_curl_state(self);
   CURL *curl = state->base_handle;
-  char *file_path = RSTRING_PTR(file);
+  char *file_path = StringValueCStr(file);
 
   session_close_debug_file(state);
 
-  if(file_path != NULL && strlen(file_path) != 0) {
+  if(strlen(file_path) != 0) {
     state->debug_file = open_file(file, "wb");
   } else {
     state->debug_file = stderr;
@@ -953,6 +1146,22 @@ void Init_session_ext() {
 
   mPatron = rb_define_module("Patron");
 
+  /* These classes are defined in Ruby and only looked up here, so unlike the ones from
+     rb_define_class the GC does not know we hold them: register them, or compaction moves
+     them out from under us and rb_raise ends up instantiating garbage */
+  rb_global_variable(&ePatronError);
+  rb_global_variable(&eUnsupportedProtocol);
+  rb_global_variable(&eUnsupportedSSLVersion);
+  rb_global_variable(&eUnsupportedHTTPVersion);
+  rb_global_variable(&eURLFormatError);
+  rb_global_variable(&eHostResolutionError);
+  rb_global_variable(&eConnectionFailed);
+  rb_global_variable(&ePartialFileError);
+  rb_global_variable(&eTimeoutError);
+  rb_global_variable(&eTooManyRedirects);
+  rb_global_variable(&eAborted);
+  rb_global_variable(&eClientCertificateError);
+
   ePatronError = rb_const_get(mPatron, rb_intern("Error"));
 
   eUnsupportedProtocol = rb_const_get(mPatron, rb_intern("UnsupportedProtocol"));
@@ -965,6 +1174,7 @@ void Init_session_ext() {
   eTimeoutError = rb_const_get(mPatron, rb_intern("TimeoutError"));
   eTooManyRedirects = rb_const_get(mPatron, rb_intern("TooManyRedirects"));
   eAborted = rb_const_get(mPatron, rb_intern("Aborted"));
+  eClientCertificateError = rb_const_get(mPatron, rb_intern("ClientCertificateError"));
 
   rb_define_module_function(mPatron, "libcurl_version",       libcurl_version, 0);
   rb_define_module_function(mPatron, "libcurl_version_exact", libcurl_version_exact, 0);