patron 0.13.3 → 0.14.0

data/ext/patron/session_ext.c

@@ -1,7 +1,5 @@
 #include <ruby.h>
-#if defined(USE_TBR) && defined(HAVE_THREAD_H)
 #include <ruby/thread.h>
-#endif
 #include <sys/stat.h>
 #include <curl/curl.h>
 #include "membuffer.h"
@@ -26,10 +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;
-  char* upload_buf;
+  CURL* base_handle;
+  CURLSH* share;
+  /* 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
-  VALUE blk_result = 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,16 +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)) {
-    // Even though it is not documented, rb_thread_call_with_gvl is available even when
-    // rb_thread_call_without_gvl is not. See https://bugs.ruby-lang.org/issues/5543#note-4
-    // > rb_thread_call_with_gvl() is globally-visible (but not in headers)
-    // > for 1.9.3: https://bugs.ruby-lang.org/issues/4328
-    #if (defined(HAVE_TBR) || defined(HAVE_TCWOGVL)) && defined(USE_TBR)
-        rb_thread_call_with_gvl((void *(*)(void *)) call_user_rb_progress_blk, (void*)state);
-    #else
-        call_user_rb_progress_blk((void*)state);
-    #endif
+  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
@@ -128,10 +148,18 @@ 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                                               */
 
+/*
+  List of active curl sessions, used exclusively to be able to set interrupts
+  for all of them if the Ruby interpreter gets shut down with libCURL requests still in flight.
+*/
 struct patron_curl_state_list {
   struct patron_curl_state       *state;
   struct patron_curl_state_list  *next;
@@ -184,29 +212,52 @@ 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 *curl) {
-  if (curl->handle) {
-    curl_easy_cleanup(curl->handle);
-    curl->handle = NULL;
-  }
+static void session_free(void *ptr) {
+  struct patron_curl_state *state = ptr;
+
+  curl_easy_cleanup(state->base_handle);
+  curl_share_cleanup(state->share);
+
+  session_close_debug_file(state);
+
+  membuffer_destroy(&state->header_buffer);
+  membuffer_destroy(&state->body_buffer);
 
-  session_close_debug_file(curl);
+  cs_list_remove(state);
 
-  membuffer_destroy( &curl->header_buffer );
-  membuffer_destroy( &curl->body_buffer );
+  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);
+}
 
-  cs_list_remove(curl);
+static size_t session_memsize(const void *ptr) {
+  const struct patron_curl_state *state = ptr;
 
-  free(curl);
+  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);
 
   /*
@@ -215,16 +266,42 @@ VALUE session_alloc(VALUE klass) {
     reuse the TCP connection and can speed things up if the same resource - like a backend service -
     gets accessed over and over with requests.
   */
-  state->handle = curl_easy_init();
-  curl_easy_setopt(state->handle, CURLOPT_NOSIGNAL, 1);
-  curl_easy_setopt(state->handle, CURLOPT_NOPROGRESS, 0);
-  #if LIBCURL_VERSION_NUM >= 0x072000
-    /* this is libCURLv7.32.0 or later, supports CURLOPT_XFERINFOFUNCTION */
-    curl_easy_setopt(state->handle, CURLOPT_XFERINFOFUNCTION, &session_progress_handler);
-  #else
-    curl_easy_setopt(state->handle, CURLOPT_PROGRESSFUNCTION, &session_progress_handler);
-  #endif
-  curl_easy_setopt(state->handle, CURLOPT_PROGRESSDATA, state);
+  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);
+  curl_easy_setopt(state->base_handle, CURLOPT_HEADERFUNCTION, &session_write_handler);
+  curl_easy_setopt(state->base_handle, CURLOPT_HEADERDATA, &state->header_buffer);
+  curl_easy_setopt(state->base_handle, CURLOPT_NOSIGNAL, 1);
+  curl_easy_setopt(state->base_handle, CURLOPT_NOPROGRESS, 0);
+#if LIBCURL_VERSION_NUM >= 0x072000
+  /* 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_legacy_progress_handler);
+#endif
+  curl_easy_setopt(state->base_handle, CURLOPT_PROGRESSDATA, state);
+#ifdef CURLPROTO_HTTP
+  // Security: do not allow Curl to go looking on gopher/SMTP etc.
+  // Must prevent situations like this:
+  // https://hackerone.com/reports/115748
+  curl_easy_setopt(state->base_handle, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
+  curl_easy_setopt(state->base_handle, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
+#endif
 
   return obj;
 }
@@ -232,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;
 }
 
@@ -276,13 +353,25 @@ static VALUE session_escape(VALUE self, VALUE value) {
   char* escaped = NULL;
   VALUE retval = Qnil;
 
-  struct patron_curl_state* state = curl_easy_init();
-  escaped = curl_easy_escape(state->handle,
+#if LIBCURL_VERSION_NUM >= 0x075200
+  /* this is libCURLv7.82.0 or later, the curl parameter is ignored */
+  CURL *curl = NULL;
+#else
+  CURL* curl = curl_easy_init();
+#endif
+  escaped = curl_easy_escape(curl,
                              RSTRING_PTR(string),
-                             (int) RSTRING_LEN(string));
+                             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_easy_cleanup(state);
   curl_free(escaped);
 
   return retval;
@@ -297,17 +386,31 @@ 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;
 
-  struct patron_curl_state* state = curl_easy_init();
-  unescaped = curl_easy_unescape(state->handle,
+#if LIBCURL_VERSION_NUM >= 0x075200
+  /* this is libCURLv7.82.0 or later, the curl parameter is ignored */
+  CURL *curl = NULL;
+#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);
+                                 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_new2(unescaped);
+  retval = rb_str_new(unescaped, unescaped_len);
   curl_free(unescaped);
-  curl_easy_cleanup(state);
 
   return retval;
 }
@@ -348,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;
 }
@@ -359,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
 }
 
@@ -380,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.");
   }
@@ -410,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
@@ -420,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));
   }
 }
 
@@ -433,7 +547,7 @@ static void set_request_body(struct patron_curl_state* state, VALUE stringable_o
  */
 static void set_options_from_request(VALUE self, VALUE request) {
   struct patron_curl_state* state = get_patron_curl_state(self);
-  CURL* curl = state->handle;
+  CURL* curl = curl_easy_duphandle(state->base_handle);
 
   ID    action                = Qnil;
   VALUE headers               = Qnil;
@@ -447,15 +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;
   }
@@ -475,7 +602,7 @@ static void set_options_from_request(VALUE self, VALUE request) {
   }
 
   action = SYM2ID(action_name);
-  if(rb_funcall(request, rb_intern("force_ipv4"), 0)) {
+  if (RTEST(rb_funcall(request, rb_intern("force_ipv4"), 0))) {
     curl_easy_setopt(curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
   }
   if (action == rb_intern("get")) {
@@ -541,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");
 
@@ -578,13 +702,6 @@ static void set_options_from_request(VALUE self, VALUE request) {
   }
   curl_easy_setopt(curl, CURLOPT_URL, StringValuePtr(url));
   
-#ifdef CURLPROTO_HTTP
-  // Security: do not allow Curl to go looking on gopher/SMTP etc.
-  // Must prevent situations like this:
-  // https://hackerone.com/reports/115748
-  curl_easy_setopt(curl, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
-  curl_easy_setopt(curl, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
-#endif
     
   timeout = rb_funcall(request, rb_intern("timeout"), 0);
   if (RTEST(timeout)) {
@@ -598,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);
   }
@@ -713,22 +830,63 @@ 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);
   if (RTEST(buffer_size)) {
      curl_easy_setopt(curl, CURLOPT_BUFFERSIZE, NUM2LONG(buffer_size));
   }
+}
 
-  if(state->debug_file) {
-    curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
-    curl_easy_setopt(curl, CURLOPT_STDERR, state->debug_file);
+/* 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 };
@@ -736,22 +894,26 @@ 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);
 
   curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
-  args[1] = INT2NUM(code);
+  args[1] = LONG2NUM(code);
 
   curl_easy_getinfo(curl, CURLINFO_REDIRECT_COUNT, &count);
-  args[2] = INT2NUM(count);
+  args[2] = LONG2NUM(count);
 
   args[3] = header_buffer;
   args[4] = body_buffer;
   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. */
@@ -766,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;
   }
 
@@ -773,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,
@@ -787,72 +962,71 @@ 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;
-  membuffer* header_buffer = NULL;
-  membuffer* body_buffer = NULL;
-  CURLcode ret = 0;
+  struct perform_context context = {curl, 0};
 
   state->interrupt = 0;            /* clear the interrupt flag */
-
-  header_buffer = &state->header_buffer;
-  body_buffer = &state->body_buffer;
-
-  membuffer_clear(header_buffer);
-  membuffer_clear(body_buffer);
-
-  /* headers */
-  curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, &session_write_handler);
-  curl_easy_setopt(curl, CURLOPT_HEADERDATA, header_buffer);
-
-  /* body */
-  if (!state->download_file) {
-    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &session_write_handler);
-    curl_easy_setopt(curl, CURLOPT_WRITEDATA, body_buffer);
+  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);
   }
 
-#if (defined(HAVE_TBR) || defined(HAVE_TCWOGVL)) && defined(USE_TBR)
-  #if defined(HAVE_TCWOGVL)
-    ret = (CURLcode) rb_thread_call_without_gvl(
-            (void *(*)(void *)) curl_easy_perform, curl,
-            session_ubf_abort, (void*)state
-          );
-  #else
-    ret = (CURLcode) rb_thread_blocking_region(
-            (rb_blocking_function_t*) curl_easy_perform, curl,
-            session_ubf_abort, (void*)state
-          );
-  #endif
-#else
-  ret = curl_easy_perform(curl);
-#endif
-
-  if (CURLE_OK == ret) {
-    VALUE header_str = membuffer_to_rb_str(header_buffer);
+  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(body_buffer); }
+    if (!state->download_file) { body_str = membuffer_to_rb_str(&state->body_buffer); }
     
     curl_easy_setopt(curl, CURLOPT_COOKIELIST, "FLUSH"); // Flush cookies to the cookie jar
     
     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_reset(state->handle);
+  curl_easy_cleanup(state->handle);
+  state->handle = NULL;
 
   if (state->headers) {
     curl_slist_free_all(state->headers);
     state->headers = NULL;
   }
+  membuffer_clear(&state->header_buffer);
 
   if (state->download_file) {
     fclose(state->download_file);
     state->download_file = NULL;
+  } else {
+    membuffer_clear(&state->body_buffer);
   }
 
   if (state->request_body_file) {
@@ -866,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;
 }
@@ -885,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
@@ -912,12 +1097,12 @@ static VALUE session_interrupt(VALUE self) {
  */
 static VALUE add_cookie_file(VALUE self, VALUE file) {
   struct patron_curl_state *state = get_patron_curl_state(self);
-  CURL* curl = state->handle;
+  CURL* curl = state->base_handle;
   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);
@@ -933,15 +1118,18 @@ 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);
-  char* file_path = RSTRING_PTR(file);
+  CURL *curl = state->base_handle;
+  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;
   }
+  curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
+  curl_easy_setopt(curl, CURLOPT_STDERR, state->debug_file);
 
   return self;
 }
@@ -958,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"));
@@ -970,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);
@@ -986,11 +1191,11 @@ void Init_session_ext() {
   rb_define_singleton_method(cSession, "unescape",   session_unescape,         1);
   rb_define_method(cSession, "unescape",       session_unescape,       1);
 
-  rb_define_method(cSession, "handle_request", session_handle_request, 1);
+  rb_define_private_method(cSession, "handle_request", session_handle_request, 1);
   rb_define_method(cSession, "reset",          session_interrupt,      0);
   rb_define_method(cSession, "interrupt",      session_interrupt,      0);
-  rb_define_method(cSession, "add_cookie_file", add_cookie_file, 1);
-  rb_define_method(cSession, "set_debug_file", set_debug_file, 1);
+  rb_define_private_method(cSession, "add_cookie_file", add_cookie_file, 1);
+  rb_define_private_method(cSession, "set_debug_file", set_debug_file, 1);
   rb_define_alias(cSession, "urlencode", "escape");
   rb_define_alias(cSession, "urldecode", "unescape");