patron 0.14.0 → 1.0.0

data/ext/patron/session_ext.c

@@ -1,1154 +1,1253 @@
+/*
+ * Patron: libcurl bindings for Ruby.
+ *
+ * One Patron::Session owns one CURLM (multi handle), one template easy handle that
+ * every request is duplicated from, and one CURLSH that carries cookies, DNS entries
+ * and TLS sessions across requests. The multi handle owns the connection cache, which
+ * is what gives a Session connection reuse between requests.
+ *
+ * A request is driven by curl_multi_perform() while holding the GVL, so every libcurl
+ * callback (write, header, progress, debug) is ordinary Ruby-safe code, and by
+ * curl_multi_poll() with the GVL released. Ruby interrupts the poll through the
+ * unblocking function, which calls curl_multi_wakeup(); that is what makes Thread#kill,
+ * Thread#raise, Timeout and interpreter exit return promptly from any phase of a
+ * transfer, including DNS and connect.
+ *
+ * Requires Ruby >= 3.3 and libcurl >= 7.81.0.
+ */
 #include <ruby.h>
 #include <ruby/thread.h>
+#include <ruby/ractor.h>
+#include <ruby/encoding.h>
+#include <ruby/io.h>
+#include <ruby/fiber/scheduler.h>
+
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <unistd.h>
 #include <sys/stat.h>
+#include <sys/select.h>
+#include <pthread.h>
+
 #include <curl/curl.h>
-#include "membuffer.h"
-#include "sglib.h"  /* Simple Generic Library -> http://sglib.sourceforge.net */
 
-#define UNUSED_ARGUMENT(x) (void)x
+#if LIBCURL_VERSION_NUM < 0x075100
+#error "Patron requires libcurl 7.81.0 or newer"
+#endif
+
 #define INTERRUPT_ABORT 1
 #define INTERRUPT_DOWNLOAD_OVERFLOW 2
 
-static VALUE mPatron = Qnil;
-static VALUE mProxyType = Qnil;
-static VALUE cSession = Qnil;
-static VALUE cRequest = Qnil;
-static VALUE ePatronError = Qnil;
-static VALUE eUnsupportedProtocol = Qnil;
-static VALUE eUnsupportedSSLVersion = Qnil;
-static VALUE eUnsupportedHTTPVersion = Qnil;
-static VALUE eURLFormatError = Qnil;
-static VALUE eHostResolutionError = Qnil;
-static VALUE eConnectionFailed = Qnil;
-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;
-  /* 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;
+/* How long one curl_multi_poll() may sleep. libcurl wakes us earlier on socket activity,
+ * on its own timers, and on curl_multi_wakeup(); this is only the upper bound. */
+#define POLL_TIMEOUT_MS 1000
+
+#define BODY_BUFFER_INITIAL_CAPACITY (16 * 1024)
+#define HEADER_BUFFER_INITIAL_CAPACITY 1024
+
+static VALUE mPatron;
+static VALUE mProxyType;
+static VALUE cSession;
+static VALUE cRequest;
+static VALUE ePatronError;
+static VALUE eUnsupportedProtocol;
+static VALUE eUnsupportedSSLVersion;
+static VALUE eUnsupportedHTTPVersion;
+static VALUE eURLFormatError;
+static VALUE eHostResolutionError;
+static VALUE eConnectionFailed;
+static VALUE ePartialFileError;
+static VALUE eTimeoutError;
+static VALUE eTooManyRedirects;
+static VALUE eAborted;
+static VALUE eDownloadLimitExceeded;
+static VALUE eClientCertificateError;
+
+/* Frozen, Ractor-shareable lookup tables exposed as Patron::Request::SSL_VERSIONS and
+ * Patron::Request::HTTP_VERSIONS: version name => libcurl constant. */
+static VALUE hSSLVersions;
+static VALUE hHTTPVersions;
+
+#define REQUEST_ATTRIBUTES(X) \
+  X(action) X(action_name) X(headers) X(url) X(timeout) X(connect_timeout) \
+  X(dns_cache_timeout) X(low_speed_time) X(low_speed_limit) X(max_redirects) \
+  X(proxy) X(proxy_type) X(credentials) X(auth_type) X(ignore_content_length) \
+  X(insecure) X(ssl_version) X(http_version) X(ssl_cert) X(ssl_cert_type) \
+  X(ssl_key) X(ssl_key_password) X(cacert) X(buffer_size) X(download_byte_limit) \
+  X(progress_callback) X(automatic_content_encoding) X(force_ipv4) \
+  X(upload_data) X(file_name) X(multipart)
+
+#define DECLARE_ID(name) static ID id_##name;
+REQUEST_ATTRIBUTES(DECLARE_ID)
+#undef DECLARE_ID
+
+static ID id_to_path, id_to_s, id_response_class, id_default_response_charset;
+static ID id_get, id_post, id_put, id_patch, id_delete, id_head;
+static ID id_ivar_curl_code;
+static ID id_url_kw, id_status_kw, id_redirect_count_kw, id_header_data_kw, id_body_kw,
+          id_default_charset_kw, id_timings_kw;
+
+struct patron_session {
+  /* Lives as long as the Session object */
+  VALUE self;                         /* back-pointer for write barriers, never marked */
+  CURLM *multi;
+  CURL *base;                         /* template; every request is a curl_easy_duphandle() of it */
+  CURLSH *share;
+  pthread_mutex_t share_locks[CURL_LOCK_DATA_LAST];
+  pid_t pid;                          /* handles must not be reused across fork() */
+  VALUE debug_io;                     /* IO receiving CURLOPT_VERBOSE output, or nil */
+  VALUE socket_ios;                   /* fd => IO wrapping one of libcurl's sockets, for the Fiber scheduler */
+
+  /* Per request, torn down in cleanup() */
+  CURL *easy;
+  curl_mime *mime;
+  struct curl_slist *headers;
+  FILE *download_file;
+  FILE *request_body_file;
   char error_buf[CURL_ERROR_SIZE];
-  struct curl_slist* headers;
-  struct curl_httppost* post;
-  struct curl_httppost* last;
-  membuffer header_buffer;
-  membuffer body_buffer;
   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() */
+  VALUE progress_proc;
+  VALUE upload_data;                  /* pinned while libcurl reads it through CURLOPT_POSTFIELDS */
+  VALUE header_buf;                   /* binary String receiving the raw headers */
+  VALUE body_buf;                     /* binary String receiving the body, or nil when downloading to a file */
+
+  /* A callback may not let a Ruby exception unwind through libcurl's frames. The tag and
+   * errinfo are parked here, the transfer is aborted, and perform() re-raises afterwards. */
   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;
-  curl_off_t dltotal;
-  curl_off_t dlnow;
-  curl_off_t ultotal;
-  curl_off_t ulnow;
-};
+  VALUE pending_errinfo;
 
+  volatile sig_atomic_t interrupt;
+  volatile sig_atomic_t busy;
+};
 
 /*----------------------------------------------------------------------------*/
-/* Curl Callbacks                                                             */
-
-/* Takes data streamed from libcurl and writes it to a Ruby string buffer. */
-static size_t session_write_handler(char* stream, size_t size, size_t nmemb, membuffer* buf) {
-  int rc = membuffer_append(buf, stream, size * nmemb);
+/* TypedData                                                                  */
 
-  /* return 0 to signal that we could not append data to our buffer */
-  if (MB_OK != rc) { return 0; }
+static void session_free(void *ptr) {
+  struct patron_session *s = ptr;
+  int i;
+
+  /* A transfer cannot be in flight here: perform() keeps self on the stack. */
+  if (s->multi) curl_multi_cleanup(s->multi);
+  if (s->base) curl_easy_cleanup(s->base);
+  if (s->share) curl_share_cleanup(s->share);
+  for (i = 0; i < CURL_LOCK_DATA_LAST; i++) pthread_mutex_destroy(&s->share_locks[i]);
+  ruby_xfree(s);
+}
 
-  /* otherwise, return the number of bytes appended */
-  return size * nmemb;
+static void session_mark(void *ptr) {
+  struct patron_session *s = ptr;
+
+  rb_gc_mark_movable(s->debug_io);
+  rb_gc_mark_movable(s->socket_ios);
+  rb_gc_mark_movable(s->progress_proc);
+  rb_gc_mark_movable(s->header_buf);
+  rb_gc_mark_movable(s->body_buf);
+  rb_gc_mark_movable(s->pending_errinfo);
+  /* libcurl holds RSTRING_PTR() of this one for the whole transfer, and an embedded
+   * String keeps its bytes inside the object slot, so it must not be moved. */
+  rb_gc_mark(s->upload_data);
 }
 
-/* Used as WRITEFUNCTION for file downloads (required on Windows) */
-static size_t file_write_handler(void* stream, size_t size, size_t nmemb, FILE* fp) {
-  fwrite(stream, size, nmemb, fp);
-  if (ferror(fp)) {
-    return 0;
-  } else {
-    /* Just always OK the write */
-    return size * nmemb;
-  }
+static void session_compact(void *ptr) {
+  struct patron_session *s = ptr;
+
+  s->debug_io = rb_gc_location(s->debug_io);
+  s->socket_ios = rb_gc_location(s->socket_ios);
+  s->progress_proc = rb_gc_location(s->progress_proc);
+  s->header_buf = rb_gc_location(s->header_buf);
+  s->body_buf = rb_gc_location(s->body_buf);
+  s->pending_errinfo = rb_gc_location(s->pending_errinfo);
 }
 
-static VALUE call_user_rb_progress_blk_unprotected(VALUE vd_curl_state) {
-  struct patron_curl_state* state = (struct patron_curl_state*)vd_curl_state;
-  return rb_funcall(state->user_progress_blk,
-    rb_intern("call"), 4,
-    LL2NUM(state->dltotal),
-    LL2NUM(state->dlnow),
-    LL2NUM(state->ultotal),
-    LL2NUM(state->ulnow));
+static size_t session_memsize(const void *ptr) {
+  /* The Strings account for themselves; libcurl's own allocations are not visible. */
+  return sizeof(struct patron_session);
 }
 
-/* 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;
+/* RUBY_TYPED_EMBEDDABLE is deliberately not used: libcurl keeps pointers into this struct
+ * (CURLOPT_XFERINFODATA, CURLOPT_ERRORBUFFER, CURLOPT_DEBUGDATA, the write/header userdata)
+ * and an embedded struct moves under compaction. */
+static const rb_data_type_t patron_session_data_type = {
+  .wrap_struct_name = "Patron::Session",
+  .function = {
+    .dmark = session_mark,
+    .dfree = session_free,
+    .dsize = session_memsize,
+    .dcompact = session_compact,
+  },
+  .flags = RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FREE_IMMEDIATELY
+#ifdef RUBY_TYPED_THREAD_SAFE_FREE
+           /* dfree only touches handles owned by this object */
+           | RUBY_TYPED_THREAD_SAFE_FREE
+#endif
+  ,
+};
 
-  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;
+/* Every entry point refreshes the back-pointer: the Session object itself may have been
+ * moved by compaction since the last call. Within a call it is on the C stack and pinned,
+ * which is what makes `s->self` safe to use from the libcurl callbacks. */
+static struct patron_session *get_session(VALUE self) {
+  struct patron_session *s;
+  TypedData_Get_Struct(self, struct patron_session, &patron_session_data_type, s);
+  s->self = self;
+  return s;
 }
 
+#define SESSION_WRITE(s, field, value) RB_OBJ_WRITE((s)->self, &(s)->field, (value))
 
-/* A non-zero return value from the progress handler will terminate the current
- * request. We use this fact in order to interrupt any request when either the
- * user calls the "interrupt" method on the session or when the Ruby interpreter
- * is attempting to exit.
- */
-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;
-  state->ultotal = ultotal;
-  state->ulnow = ulnow;
-
-  // 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) && !state->pending_tag) {
-    rb_thread_call_with_gvl(call_user_rb_progress_blk, state);
-  }
+/*----------------------------------------------------------------------------*/
+/* Errors                                                                     */
 
-  // Set the interrupt if the download byte limit has been reached
-  if(state->download_byte_limit != 0 && (dltotal > state->download_byte_limit)) {
-    state->interrupt = INTERRUPT_DOWNLOAD_OVERFLOW;
+static VALUE error_class_for(CURLcode code) {
+  switch (code) {
+    case CURLE_UNSUPPORTED_PROTOCOL:  return eUnsupportedProtocol;
+    case CURLE_URL_MALFORMAT:         return eURLFormatError;
+    case CURLE_COULDNT_RESOLVE_HOST:  return eHostResolutionError;
+    case CURLE_COULDNT_CONNECT:       return eConnectionFailed;
+    case CURLE_PARTIAL_FILE:          return ePartialFileError;
+    case CURLE_OPERATION_TIMEDOUT:    return eTimeoutError;
+    case CURLE_TOO_MANY_REDIRECTS:    return eTooManyRedirects;
+    case CURLE_ABORTED_BY_CALLBACK:   return eAborted;
+    case CURLE_SSL_CERTPROBLEM:       return eClientCertificateError;
+    default:                          return ePatronError;
   }
-  
-  // If the interrupt value is anything except 0, the perform() call
-  // will be aborted by libCURL.
-  // Note however that some older versions of libcurl have a bug which
-  // makes the return value of this callback be ignored, and the request
-  // will actually proceed undeterred.
-  // See https://sourceforge.net/p/curl/bugs/1318/
-  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);
+NORETURN(static void raise_curl_error(VALUE klass, CURLcode code, const char *message));
+static void raise_curl_error(VALUE klass, CURLcode code, const char *message) {
+  VALUE exc;
+
+  if (!message || !*message) message = curl_easy_strerror(code);
+  exc = rb_exc_new_cstr(klass, message);
+  rb_ivar_set(exc, id_ivar_curl_code, INT2NUM((int)code));
+  rb_exc_raise(exc);
 }
-#endif
 
+/* curl_easy_setopt() only fails for options the installed libcurl cannot honour; that must
+ * surface instead of silently running the request with defaults. */
+#define setopt_or_raise(handle, option, value) do { \
+  CURLcode setopt_rc_ = curl_easy_setopt((handle), (option), (value)); \
+  if (setopt_rc_ != CURLE_OK) raise_curl_error(ePatronError, setopt_rc_, NULL); \
+} while (0)
 
-/*
-  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;
-};
+/*----------------------------------------------------------------------------*/
+/* Deferred exceptions from inside libcurl callbacks                          */
 
-#define CS_LIST_COMPARATOR(p, _state_) (p->state - _state_)
+static void park_exception(struct patron_session *s, int tag) {
+  if (s->pending_tag) return;
+  s->pending_tag = tag;
+  SESSION_WRITE(s, pending_errinfo, rb_errinfo());
+  s->interrupt = INTERRUPT_ABORT;
+}
 
-static struct patron_curl_state_list *cs_list = NULL;
+/* A raise can be re-raised as such. A throw or a Thread#kill leaves a non-exception in
+ * errinfo, which rb_set_errinfo refuses, so those jump by tag and rely on errinfo being
+ * untouched since the callback parked it (nothing in between rescues). */
+NORETURN(static void reraise_parked(struct patron_session *s));
+static void reraise_parked(struct patron_session *s) {
+  int tag = s->pending_tag;
+  VALUE errinfo = s->pending_errinfo;
+
+  s->pending_tag = 0;
+  SESSION_WRITE(s, pending_errinfo, Qnil);
+  if (RB_TYPE_P(errinfo, T_OBJECT) && rb_obj_is_kind_of(errinfo, rb_eException)) rb_exc_raise(errinfo);
+  rb_jump_tag(tag);
+}
 
-static void cs_list_append( struct patron_curl_state *state ) {
-  struct patron_curl_state_list *item = NULL;
+/*----------------------------------------------------------------------------*/
+/* libcurl callbacks. All of them run with the GVL held, from curl_multi_perform(). */
 
-  assert(state != NULL);
-  item = ruby_xmalloc(sizeof(struct patron_curl_state_list));
-  item->state = state;
-  item->next = NULL;
+struct append_args {
+  VALUE str;
+  const char *ptr;
+  size_t len;
+};
 
-  SGLIB_LIST_ADD(struct patron_curl_state_list, cs_list, item, next);
+static VALUE append_protected(VALUE arg) {
+  struct append_args *a = (struct append_args *)arg;
+  rb_str_cat(a->str, a->ptr, (long)a->len);
+  return Qnil;
 }
 
-static void cs_list_remove(struct patron_curl_state *state) {
-  struct patron_curl_state_list *item = NULL;
-
-  assert(state != NULL);
+static size_t append_to_string(struct patron_session *s, VALUE str, const char *ptr, size_t len) {
+  struct append_args args = { str, ptr, len };
+  int tag = 0;
 
-  SGLIB_LIST_DELETE_IF_MEMBER(struct patron_curl_state_list, cs_list, state, CS_LIST_COMPARATOR, next, item);
-  if (item) {
-    ruby_xfree(item);
+  rb_protect(append_protected, (VALUE)&args, &tag);
+  if (tag) {
+    park_exception(s, tag);
+    return 0;
   }
+  return len;
 }
 
-/* Gets attached to at_exit of the Ruby process to be able to abort all running libCURL requests and quit */
-static void cs_list_interrupt(VALUE data) {
-  UNUSED_ARGUMENT(data);
+static size_t body_write_cb(char *ptr, size_t size, size_t nmemb, void *userdata) {
+  struct patron_session *s = userdata;
+  size_t len = size * nmemb;
 
-  SGLIB_LIST_MAP_ON_ELEMENTS(struct patron_curl_state_list, cs_list, item, next, {
-    item->state->interrupt = INTERRUPT_ABORT;
-  });
+  if (s->download_file) {
+    if (fwrite(ptr, 1, len, s->download_file) != len) return 0;
+    return len;
+  }
+  return append_to_string(s, s->body_buf, ptr, len);
 }
 
+static size_t header_write_cb(char *ptr, size_t size, size_t nmemb, void *userdata) {
+  struct patron_session *s = userdata;
+  return append_to_string(s, s->header_buf, ptr, size * nmemb);
+}
 
-/*----------------------------------------------------------------------------*/
-/* Object allocation                                                          */
-
-static void session_close_debug_file(struct patron_curl_state *curl) {
-  if (curl->debug_file && stderr != curl->debug_file) {
-    fclose(curl->debug_file);
-  }
-  curl->debug_file = NULL;
+static size_t file_read_cb(char *buffer, size_t size, size_t nitems, void *userdata) {
+  FILE *fp = userdata;
+  return fread(buffer, 1, size * nitems, fp);
 }
 
-/* Cleans up the patron_curl_state data when the Session object is garbage collected. */
-static void session_free(void *ptr) {
-  struct patron_curl_state *state = ptr;
+struct progress_args {
+  struct patron_session *s;
+  curl_off_t dltotal, dlnow, ultotal, ulnow;
+};
+
+static VALUE progress_protected(VALUE arg) {
+  struct progress_args *a = (struct progress_args *)arg;
+  VALUE argv[4] = { LL2NUM(a->dltotal), LL2NUM(a->dlnow), LL2NUM(a->ultotal), LL2NUM(a->ulnow) };
+  return rb_proc_call_with_block(a->s->progress_proc, 4, argv, Qnil);
+}
 
-  curl_easy_cleanup(state->base_handle);
-  curl_share_cleanup(state->share);
+/* Non-zero return aborts the transfer with CURLE_ABORTED_BY_CALLBACK. */
+static int xferinfo_cb(void *userdata, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow) {
+  struct patron_session *s = userdata;
 
-  session_close_debug_file(state);
+  if (s->interrupt) return 1;
 
-  membuffer_destroy(&state->header_buffer);
-  membuffer_destroy(&state->body_buffer);
+  if (s->download_byte_limit > 0 && (dltotal > s->download_byte_limit || dlnow > s->download_byte_limit)) {
+    s->interrupt = INTERRUPT_DOWNLOAD_OVERFLOW;
+    return 1;
+  }
 
-  cs_list_remove(state);
+  if (!NIL_P(s->progress_proc)) {
+    struct progress_args args = { s, dltotal, dlnow, ultotal, ulnow };
+    int tag = 0;
+    VALUE result = rb_protect(progress_protected, (VALUE)&args, &tag);
 
-  ruby_xfree(state);
+    if (tag) {
+      park_exception(s, tag);
+      return 1;
+    }
+    /* Only an explicit false aborts; a callback that happens to end in nil keeps going. */
+    if (result == Qfalse) {
+      s->interrupt = INTERRUPT_ABORT;
+      return 1;
+    }
+  }
+  return 0;
 }
 
-static void session_mark(void *ptr) {
-  struct patron_curl_state *state = ptr;
+struct debug_args {
+  VALUE io;
+  const char *prefix;
+  const char *data;
+  size_t len;
+};
 
-  rb_gc_mark(state->user_progress_blk);
-  rb_gc_mark(state->upload_data);
-  rb_gc_mark(state->pending_exception);
+static VALUE debug_protected(VALUE arg) {
+  struct debug_args *a = (struct debug_args *)arg;
+  VALUE line = rb_str_buf_new((long)(a->len + 2));
+  rb_str_cat_cstr(line, a->prefix);
+  rb_str_cat(line, a->data, (long)a->len);
+  rb_io_write(a->io, line);
+  return Qnil;
 }
 
-static size_t session_memsize(const void *ptr) {
-  const struct patron_curl_state *state = ptr;
+/* Mirrors what libcurl itself prints with CURLOPT_VERBOSE: informational text and the
+ * headers in both directions, never the payload. */
+static int debug_cb(CURL *handle, curl_infotype type, char *data, size_t len, void *userdata) {
+  struct patron_session *s = userdata;
+  const char *prefix;
+  struct debug_args args;
+  int tag = 0;
+
+  if (NIL_P(s->debug_io)) return 0;
+
+  switch (type) {
+    case CURLINFO_TEXT:       prefix = "* "; break;
+    case CURLINFO_HEADER_IN:  prefix = "< "; break;
+    case CURLINFO_HEADER_OUT: prefix = "> "; break;
+    default:                  return 0;
+  }
 
-  return sizeof(*state) + state->header_buffer.capacity + state->body_buffer.capacity;
+  args.io = s->debug_io;
+  args.prefix = prefix;
+  args.data = data;
+  args.len = len;
+  rb_protect(debug_protected, (VALUE)&args, &tag);
+  if (tag) park_exception(s, tag);
+  return 0;
 }
 
-static const rb_data_type_t patron_session_data_type = {
-  "Patron::Session",
-  {session_mark, session_free, session_memsize,},
-  0, 0, RUBY_TYPED_FREE_IMMEDIATELY,
-};
+static void share_lock_cb(CURL *handle, curl_lock_data data, curl_lock_access access, void *userptr) {
+  struct patron_session *s = userptr;
+  pthread_mutex_lock(&s->share_locks[data]);
+}
 
-/* Allocates patron_curl_state data needed for a new Session object. */
-VALUE session_alloc(VALUE klass) {
-  struct patron_curl_state* 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);
-
-  /*
-    Eagerly initialize the curl handle. We initialize it only once and store it
-    in the struct until the Session object gets garbage-collected in session_free(). This allows libCURL to
-    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->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");
+static void share_unlock_cb(CURL *handle, curl_lock_data data, void *userptr) {
+  struct patron_session *s = userptr;
+  pthread_mutex_unlock(&s->share_locks[data]);
+}
+
+/*----------------------------------------------------------------------------*/
+/* Handle lifecycle                                                           */
+
+static void init_handles(struct patron_session *s) {
+  int i;
+
+  for (i = 0; i < CURL_LOCK_DATA_LAST; i++) pthread_mutex_init(&s->share_locks[i], NULL);
+
+  s->share = curl_share_init();
+  s->multi = curl_multi_init();
+  s->base = curl_easy_init();
+  if (!s->share || !s->multi || !s->base) {
+    if (s->base) curl_easy_cleanup(s->base);
+    if (s->multi) curl_multi_cleanup(s->multi);
+    if (s->share) curl_share_cleanup(s->share);
+    s->base = NULL; s->multi = NULL; s->share = NULL;
+    rb_memerror();
   }
-  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);
+  s->pid = getpid();
+
+  curl_share_setopt(s->share, CURLSHOPT_LOCKFUNC, share_lock_cb);
+  curl_share_setopt(s->share, CURLSHOPT_UNLOCKFUNC, share_unlock_cb);
+  curl_share_setopt(s->share, CURLSHOPT_USERDATA, s);
+  curl_share_setopt(s->share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
+  curl_share_setopt(s->share, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
+  curl_share_setopt(s->share, CURLSHOPT_SHARE, CURL_LOCK_DATA_SSL_SESSION);
+  curl_share_setopt(s->share, CURLSHOPT_SHARE, CURL_LOCK_DATA_PSL);
+
+  /* The multi handle owns the connection cache. Multiplexing costs nothing with one
+   * transfer at a time and is ready for concurrent transfers later. */
+  curl_multi_setopt(s->multi, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
+
+  curl_easy_setopt(s->base, CURLOPT_SHARE, s->share);
+  curl_easy_setopt(s->base, CURLOPT_WRITEFUNCTION, body_write_cb);
+  curl_easy_setopt(s->base, CURLOPT_WRITEDATA, s);
+  curl_easy_setopt(s->base, CURLOPT_HEADERFUNCTION, header_write_cb);
+  curl_easy_setopt(s->base, CURLOPT_HEADERDATA, s);
+  curl_easy_setopt(s->base, CURLOPT_NOSIGNAL, 1L);
+  curl_easy_setopt(s->base, CURLOPT_NOPROGRESS, 0L);
+  curl_easy_setopt(s->base, CURLOPT_XFERINFOFUNCTION, xferinfo_cb);
+  curl_easy_setopt(s->base, CURLOPT_XFERINFODATA, s);
+  curl_easy_setopt(s->base, CURLOPT_DEBUGFUNCTION, debug_cb);
+  curl_easy_setopt(s->base, CURLOPT_DEBUGDATA, s);
+  curl_easy_setopt(s->base, CURLOPT_ERRORBUFFER, s->error_buf);
+
+  /* Never let a URL or a redirect take us to gopher, smtp, file and friends. */
+#if LIBCURL_VERSION_NUM >= 0x075500
+  curl_easy_setopt(s->base, CURLOPT_PROTOCOLS_STR, "http,https");
+  curl_easy_setopt(s->base, CURLOPT_REDIR_PROTOCOLS_STR, "http,https");
 #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);
+  curl_easy_setopt(s->base, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
+  curl_easy_setopt(s->base, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
 #endif
+}
 
-  return obj;
+/* A forked child must not use connections it shares with the parent. The inherited
+ * handles are abandoned rather than cleaned up, since cleaning up would shut down
+ * TLS sessions on sockets the parent is still using. */
+static void ensure_handles_for_this_process(struct patron_session *s) {
+  if (s->pid == getpid()) return;
+  s->multi = NULL;
+  s->base = NULL;
+  s->share = NULL;
+  init_handles(s);
+  /* Cookie jar and debug settings live on the base handle; the Ruby side re-applies them. */
+  rb_funcall(s->self, rb_intern("reapply_base_options"), 0);
 }
 
-/* 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;
-  TypedData_Get_Struct(self, struct patron_curl_state, &patron_session_data_type, state);
-  return state;
+static VALUE session_alloc(VALUE klass) {
+  struct patron_session *s;
+  VALUE obj = TypedData_Make_Struct(klass, struct patron_session, &patron_session_data_type, s);
+
+  s->self = obj;
+  s->debug_io = Qnil;
+  s->socket_ios = Qnil;
+  s->progress_proc = Qnil;
+  s->upload_data = Qnil;
+  s->header_buf = Qnil;
+  s->body_buf = Qnil;
+  s->pending_errinfo = Qnil;
+  init_handles(s);
+  return obj;
 }
 
 /*----------------------------------------------------------------------------*/
-/* Method implementations                                                     */
+/* Module functions                                                           */
 
 /*
-* Returns the version of the embedded libcurl.
-* 
-*  @return [String] libcurl version string
+ * Returns the version string of the libcurl in use, e.g. "libcurl/8.7.1 OpenSSL/3.3.0".
+ *
+ * @return [String]
  */
 static VALUE libcurl_version(VALUE klass) {
-  char* value = curl_version();
-  UNUSED_ARGUMENT(klass);
-  return rb_str_new2(value);
+  return rb_str_new_cstr(curl_version());
 }
 
 /*
-* Returns the version of the embedded libcurl.
-* 
-*  @return [Array] an array of MAJOR, MINOR, PATCH integers
+ * Returns the version of the libcurl Patron was compiled against.
+ *
+ * @return [Array<Integer>] major, minor and patch
  */
 static VALUE libcurl_version_exact(VALUE klass) {
-  UNUSED_ARGUMENT(klass);
-  VALUE cv_major = INT2FIX(LIBCURL_VERSION_MAJOR);
-  VALUE cv_minor = INT2FIX(LIBCURL_VERSION_MINOR);
-  VALUE cv_patch = INT2FIX(LIBCURL_VERSION_PATCH);
-  VALUE version_arr = rb_ary_new3(3, cv_major, cv_minor, cv_patch);
-  return version_arr;
+  return rb_ary_new_from_args(3, INT2FIX(LIBCURL_VERSION_MAJOR), INT2FIX(LIBCURL_VERSION_MINOR), INT2FIX(LIBCURL_VERSION_PATCH));
 }
 
 /*
- * Escapes the provided string using libCURL URL escaping functions.
+ * Describes the libcurl in use at runtime.
  *
- * @param [String] value plain string to URL-escape
-*  @return [String] the escaped string
+ * @return [Hash] `:version`, `:ssl_version`, `:libz_version` Strings (the latter two may be nil)
+ *   and `:features`, an Array of Symbols such as `:ssl`, `:http2`, `:http3`, `:asynchdns`, `:threadsafe`
  */
-static VALUE session_escape(VALUE self, VALUE value) {
-  
-  VALUE string = StringValue(value);
-  char* escaped = NULL;
-  VALUE retval = Qnil;
-
-#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();
+static VALUE libcurl_features(VALUE klass) {
+  curl_version_info_data *info = curl_version_info(CURLVERSION_NOW);
+  VALUE features = rb_ary_new();
+  VALUE result = rb_hash_new();
+
+#define FEATURE(flag, name) if (info->features & (flag)) rb_ary_push(features, ID2SYM(rb_intern(name)))
+  FEATURE(CURL_VERSION_SSL, "ssl");
+  FEATURE(CURL_VERSION_IPV6, "ipv6");
+  FEATURE(CURL_VERSION_LIBZ, "libz");
+  FEATURE(CURL_VERSION_ASYNCHDNS, "asynchdns");
+  FEATURE(CURL_VERSION_HTTP2, "http2");
+  FEATURE(CURL_VERSION_HTTP3, "http3");
+  FEATURE(CURL_VERSION_BROTLI, "brotli");
+  FEATURE(CURL_VERSION_UNIX_SOCKETS, "unix_sockets");
+#ifdef CURL_VERSION_ZSTD
+  FEATURE(CURL_VERSION_ZSTD, "zstd");
 #endif
-  escaped = curl_easy_escape(curl,
-                             RSTRING_PTR(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);
+#ifdef CURL_VERSION_THREADSAFE
+  FEATURE(CURL_VERSION_THREADSAFE, "threadsafe");
 #endif
-  if (!escaped) {
-    rb_raise(ePatronError, "libcurl could not escape the string");
-  }
+#undef FEATURE
 
-  retval = rb_str_new2(escaped);
-  curl_free(escaped);
+  rb_hash_aset(result, ID2SYM(rb_intern("version")), rb_str_new_cstr(info->version));
+  rb_hash_aset(result, ID2SYM(rb_intern("ssl_version")), info->ssl_version ? rb_str_new_cstr(info->ssl_version) : Qnil);
+  rb_hash_aset(result, ID2SYM(rb_intern("libz_version")), info->libz_version ? rb_str_new_cstr(info->libz_version) : Qnil);
+  rb_hash_aset(result, ID2SYM(rb_intern("features")), features);
+  return result;
+}
+
+/*
+ * URL-escapes a String using libcurl.
+ *
+ * @param value [String]
+ * @return [String] the escaped string
+ */
+static VALUE session_escape(VALUE self, VALUE value) {
+  VALUE string = StringValue(value);
+  char *escaped = curl_easy_escape(NULL, RSTRING_PTR(string), rb_long2int(RSTRING_LEN(string)));
+  VALUE result;
 
-  return retval;
+  if (!escaped) rb_raise(ePatronError, "libcurl could not escape the string");
+  result = rb_usascii_str_new_cstr(escaped);
+  curl_free(escaped);
+  return result;
 }
 
 /*
- * Unescapes the provided string using libCURL URL escaping functions.
+ * URL-unescapes a String using libcurl. The result is binary, since percent-escapes can
+ * encode arbitrary bytes.
  *
- * @param [String] value URL-encoded String to unescape
-*  @return [String] unescaped (decoded) string
+ * @param value [String]
+ * @return [String] the unescaped string
  */
 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
-  /* 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),
-                                 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");
-  }
+  int outlen = 0;
+  char *unescaped = curl_easy_unescape(NULL, RSTRING_PTR(string), rb_long2int(RSTRING_LEN(string)), &outlen);
+  VALUE result;
 
-  retval = rb_str_new(unescaped, unescaped_len);
+  if (!unescaped) rb_raise(ePatronError, "libcurl could not unescape the string");
+  result = rb_str_new(unescaped, outlen);
   curl_free(unescaped);
-
-  return retval;
+  return result;
 }
 
-/* Callback used to iterate over the HTTP headers and store them in an slist. */
-static int each_http_header(VALUE header_key, VALUE header_value, VALUE self) {
-  struct patron_curl_state *state = get_patron_curl_state(self);
-  CURL* curl = state->handle;
-
-  VALUE name = rb_obj_as_string(header_key);
-  VALUE value = rb_obj_as_string(header_value);
-  VALUE header_str = Qnil;
-  
-  // TODO: see how to combine this with automatic_content_encoding
-  if (rb_str_cmp(name, rb_str_new2("Accept-Encoding")) == 0) {
-    if (rb_funcall(value, rb_intern("include?"), 1, rb_str_new2("gzip"))) {
-      #ifdef CURLOPT_ACCEPT_ENCODING
-        curl_easy_setopt(curl, CURLOPT_ACCEPT_ENCODING, "gzip");
-      #elif defined CURLOPT_ENCODING
-        curl_easy_setopt(curl, CURLOPT_ENCODING, "gzip");
-      #else
-        rb_raise(rb_eArgError,
-                "The libcurl version installed doesn't support 'gzip'.");
-      #endif
-    }
-  }
+/*----------------------------------------------------------------------------*/
+/* Request configuration                                                      */
 
-  header_str = rb_str_plus(name, rb_str_new2(": "));
-  header_str = rb_str_plus(header_str, value);
+static VALUE request_attr(VALUE request, ID id) {
+  return rb_funcallv(request, id, 0, NULL);
+}
 
-  state->headers = curl_slist_append(state->headers, StringValuePtr(header_str));
+static int header_name_is(VALUE name, const char *expected) {
+  long len = (long)strlen(expected);
+  long i;
+  const char *p;
 
-  return 0;
+  if (RSTRING_LEN(name) != len) return 0;
+  p = RSTRING_PTR(name);
+  for (i = 0; i < len; i++) {
+    if (rb_tolower((unsigned char)p[i]) != rb_tolower((unsigned char)expected[i])) return 0;
+  }
+  return 1;
 }
 
-static int formadd_values(VALUE data_key, VALUE data_value, VALUE self) {
-  struct patron_curl_state *state = get_patron_curl_state(self);
-  VALUE name = rb_obj_as_string(data_key);
-  VALUE value = rb_obj_as_string(data_value);
-
-  /* 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);
+static int string_contains(VALUE str, const char *needle) {
+  const char *haystack = RSTRING_PTR(str);
+  long len = RSTRING_LEN(str);
+  long needle_len = (long)strlen(needle);
+  long i;
 
+  for (i = 0; i + needle_len <= len; i++) {
+    if (memcmp(haystack + i, needle, (size_t)needle_len) == 0) return 1;
+  }
   return 0;
 }
 
-static int formadd_files(VALUE data_key, VALUE data_value, VALUE self) {
-  struct patron_curl_state *state = get_patron_curl_state(self);
-  VALUE name = rb_obj_as_string(data_key);
-  VALUE value = rb_obj_as_string(data_value);
+static int each_http_header(VALUE key, VALUE value, VALUE self) {
+  struct patron_session *s = get_session(self);
+  VALUE name = rb_obj_as_string(key);
+  VALUE line;
 
-  curl_formadd(&state->post, &state->last,
-                CURLFORM_COPYNAME, RSTRING_PTR(name), CURLFORM_NAMELENGTH, (long) RSTRING_LEN(name),
-                CURLFORM_FILE, StringValueCStr(value), CURLFORM_END);
+  /* "Accept-Encoding: gzip" also asks libcurl to inflate the response for us. */
+  if (header_name_is(name, "Accept-Encoding") && string_contains(rb_obj_as_string(value), "gzip")) {
+    setopt_or_raise(s->easy, CURLOPT_ACCEPT_ENCODING, "gzip");
+  }
 
-  return 0;
+  line = rb_sprintf("%"PRIsVALUE": %"PRIsVALUE, name, value);
+  s->headers = curl_slist_append(s->headers, StringValueCStr(line));
+  return ST_CONTINUE;
 }
 
-// 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, (curl_off_t) RSTRING_LEN(state->upload_data));
-  #else
-    curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, (long) RSTRING_LEN(state->upload_data));
-  #endif
+static curl_mimepart *add_mime_part(struct patron_session *s, VALUE key) {
+  curl_mimepart *part;
+  VALUE name = rb_obj_as_string(key);
+
+  if (!s->mime) s->mime = curl_mime_init(s->easy);
+  part = curl_mime_addpart(s->mime);
+  if (!part) rb_memerror();
+  curl_mime_name(part, StringValueCStr(name));
+  return part;
 }
 
-static void set_chunked_encoding(struct patron_curl_state *state) {
-  state->headers = curl_slist_append(state->headers, "Transfer-Encoding: chunked");
+static int each_mime_value(VALUE key, VALUE value, VALUE self) {
+  struct patron_session *s = get_session(self);
+  VALUE str = rb_obj_as_string(value);
+  curl_mimepart *part = add_mime_part(s, key);
+
+  /* curl_mime_data() copies, so the String may be collected right after this call. */
+  curl_mime_data(part, RSTRING_PTR(str), (size_t)RSTRING_LEN(str));
+  return ST_CONTINUE;
 }
 
-static FILE* open_file(VALUE filename, const char* perms) {
-  FILE* handle = fopen(StringValueCStr(filename), perms);
-  if (!handle) {
-    rb_raise(rb_eArgError, "Unable to open specified file.");
+static int each_mime_file(VALUE key, VALUE value, VALUE self) {
+  struct patron_session *s = get_session(self);
+  VALUE path = rb_obj_as_string(value);
+  curl_mimepart *part = add_mime_part(s, key);
+
+  FilePathValue(path);
+  if (curl_mime_filedata(part, StringValueCStr(path)) != CURLE_OK) {
+    rb_raise(rb_eArgError, "Unable to read file for multipart upload: %"PRIsVALUE, path);
   }
+  return ST_CONTINUE;
+}
+
+static FILE *open_file(VALUE filename, const char *mode) {
+  FILE *handle;
 
+  FilePathValue(filename);
+  handle = fopen(StringValueCStr(filename), mode);
+  if (!handle) rb_sys_fail_str(filename);
   return handle;
 }
 
-static void set_request_body_file(struct patron_curl_state* state, VALUE r_path_str) {
-  CURL* curl = state->handle;
-  
-  state->request_body_file = open_file(r_path_str, "rb");
-  curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
-  curl_easy_setopt(curl, CURLOPT_READDATA, state->request_body_file);
-  struct stat stat_info;
-  fstat(fileno(state->request_body_file), &stat_info);
-  #ifdef CURLOPT_INFILESIZE_LARGE
-    curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, stat_info.st_size);
-  #else
-    curl_easy_setopt(curl, CURLOPT_INFILESIZE, stat_info.st_size);
-  #endif
-}
+static void set_request_body_from_file(struct patron_session *s, VALUE path) {
+  struct stat st;
+
+  s->request_body_file = open_file(path, "rb");
+  if (fstat(fileno(s->request_body_file), &st) != 0) rb_sys_fail_str(path);
 
-static long floating_rb_seconds_to_milliseconds(VALUE r_seconds) {
-  double seconds_f = NUM2DBL(r_seconds);
-  long millis = seconds_f * (double)1000.0;
-  return millis;
+  setopt_or_raise(s->easy, CURLOPT_UPLOAD, 1L);
+  setopt_or_raise(s->easy, CURLOPT_READFUNCTION, file_read_cb);
+  setopt_or_raise(s->easy, CURLOPT_READDATA, s->request_body_file);
+  setopt_or_raise(s->easy, CURLOPT_INFILESIZE_LARGE, (curl_off_t)st.st_size);
 }
 
-static void set_request_body(struct patron_curl_state* state, VALUE stringable_or_file) {
-  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
-    // file path on the file system and open a file pointer to it
-    VALUE r_path_str = rb_funcall(stringable_or_file, rb_intern("to_path"), 0);
-    r_path_str = rb_funcall(r_path_str, rb_intern("to_s"), 0);
-    set_request_body_file(state, r_path_str);
+static void set_request_body(struct patron_session *s, VALUE stringable_or_file) {
+  if (rb_respond_to(stringable_or_file, id_to_path)) {
+    VALUE path = rb_funcallv(stringable_or_file, id_to_path, 0, NULL);
+    set_request_body_from_file(s, rb_obj_as_string(path));
   } else {
-    // Set the request body from a String
-    set_curl_request_body(state, rb_funcall(stringable_or_file, rb_intern("to_s"), 0));
+    VALUE data = rb_obj_as_string(stringable_or_file);
+    SESSION_WRITE(s, upload_data, data);
+    setopt_or_raise(s->easy, CURLOPT_POSTFIELDSIZE_LARGE, (curl_off_t)RSTRING_LEN(data));
+    setopt_or_raise(s->easy, CURLOPT_POSTFIELDS, RSTRING_PTR(data));
   }
 }
 
-/* Set the options on the Curl handle from a Request object. Takes each field
- * in the Request object and uses it to set the appropriate option on the Curl
- * handle.
- */
-static void set_options_from_request(VALUE self, VALUE request) {
-  struct patron_curl_state* state = get_patron_curl_state(self);
-  CURL* curl = curl_easy_duphandle(state->base_handle);
-
-  ID    action                = Qnil;
-  VALUE headers               = Qnil;
-  VALUE url                   = Qnil;
-  VALUE timeout               = Qnil;
-  VALUE redirects             = Qnil;
-  VALUE proxy                 = Qnil;
-  VALUE proxy_type            = Qnil;
-  VALUE credentials           = Qnil;
-  VALUE ignore_content_length = Qnil;
-  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           = 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 = (curl_off_t) NUM2LL(download_byte_limit);
-  } else {
-    state->download_byte_limit = 0;
-  }
+static long seconds_to_milliseconds(VALUE seconds) {
+  return (long)(NUM2DBL(seconds) * 1000.0);
+}
 
-  if (rb_obj_is_proc(maybe_progress_proc)) {
-    state->user_progress_blk = maybe_progress_proc;
-  } else {
-    state->user_progress_blk = Qnil;
-  }
+static long lookup_version(VALUE table, VALUE requested, VALUE error_class, const char *what) {
+  VALUE key = rb_obj_as_string(requested);
+  VALUE found = rb_hash_lookup2(table, key, Qundef);
+
+  if (found == Qundef) rb_raise(error_class, "Unsupported %s: %"PRIsVALUE, what, key);
+  return NUM2LONG(found);
+}
+
+static void set_string_option(struct patron_session *s, CURLoption option, VALUE value, int is_path) {
+  VALUE str = is_path ? rb_funcallv(value, id_to_s, 0, NULL) : rb_obj_as_string(value);
+  if (is_path) FilePathValue(str);
+  setopt_or_raise(s->easy, option, StringValueCStr(str));
+}
+
+static void set_options_from_request(struct patron_session *s, VALUE request) {
+  VALUE self = s->self;
+  CURL *easy;
+  VALUE action_name, headers, url, value, upload_data, file_name;
+  ID action;
 
-  headers = rb_funcall(request, rb_intern("headers"), 0);
+  easy = curl_easy_duphandle(s->base);
+  if (!easy) rb_memerror();
+  /* Assigned before anything can raise so that cleanup() releases it. */
+  s->easy = easy;
+  /* duphandle() hands back a handle "as if CURLOPT_SHARE was unset" (its man page), so the
+   * share with the cookies and TLS sessions must be attached to every request handle anew. */
+  curl_easy_setopt(easy, CURLOPT_SHARE, s->share);
+
+  value = request_attr(request, id_download_byte_limit);
+  s->download_byte_limit = RTEST(value) ? NUM2OFFT(value) : 0;
+
+  value = request_attr(request, id_progress_callback);
+  SESSION_WRITE(s, progress_proc, rb_obj_is_proc(value) ? value : Qnil);
+
+  headers = request_attr(request, id_headers);
   if (RTEST(headers)) {
-    if (rb_type(headers) != T_HASH) {
-      rb_raise(rb_eArgError, "Headers must be passed in a hash.");
-    }
+    Check_Type(headers, T_HASH);
     rb_hash_foreach(headers, each_http_header, self);
   }
 
-  action = SYM2ID(action_name);
-  if (RTEST(rb_funcall(request, rb_intern("force_ipv4"), 0))) {
-    curl_easy_setopt(curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
+  if (RTEST(request_attr(request, id_force_ipv4))) {
+    setopt_or_raise(easy, CURLOPT_IPRESOLVE, (long)CURL_IPRESOLVE_V4);
   }
-  if (action == rb_intern("get")) {
-    VALUE data = rb_funcall(request, rb_intern("upload_data"), 0);
-    VALUE download_file = rb_funcall(request, rb_intern("file_name"), 0);
-
-    curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);
-    if (RTEST(data)) {
-      set_request_body(state, data);
-      curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "GET");
-    }
-    if (RTEST(download_file)) {
-      // we need the WRITEDATA option for the file destination
-      state->download_file = open_file(download_file, "wb");
-      curl_easy_setopt(curl, CURLOPT_WRITEDATA, state->download_file);
-      // curl docs say that CURLOPT_WRITEFUNCTION must be set too
-      // to avoid issues on Windows
-      curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &file_write_handler);
-    } else {
-      state->download_file = NULL;
+
+  action_name = request_attr(request, id_action);
+  action = SYM2ID(action_name);
+  upload_data = request_attr(request, id_upload_data);
+  file_name = request_attr(request, id_file_name);
+
+  if (action == id_get) {
+    setopt_or_raise(easy, CURLOPT_HTTPGET, 1L);
+    if (RTEST(upload_data)) {
+      set_request_body(s, upload_data);
+      setopt_or_raise(easy, CURLOPT_CUSTOMREQUEST, "GET");
     }
-  } else if (action == rb_intern("post") || action == rb_intern("put") || action == rb_intern("patch")) {
-    VALUE data = rb_funcall(request, rb_intern("upload_data"), 0);
-    VALUE filename = rb_funcall(request, rb_intern("file_name"), 0);
-    VALUE multipart = rb_funcall(request, rb_intern("multipart"), 0);
-
-    if (action == rb_intern("post")) {
-      curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
-    } else if (action == rb_intern("put")) {
-      curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
-    } else if (action == rb_intern("patch")) {
-      curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PATCH");
+    if (RTEST(file_name)) {
+      s->download_file = open_file(file_name, "wb");
+      SESSION_WRITE(s, body_buf, Qnil);
     }
-    
-    if (RTEST(data) && !RTEST(multipart)) {
-      if (action == rb_intern("post")) {
-        curl_easy_setopt(curl, CURLOPT_POST, 1);
+  } else if (action == id_post || action == id_put || action == id_patch) {
+    VALUE multipart = request_attr(request, id_multipart);
+    const char *verb = action == id_post ? "POST" : action == id_put ? "PUT" : "PATCH";
+
+    setopt_or_raise(easy, CURLOPT_CUSTOMREQUEST, verb);
+
+    if (RTEST(multipart)) {
+      if (RTEST(upload_data)) {
+        Check_Type(upload_data, T_HASH);
+        rb_hash_foreach(upload_data, each_mime_value, self);
       }
-      set_request_body(state, data);
-    } else if (RTEST(filename) && !RTEST(multipart)) {
-      set_chunked_encoding(state);
-      set_request_body_file(state, filename);
-    } else if (RTEST(multipart)) {
-      if (action == rb_intern("post")) {
-        if(RTEST(data) && RTEST(filename)) {
-          if (rb_type(data) == T_HASH && rb_type(filename) == T_HASH) {
-            rb_hash_foreach(data, formadd_values, self);
-            rb_hash_foreach(filename, formadd_files, self);
-          } else {
-            rb_raise(rb_eArgError, "Data and Filename must be passed in a hash.");
-          }
-        }
-        curl_easy_setopt(curl, CURLOPT_HTTPPOST, state->post);
-      } else {
-         rb_raise(rb_eArgError, "Multipart PUT not supported");
+      if (RTEST(file_name)) {
+        Check_Type(file_name, T_HASH);
+        rb_hash_foreach(file_name, each_mime_file, self);
       }
-
+      if (!s->mime) s->mime = curl_mime_init(easy);
+      setopt_or_raise(easy, CURLOPT_MIMEPOST, s->mime);
+    } else if (RTEST(upload_data)) {
+      if (action == id_post) setopt_or_raise(easy, CURLOPT_POST, 1L);
+      set_request_body(s, upload_data);
+    } else if (RTEST(file_name)) {
+      s->headers = curl_slist_append(s->headers, "Transfer-Encoding: chunked");
+      set_request_body_from_file(s, rb_obj_as_string(file_name));
     } else {
-      rb_raise(rb_eArgError, "Must provide either data or a filename when doing a PUT or POST");
+      rb_raise(rb_eArgError, "Must provide either data or a filename when doing a PUT, POST or PATCH");
     }
-
-  // support for data passed with a DELETE request (e.g.: used by elasticsearch)
-  } else if (action == rb_intern("delete")) {
-      VALUE data = rb_funcall(request, rb_intern("upload_data"), 0);
-      if (RTEST(data)) {
-        curl_easy_setopt(curl, CURLOPT_POST, 1);
-        set_request_body(state, data);
-      }
-      curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
-
-  } else if (action == rb_intern("head")) {
-    curl_easy_setopt(curl, CURLOPT_NOBODY, 1);
+  } else if (action == id_delete) {
+    if (RTEST(upload_data)) {
+      setopt_or_raise(easy, CURLOPT_POST, 1L);
+      set_request_body(s, upload_data);
+    }
+    setopt_or_raise(easy, CURLOPT_CUSTOMREQUEST, "DELETE");
+  } else if (action == id_head) {
+    setopt_or_raise(easy, CURLOPT_NOBODY, 1L);
   } else {
-    VALUE action_name = rb_funcall(request, rb_intern("action_name"), 0);
-    curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, StringValuePtr(action_name));
+    VALUE verb = request_attr(request, id_action_name);
+    setopt_or_raise(easy, CURLOPT_CUSTOMREQUEST, StringValueCStr(verb));
   }
 
-  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, state->headers);
-  curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, state->error_buf);
-
-  // Enable automatic content-encoding support via gzip/deflate if set in the request,
-  // see https://curl.haxx.se/libcurl/c/CURLOPT_ACCEPT_ENCODING.html
-  if(RTEST(a_c_encoding)) {
-    #ifdef CURLOPT_ACCEPT_ENCODING
-      curl_easy_setopt(curl, CURLOPT_ACCEPT_ENCODING, "");
-    #elif defined CURLOPT_ENCODING
-      curl_easy_setopt(curl, CURLOPT_ENCODING, "");
-    #else
-      rb_raise(rb_eArgError,
-        "The libcurl version installed doesn't support automatic content negotiation");
-    #endif
-  }
-  
-  url = rb_funcall(request, rb_intern("url"), 0);
-  if (!RTEST(url)) {
-    rb_raise(rb_eArgError, "Must provide a URL");
-  }
-  curl_easy_setopt(curl, CURLOPT_URL, StringValuePtr(url));
-  
-    
-  timeout = rb_funcall(request, rb_intern("timeout"), 0);
-  if (RTEST(timeout)) {
-    curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, floating_rb_seconds_to_milliseconds(timeout));
-  }
+  setopt_or_raise(easy, CURLOPT_HTTPHEADER, s->headers);
 
-  timeout = rb_funcall(request, rb_intern("connect_timeout"), 0);
-  if (RTEST(timeout)) {
-    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT_MS, floating_rb_seconds_to_milliseconds(timeout));
+  if (RTEST(request_attr(request, id_automatic_content_encoding))) {
+    setopt_or_raise(easy, CURLOPT_ACCEPT_ENCODING, "");
   }
 
-  timeout = rb_funcall(request, rb_intern("dns_cache_timeout"), 0);
-  if (RTEST(timeout)) {
-    curl_easy_setopt(curl, CURLOPT_DNS_CACHE_TIMEOUT, NUM2LONG(timeout));
-  }
+  url = request_attr(request, id_url);
+  if (!RTEST(url)) rb_raise(rb_eArgError, "Must provide a URL");
+  set_string_option(s, CURLOPT_URL, url, 0);
 
-  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, NUM2LONG(low_speed_time));
-  }
+  value = request_attr(request, id_timeout);
+  if (RTEST(value)) setopt_or_raise(easy, CURLOPT_TIMEOUT_MS, seconds_to_milliseconds(value));
 
-  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, NUM2LONG(low_speed_limit_bytes_per_second));
-  }
+  value = request_attr(request, id_connect_timeout);
+  if (RTEST(value)) setopt_or_raise(easy, CURLOPT_CONNECTTIMEOUT_MS, seconds_to_milliseconds(value));
 
-  redirects = rb_funcall(request, rb_intern("max_redirects"), 0);
-  if (RTEST(redirects)) {
-    long r = NUM2LONG(redirects);
-    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, r == 0 ? 0 : 1);
-    curl_easy_setopt(curl, CURLOPT_MAXREDIRS, r);
-  }
+  value = request_attr(request, id_dns_cache_timeout);
+  if (RTEST(value)) setopt_or_raise(easy, CURLOPT_DNS_CACHE_TIMEOUT, NUM2LONG(value));
 
-  proxy = rb_funcall(request, rb_intern("proxy"), 0);
-  if (RTEST(proxy)) {
-    curl_easy_setopt(curl, CURLOPT_PROXY, StringValuePtr(proxy));
-  }
+  value = request_attr(request, id_low_speed_time);
+  if (RTEST(value)) setopt_or_raise(easy, CURLOPT_LOW_SPEED_TIME, NUM2LONG(value));
 
-  proxy_type = rb_funcall(request, rb_intern("proxy_type"), 0);
-  if (RTEST(proxy_type)) {
-    curl_easy_setopt(curl, CURLOPT_PROXYTYPE, NUM2LONG(proxy_type));
-  }
+  value = request_attr(request, id_low_speed_limit);
+  if (RTEST(value)) setopt_or_raise(easy, CURLOPT_LOW_SPEED_LIMIT, NUM2LONG(value));
 
-  credentials = rb_funcall(request, rb_intern("credentials"), 0);
-  if (RTEST(credentials)) {
-    VALUE auth_type = rb_funcall(request, rb_intern("auth_type"), 0);
-    curl_easy_setopt(curl, CURLOPT_HTTPAUTH, NUM2LONG(auth_type));
-    curl_easy_setopt(curl, CURLOPT_USERPWD, StringValuePtr(credentials));
+  value = request_attr(request, id_max_redirects);
+  if (RTEST(value)) {
+    long redirects = NUM2LONG(value);
+    setopt_or_raise(easy, CURLOPT_FOLLOWLOCATION, redirects == 0 ? 0L : 1L);
+    setopt_or_raise(easy, CURLOPT_MAXREDIRS, redirects);
   }
 
-  ignore_content_length = rb_funcall(request, rb_intern("ignore_content_length"), 0);
-  if (RTEST(ignore_content_length)) {
-    curl_easy_setopt(curl, CURLOPT_IGNORE_CONTENT_LENGTH, 1);
-  }
+  value = request_attr(request, id_proxy);
+  if (RTEST(value)) set_string_option(s, CURLOPT_PROXY, value, 0);
 
-  insecure = rb_funcall(request, rb_intern("insecure"), 0);
-  if(RTEST(insecure)) {
-    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
-    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0);
-  }
+  value = request_attr(request, id_proxy_type);
+  if (RTEST(value)) setopt_or_raise(easy, CURLOPT_PROXYTYPE, NUM2LONG(value));
 
-  ssl_version = rb_funcall(request, rb_intern("ssl_version"), 0);
-  if(RTEST(ssl_version)) {
-    VALUE ssl_version_str = rb_funcall(ssl_version, rb_intern("to_s"), 0);
-    char* version = StringValuePtr(ssl_version_str);
-
-    if(strcmp(version, "SSLv2") == 0) {
-      curl_easy_setopt(curl, CURLOPT_SSLVERSION, CURL_SSLVERSION_SSLv2);
-    } else if(strcmp(version, "SSLv3") == 0) {
-      curl_easy_setopt(curl, CURLOPT_SSLVERSION, CURL_SSLVERSION_SSLv3);
-    } else if(strcmp(version, "TLSv1") == 0) {
-          curl_easy_setopt(curl, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1);
-    }
-    #if LIBCURL_VERSION_NUM >= 0x072200
-    /* this is libCURLv7.34.0 or later */
-    else if(strcmp(version, "TLSv1_0") == 0) {
-      curl_easy_setopt(curl, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_0); //libcurl v7.34.0+
-    } else if(strcmp(version, "TLSv1_1") == 0) {
-      curl_easy_setopt(curl, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_1); //libcurl v7.34.0+
-    } else if(strcmp(version, "TLSv1_2") == 0) {
-      curl_easy_setopt(curl, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_2); //libcurl v7.34.0+
-    }
-    #endif
-    #if LIBCURL_VERSION_NUM >= 0x073400
-    /* this is libCURLv7.52.0 or later */
-    else if(strcmp(version, "TLSv1_3") == 0) {
-      curl_easy_setopt(curl, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_3); //libcurl v7.52.0+
-    }
-    #endif
-    else {
-      rb_raise(eUnsupportedSSLVersion, "Unsupported SSL version: %s", version);
-    }
+  value = request_attr(request, id_credentials);
+  if (RTEST(value)) {
+    setopt_or_raise(easy, CURLOPT_HTTPAUTH, NUM2LONG(request_attr(request, id_auth_type)));
+    set_string_option(s, CURLOPT_USERPWD, value, 0);
   }
 
-  http_version = rb_funcall(request, rb_intern("http_version"), 0);
-  if(RTEST(http_version)) {
-    VALUE http_version_str = rb_funcall(http_version, rb_intern("to_s"), 0);
-    char* version = StringValuePtr(http_version_str);
-    if(strcmp(version, "None") == 0) {
-      curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_NONE);
-    } else if(strcmp(version, "HTTPv1_0") == 0) {
-      curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
-    } else if(strcmp(version, "HTTPv1_1") == 0) {
-          curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
-    }
-    #if LIBCURL_VERSION_NUM >= 0x072100
-    /* this is libCURLv7.33.0 or later */
-    else if(strcmp(version, "HTTPv2_0") == 0) {
-      curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0); //libcurl v7.33.0+
-    }
-    #endif
-    #if LIBCURL_VERSION_NUM >= 0x072F00
-    /* this is libCURLv7.47.0 or later */
-    else if(strcmp(version, "HTTPv2_TLS") == 0) {
-      curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2TLS); //libcurl v7.47.0+
-    }
-    #endif
-    #if LIBCURL_VERSION_NUM >= 0x073100
-    /* this is libCURLv7.49.0 or later */
-    else if(strcmp(version, "HTTPv2_PRIOR") == 0) {
-      curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE); //libcurl v7.49.0+
-    }
-    #endif
-    else {
-      rb_raise(eUnsupportedHTTPVersion, "Unsupported HTTP version: %s", version);
-    }
+  if (RTEST(request_attr(request, id_ignore_content_length))) {
+    setopt_or_raise(easy, CURLOPT_IGNORE_CONTENT_LENGTH, 1L);
   }
 
-  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));
+  if (RTEST(request_attr(request, id_insecure))) {
+    setopt_or_raise(easy, CURLOPT_SSL_VERIFYPEER, 0L);
+    setopt_or_raise(easy, CURLOPT_SSL_VERIFYHOST, 0L);
   }
 
-  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));
+  value = request_attr(request, id_ssl_version);
+  if (RTEST(value)) {
+    setopt_or_raise(easy, CURLOPT_SSLVERSION, lookup_version(hSSLVersions, value, eUnsupportedSSLVersion, "SSL version"));
   }
 
-  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));
+  value = request_attr(request, id_http_version);
+  if (RTEST(value)) {
+    setopt_or_raise(easy, CURLOPT_HTTP_VERSION, lookup_version(hHTTPVersions, value, eUnsupportedHTTPVersion, "HTTP version"));
   }
 
-  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));
-  }
+  value = request_attr(request, id_ssl_cert);
+  if (RTEST(value)) set_string_option(s, CURLOPT_SSLCERT, value, 1);
 
-  cacert = rb_funcall(request, rb_intern("cacert"), 0);
-  if(RTEST(cacert)) {
-    cacert = FilePathValue(cacert);
-    curl_easy_setopt(curl, CURLOPT_CAINFO, StringValueCStr(cacert));
-  }
+  value = request_attr(request, id_ssl_cert_type);
+  if (RTEST(value)) set_string_option(s, CURLOPT_SSLCERTTYPE, value, 0);
 
-  buffer_size = rb_funcall(request, rb_intern("buffer_size"), 0);
-  if (RTEST(buffer_size)) {
-     curl_easy_setopt(curl, CURLOPT_BUFFERSIZE, NUM2LONG(buffer_size));
-  }
+  value = request_attr(request, id_ssl_key);
+  if (RTEST(value)) set_string_option(s, CURLOPT_SSLKEY, value, 1);
+
+  value = request_attr(request, id_ssl_key_password);
+  if (RTEST(value)) set_string_option(s, CURLOPT_KEYPASSWD, value, 0);
+
+  value = request_attr(request, id_cacert);
+  if (RTEST(value)) set_string_option(s, CURLOPT_CAINFO, value, 1);
+
+  value = request_attr(request, id_buffer_size);
+  if (RTEST(value)) setopt_or_raise(easy, CURLOPT_BUFFERSIZE, NUM2LONG(value));
 }
 
-/* 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));
+/*----------------------------------------------------------------------------*/
+/* Response                                                                   */
+
+static void set_timing(CURL *easy, VALUE timings, const char *key, CURLINFO info) {
+  curl_off_t microseconds = 0;
+  if (curl_easy_getinfo(easy, info, &microseconds) == CURLE_OK) {
+    rb_hash_aset(timings, ID2SYM(rb_intern(key)), rb_float_new((double)microseconds / 1000000.0));
   }
 }
 
-/* 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) {
+/* libcurl's cumulative transfer marks in seconds since the request started:
+ * namelookup <= connect <= appconnect <= pretransfer <= starttransfer <= total. */
+static VALUE create_timings(CURL *easy) {
   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);
+  set_timing(easy, timings, "namelookup",    CURLINFO_NAMELOOKUP_TIME_T);
+  set_timing(easy, timings, "connect",       CURLINFO_CONNECT_TIME_T);
+  set_timing(easy, timings, "appconnect",    CURLINFO_APPCONNECT_TIME_T);
+  set_timing(easy, timings, "pretransfer",   CURLINFO_PRETRANSFER_TIME_T);
+  set_timing(easy, timings, "starttransfer", CURLINFO_STARTTRANSFER_TIME_T);
+  set_timing(easy, timings, "redirect",      CURLINFO_REDIRECT_TIME_T);
+  set_timing(easy, timings, "total",         CURLINFO_TOTAL_TIME_T);
   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 };
-  char* effective_url = NULL;
+static VALUE create_response(struct patron_session *s) {
+  VALUE self = s->self;
+  CURL *easy = s->easy;
+  VALUE kwargs = rb_hash_new();
+  char *effective_url = NULL;
   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] = LONG2NUM(code);
-
-  curl_easy_getinfo(curl, CURLINFO_REDIRECT_COUNT, &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);
-  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;
+  long redirect_count = 0;
+  VALUE klass;
+
+  curl_easy_getinfo(easy, CURLINFO_EFFECTIVE_URL, &effective_url);
+  curl_easy_getinfo(easy, CURLINFO_RESPONSE_CODE, &code);
+  curl_easy_getinfo(easy, CURLINFO_REDIRECT_COUNT, &redirect_count);
+
+  rb_hash_aset(kwargs, ID2SYM(id_url_kw), effective_url ? rb_usascii_str_new_cstr(effective_url) : Qnil);
+  rb_hash_aset(kwargs, ID2SYM(id_status_kw), LONG2NUM(code));
+  rb_hash_aset(kwargs, ID2SYM(id_redirect_count_kw), LONG2NUM(redirect_count));
+  rb_hash_aset(kwargs, ID2SYM(id_header_data_kw), s->header_buf);
+  rb_hash_aset(kwargs, ID2SYM(id_body_kw), s->body_buf);
+  rb_hash_aset(kwargs, ID2SYM(id_default_charset_kw), rb_funcallv(self, id_default_response_charset, 0, NULL));
+  rb_hash_aset(kwargs, ID2SYM(id_timings_kw), create_timings(easy));
+
+  klass = rb_funcallv(self, id_response_class, 0, NULL);
+  return rb_class_new_instance_kw(1, &kwargs, klass, RB_PASS_KEYWORDS);
 }
 
-/* Raise an exception based on the Curl error code. */
-static VALUE select_error(CURLcode code) {
-  VALUE error = Qnil;
-  switch (code) {
-    case CURLE_UNSUPPORTED_PROTOCOL:  error = eUnsupportedProtocol; break;
-    case CURLE_URL_MALFORMAT:         error = eURLFormatError;      break;
-    case CURLE_COULDNT_RESOLVE_HOST:  error = eHostResolutionError; break;
-    case CURLE_COULDNT_CONNECT:       error = eConnectionFailed;    break;
-    case CURLE_PARTIAL_FILE:          error = ePartialFileError;    break;
-    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;
-  }
+/*----------------------------------------------------------------------------*/
+/* Performing a request                                                       */
 
-  return error;
-}
+struct poll_context {
+  CURLM *multi;
+  CURLMcode rc;
+};
 
+static void *poll_without_gvl(void *ptr) {
+  struct poll_context *ctx = ptr;
+  ctx->rc = curl_multi_poll(ctx->multi, NULL, 0, POLL_TIMEOUT_MS, NULL);
+  return NULL;
+}
 
-struct perform_context {
-  CURL *curl;
-  CURLcode code;
-};
+/* Runs without the GVL whenever Ruby needs this thread back (Thread#kill, Thread#raise,
+ * signals, interpreter exit). Only wakes the poll; Ruby decides after it returns whether
+ * there is an exception to raise. */
+static void wakeup_poll(void *ptr) {
+  struct patron_session *s = ptr;
+  curl_multi_wakeup(s->multi);
+}
 
-static void *perform_without_gvl(void *ptr) {
-  struct perform_context *context = ptr;
+/* Blocks the whole thread until libcurl has something to do, with the GVL released */
+static void wait_without_scheduler(struct patron_session *s) {
+  struct poll_context ctx = { s->multi, CURLM_OK };
+  /* Pending Ruby interrupts are raised right here as rb_nogvl returns; the rb_ensure
+   * around the request takes care of the half-finished transfer. */
+  rb_nogvl(poll_without_gvl, &ctx, wakeup_poll, s, RB_NOGVL_UBF_ASYNC_SAFE);
+  if (ctx.rc != CURLM_OK) rb_raise(ePatronError, "%s", curl_multi_strerror(ctx.rc));
+}
 
-  context->code = curl_easy_perform(context->curl);
-  return NULL;
+static VALUE float_seconds(long milliseconds) {
+  return rb_float_new((double)milliseconds / 1000.0);
 }
 
-/* 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,
-   but we _are_ permitted to touch our internal curl state struct
-*/
-void session_ubf_abort(void* patron_state) {
-  struct patron_curl_state* state = (struct patron_curl_state*) patron_state;
-  state->interrupt = INTERRUPT_ABORT;
+/* An IO wrapping one of libcurl's sockets, for handing to the scheduler. FMODE_EXTERNAL keeps
+ * Ruby from ever closing the descriptor; libcurl owns it. The wrappers are dropped whenever the
+ * set of sockets changes, so a descriptor number the kernel reused gets a fresh one. */
+static VALUE socket_io(struct patron_session *s, int fd) {
+  VALUE key = INT2FIX(fd);
+  VALUE io = rb_hash_lookup2(s->socket_ios, key, Qnil);
+
+  if (NIL_P(io)) {
+    io = rb_io_open_descriptor(rb_cIO, fd, FMODE_READWRITE | FMODE_EXTERNAL, Qnil, Qnil, NULL);
+    rb_hash_aset(s->socket_ios, key, io);
+  }
+  return io;
 }
 
-/* Perform the actual HTTP request by calling libcurl. */
-static VALUE perform_request(VALUE self) {
-  struct patron_curl_state *state = get_patron_curl_state(self);
-  CURL* curl = state->handle;
-  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);
+#define MAX_WAIT_FDS 16
+
+/* Yields to the Fiber scheduler until libcurl has something to do, so other fibers on this thread
+ * run meanwhile. Uses io_wait for the usual single socket, io_select when libcurl juggles several
+ * (happy eyeballs), and a plain sleep while it has none (threaded resolver at work). */
+static void wait_with_scheduler(struct patron_session *s, VALUE scheduler) {
+  fd_set rd, wr, ex;
+  int maxfd = -1, fd, nfds = 0, i;
+  int fds[MAX_WAIT_FDS], events[MAX_WAIT_FDS];
+  long timeout_ms = -1;
+  VALUE timeout;
+
+  FD_ZERO(&rd); FD_ZERO(&wr); FD_ZERO(&ex);
+  curl_multi_fdset(s->multi, &rd, &wr, &ex, &maxfd);
+  curl_multi_timeout(s->multi, &timeout_ms);
+  if (timeout_ms < 0 || timeout_ms > POLL_TIMEOUT_MS) timeout_ms = POLL_TIMEOUT_MS;
+
+  for (fd = 0; fd <= maxfd && nfds < MAX_WAIT_FDS; fd++) {
+    int ev = 0;
+    if (FD_ISSET(fd, &rd)) ev |= RUBY_IO_READABLE;
+    if (FD_ISSET(fd, &wr)) ev |= RUBY_IO_WRITABLE;
+    if (FD_ISSET(fd, &ex)) ev |= RUBY_IO_PRIORITY;
+    if (!ev) continue;
+    fds[nfds] = fd;
+    events[nfds] = ev;
+    nfds++;
+  }
+
+  if (nfds == 0) {
+    /* libcurl asks to be called back within 100 ms when it has no socket to wait on */
+    if (timeout_ms > 100) timeout_ms = 100;
+    rb_fiber_scheduler_kernel_sleep(scheduler, float_seconds(timeout_ms));
+    return;
+  }
+
+  if (NIL_P(s->socket_ios)) SESSION_WRITE(s, socket_ios, rb_hash_new());
+  if (RHASH_SIZE(s->socket_ios) != (st_index_t)nfds) rb_hash_clear(s->socket_ios);
+  for (i = 0; i < nfds; i++) {
+    if (rb_hash_lookup2(s->socket_ios, INT2FIX(fds[i]), Qundef) == Qundef) {
+      rb_hash_clear(s->socket_ios);
+      break;
     }
-    rb_jump_tag(tag);
   }
 
-  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); }
-    
-    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(context.code), "%s", state->error_buf);
+  timeout = float_seconds(timeout_ms);
+  if (nfds == 1) {
+    rb_fiber_scheduler_io_wait(scheduler, socket_io(s, fds[0]), INT2NUM(events[0]), timeout);
+    return;
   }
-}
 
-/* 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);
+  {
+    VALUE readables = rb_ary_new(), writables = rb_ary_new(), exceptables = rb_ary_new();
+    VALUE ready;
+
+    for (i = 0; i < nfds; i++) {
+      VALUE io = socket_io(s, fds[i]);
+      if (events[i] & RUBY_IO_READABLE) rb_ary_push(readables, io);
+      if (events[i] & RUBY_IO_WRITABLE) rb_ary_push(writables, io);
+      if (events[i] & RUBY_IO_PRIORITY) rb_ary_push(exceptables, io);
+    }
+    ready = rb_fiber_scheduler_io_select(scheduler, readables, writables, exceptables, timeout);
+    if (ready == Qundef) {
+      /* A scheduler without io_select; poll instead. Only ever happens while connecting. */
+      rb_fiber_scheduler_kernel_sleep(scheduler, float_seconds(timeout_ms > 50 ? 50 : timeout_ms));
+    }
+  }
 }
 
-/* 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;
+static void drive_transfer(struct patron_session *s) {
+  int running = 1;
+  CURLMcode mc;
+  /* Set per thread; a Session inside Async { } yields to it instead of blocking the thread */
+  VALUE scheduler = rb_fiber_scheduler_current();
 
-  if (state->headers) {
-    curl_slist_free_all(state->headers);
-    state->headers = NULL;
+  mc = curl_multi_add_handle(s->multi, s->easy);
+  if (mc != CURLM_OK) rb_raise(ePatronError, "%s", curl_multi_strerror(mc));
+
+  while (running) {
+    mc = curl_multi_perform(s->multi, &running);
+    if (mc != CURLM_OK) rb_raise(ePatronError, "%s", curl_multi_strerror(mc));
+    if (s->pending_tag || s->interrupt) break;
+    if (!running) break;
+
+    if (NIL_P(scheduler)) {
+      wait_without_scheduler(s);
+    } else {
+      wait_with_scheduler(s, scheduler);
+    }
+    if (s->interrupt) break;
   }
-  membuffer_clear(&state->header_buffer);
+}
 
-  if (state->download_file) {
-    fclose(state->download_file);
-    state->download_file = NULL;
-  } else {
-    membuffer_clear(&state->body_buffer);
+static CURLcode transfer_result(struct patron_session *s) {
+  CURLcode result = CURLE_OK;
+  CURLMsg *msg;
+  int remaining = 0;
+
+  while ((msg = curl_multi_info_read(s->multi, &remaining))) {
+    if (msg->msg == CURLMSG_DONE && msg->easy_handle == s->easy) result = msg->data.result;
   }
+  return result;
+}
 
-  if (state->request_body_file) {
-    fclose(state->request_body_file);
-    state->request_body_file = NULL;
+struct perform_args {
+  struct patron_session *s;
+  VALUE request;
+};
+
+static VALUE perform(VALUE ptr) {
+  struct perform_args *args = (struct perform_args *)ptr;
+  struct patron_session *s = args->s;
+  CURLcode result;
+
+  s->interrupt = 0;
+  s->pending_tag = 0;
+  s->error_buf[0] = '\0';
+  SESSION_WRITE(s, header_buf, rb_str_buf_new(HEADER_BUFFER_INITIAL_CAPACITY));
+  SESSION_WRITE(s, body_buf, rb_str_buf_new(BODY_BUFFER_INITIAL_CAPACITY));
+
+  set_options_from_request(s, args->request);
+  drive_transfer(s);
+
+  if (s->pending_tag) reraise_parked(s);
+
+  if (s->interrupt == INTERRUPT_DOWNLOAD_OVERFLOW) {
+    raise_curl_error(eDownloadLimitExceeded, CURLE_ABORTED_BY_CALLBACK, "Download byte limit exceeded");
   }
-  
-  if (state->post) {
-    curl_formfree(state->post);
-    state->post = NULL;
-    state->last = NULL;
+  if (s->interrupt) {
+    raise_curl_error(eAborted, CURLE_ABORTED_BY_CALLBACK, "Request interrupted");
   }
 
-  state->upload_data = Qnil;
-  state->pending_tag = 0;
-  state->pending_exception = Qnil;
-  state->busy = 0;
+  result = transfer_result(s);
+  if (result != CURLE_OK) raise_curl_error(error_class_for(result), result, s->error_buf);
+
+  /* Write the cookies accumulated in the share out to the jar, if one is configured */
+  curl_easy_setopt(s->easy, CURLOPT_COOKIELIST, "FLUSH");
 
+  return create_response(s);
+}
+
+/* Runs under rb_ensure after every request, whether it finished, raised or was interrupted. */
+static VALUE cleanup(VALUE self) {
+  struct patron_session *s = get_session(self);
+
+  if (s->easy) {
+    curl_multi_remove_handle(s->multi, s->easy);
+    curl_easy_cleanup(s->easy);
+    s->easy = NULL;
+  }
+  if (s->mime) {
+    curl_mime_free(s->mime);
+    s->mime = NULL;
+  }
+  if (s->headers) {
+    curl_slist_free_all(s->headers);
+    s->headers = NULL;
+  }
+  if (s->download_file) {
+    fclose(s->download_file);
+    s->download_file = NULL;
+  }
+  if (s->request_body_file) {
+    fclose(s->request_body_file);
+    s->request_body_file = NULL;
+  }
+
+  SESSION_WRITE(s, progress_proc, Qnil);
+  SESSION_WRITE(s, upload_data, Qnil);
+  SESSION_WRITE(s, header_buf, Qnil);
+  SESSION_WRITE(s, body_buf, Qnil);
+  s->download_byte_limit = 0;
+  s->busy = 0;
   return Qnil;
 }
 
 /*
- * Peform the actual HTTP request by calling libcurl. Each filed in the
- * +request+ object will be used to set the appropriate option on the libcurl
- * library. After the request completes, a Response object will be created and
- * returned.
+ * Performs the HTTP request described by +request+ and returns a Response built with
+ * #response_class. Raises a Patron::Error subclass when libcurl reports a failure.
  *
- * In the event of an error in the libcurl library, a Ruby exception will be
- * created and raised. The exception will return the libcurl error code and
- * error message.
- *
- * @param request[Patron::Request] the request to use when filling the CURL options
- * @return [Patron::Response] the result of calling `response_class` on the Session
+ * @param request [Patron::Request]
+ * @return [Patron::Response]
  */
 static VALUE session_handle_request(VALUE self, VALUE request) {
-  struct patron_curl_state *state = get_patron_curl_state(self);
-  VALUE args = Qnil;
+  struct patron_session *s = get_session(self);
+  struct perform_args args = { s, request };
 
-  if (state->busy) {
-    rb_raise(ePatronError, "Session is already performing a request on another thread; use one Session per thread");
+  if (s->busy) {
+    rb_raise(ePatronError, "This Session is already performing a request in another thread or fiber; use one Session per thread or fiber");
   }
-  state->busy = 1;
-
-  args = rb_ary_new3(2, self, request);
-  return rb_ensure(&prepare_and_perform_request, args, &cleanup, self);
+  ensure_handles_for_this_process(s);
+  s->busy = 1;
+  return rb_ensure(perform, (VALUE)&args, cleanup, self);
 }
 
-/* Interrupt any currently executing request. This will cause the current
- * request to error and raise an exception. The method can be called from another thread to
- * abort the request in-flight.
+/*
+ * Aborts the request currently in flight on this Session, which then raises Patron::Aborted.
+ * Safe to call from another thread.
  *
- * @return [void] This method always raises
+ * @return self
  */
 static VALUE session_interrupt(VALUE self) {
-  struct patron_curl_state *state = get_patron_curl_state(self);
-  state->interrupt = INTERRUPT_ABORT;
+  struct patron_session *s = get_session(self);
+
+  s->interrupt = INTERRUPT_ABORT;
+  if (s->multi) curl_multi_wakeup(s->multi);
   return self;
 }
 
 /*
- * Turn on cookie handling for this session, storing them in memory by
- * default or in +file+ if specified. The `file` must be readable and
- * writable. Calling multiple times will add more files.
- * FIXME: what does the empty string actually do here?
-* 
- * @param [String] file path to the existing cookie file, or nil to store in memory.
-*  @return self
+ * Enables cookie handling: in memory when +path+ is empty, otherwise read from and written
+ * back to the file at +path+.
  */
-static VALUE add_cookie_file(VALUE self, VALUE file) {
-  struct patron_curl_state *state = get_patron_curl_state(self);
-  CURL* curl = state->base_handle;
-  char* file_path = NULL;
-
-  // FIXME: http://websystemsengineering.blogspot.nl/2013/03/curloptcookiefile-vs-curloptcookiejar.html
-  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);
+static VALUE session_set_cookie_file(VALUE self, VALUE path) {
+  struct patron_session *s = get_session(self);
+  const char *file_path = StringValueCStr(path);
 
+  if (*file_path) setopt_or_raise(s->base, CURLOPT_COOKIEJAR, file_path);
+  setopt_or_raise(s->base, CURLOPT_COOKIEFILE, file_path);
   return self;
 }
 
 /*
- * Enable debug output to stderr or to specified +file+.
- *
- * @param [String, nil] file path to the debug file, or nil to write to STDERR
-*  @return self
+ * Sends libcurl's verbose output to +io+, or disables it when +io+ is nil.
  */
-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 = StringValueCStr(file);
+static VALUE session_set_debug_io(VALUE self, VALUE io) {
+  struct patron_session *s = get_session(self);
 
-  session_close_debug_file(state);
+  SESSION_WRITE(s, debug_io, io);
+  setopt_or_raise(s->base, CURLOPT_VERBOSE, NIL_P(io) ? 0L : 1L);
+  return self;
+}
 
-  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);
+/*----------------------------------------------------------------------------*/
+/* Init                                                                       */
 
-  return self;
+static VALUE shareable_table(void) {
+  return rb_hash_new();
 }
 
+static void table_entry(VALUE table, const char *name, long value) {
+  rb_hash_aset(table, rb_interned_str_cstr(name), LONG2NUM(value));
+}
 
-/*----------------------------------------------------------------------------*/
-/* Extension initialization                                                   */
+void Init_session_ext(void) {
+  /* Must precede the method definitions it applies to. There is no mutable global state:
+   * every handle belongs to one Session, and libcurl's own globals are initialised once here. */
+  rb_ext_ractor_safe(true);
 
-void Init_session_ext() {
   curl_global_init(CURL_GLOBAL_ALL);
   rb_require("patron/error");
-
-  rb_set_end_proc(&cs_list_interrupt, Qnil);
+  rb_require("patron/request");
+
+#define DEFINE_ID(name) id_##name = rb_intern_const(#name);
+  REQUEST_ATTRIBUTES(DEFINE_ID)
+#undef DEFINE_ID
+  id_to_path = rb_intern_const("to_path");
+  id_to_s = rb_intern_const("to_s");
+  id_response_class = rb_intern_const("response_class");
+  id_default_response_charset = rb_intern_const("default_response_charset");
+  id_get = rb_intern_const("get");
+  id_post = rb_intern_const("post");
+  id_put = rb_intern_const("put");
+  id_patch = rb_intern_const("patch");
+  id_delete = rb_intern_const("delete");
+  id_head = rb_intern_const("head");
+  id_ivar_curl_code = rb_intern_const("@curl_code");
+  id_url_kw = rb_intern_const("url");
+  id_status_kw = rb_intern_const("status");
+  id_redirect_count_kw = rb_intern_const("redirect_count");
+  id_header_data_kw = rb_intern_const("header_data");
+  id_body_kw = rb_intern_const("body");
+  id_default_charset_kw = rb_intern_const("default_charset");
+  id_timings_kw = rb_intern_const("timings");
 
   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 */
+  /* These are Ruby-defined classes and tables, not immortal rb_define_class() ones,
+   * so the GC has to know about the slots or compaction leaves them dangling */
+  rb_global_variable(&cRequest);
+  rb_global_variable(&hSSLVersions);
+  rb_global_variable(&hHTTPVersions);
   rb_global_variable(&ePatronError);
   rb_global_variable(&eUnsupportedProtocol);
   rb_global_variable(&eUnsupportedSSLVersion);
@@ -1160,10 +1259,10 @@ void Init_session_ext() {
   rb_global_variable(&eTimeoutError);
   rb_global_variable(&eTooManyRedirects);
   rb_global_variable(&eAborted);
+  rb_global_variable(&eDownloadLimitExceeded);
   rb_global_variable(&eClientCertificateError);
 
   ePatronError = rb_const_get(mPatron, rb_intern("Error"));
-
   eUnsupportedProtocol = rb_const_get(mPatron, rb_intern("UnsupportedProtocol"));
   eUnsupportedSSLVersion = rb_const_get(mPatron, rb_intern("UnsupportedSSLVersion"));
   eUnsupportedHTTPVersion = rb_const_get(mPatron, rb_intern("UnsupportedHTTPVersion"));
@@ -1174,38 +1273,60 @@ 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"));
+  eDownloadLimitExceeded = rb_const_get(mPatron, rb_intern("DownloadLimitExceeded"));
   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", libcurl_version, 0);
   rb_define_module_function(mPatron, "libcurl_version_exact", libcurl_version_exact, 0);
+  rb_define_module_function(mPatron, "libcurl_features", libcurl_features, 0);
 
   cSession = rb_define_class_under(mPatron, "Session", rb_cObject);
-  cRequest = rb_define_class_under(mPatron, "Request", rb_cObject);
+  /* Defined in Ruby; we only hang constants off it */
+  cRequest = rb_path2class("Patron::Request");
   rb_define_alloc_func(cSession, session_alloc);
 
-  // Make "escape" available both as a class method and as an instance method,
-  // to make it usable to the Util module which does not have access to
-  // the Session object internally
-  rb_define_singleton_method(cSession, "escape",   session_escape,         1);
-  rb_define_method(cSession, "escape",         session_escape,         1);
-  rb_define_singleton_method(cSession, "unescape",   session_unescape,         1);
-  rb_define_method(cSession, "unescape",       session_unescape,       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_private_method(cSession, "add_cookie_file", add_cookie_file, 1);
-  rb_define_private_method(cSession, "set_debug_file", set_debug_file, 1);
+  /* escape/unescape are available on the class as well, for Patron::Util */
+  rb_define_singleton_method(cSession, "escape", session_escape, 1);
+  rb_define_method(cSession, "escape", session_escape, 1);
+  rb_define_singleton_method(cSession, "unescape", session_unescape, 1);
+  rb_define_method(cSession, "unescape", session_unescape, 1);
   rb_define_alias(cSession, "urlencode", "escape");
   rb_define_alias(cSession, "urldecode", "unescape");
 
-  rb_define_const(cRequest, "AuthBasic",  LONG2NUM(CURLAUTH_BASIC));
+  rb_define_private_method(cSession, "handle_request", session_handle_request, 1);
+  rb_define_private_method(cSession, "set_cookie_file", session_set_cookie_file, 1);
+  rb_define_private_method(cSession, "set_debug_io", session_set_debug_io, 1);
+  rb_define_method(cSession, "interrupt", session_interrupt, 0);
+
+  rb_define_const(cRequest, "AuthBasic", LONG2NUM(CURLAUTH_BASIC));
   rb_define_const(cRequest, "AuthDigest", LONG2NUM(CURLAUTH_DIGEST));
-  rb_define_const(cRequest, "AuthAny",    LONG2NUM(CURLAUTH_ANY));
+  rb_define_const(cRequest, "AuthAny", LONG2NUM(CURLAUTH_ANY));
+
+  hSSLVersions = shareable_table();
+  table_entry(hSSLVersions, "TLSv1", CURL_SSLVERSION_TLSv1);
+  table_entry(hSSLVersions, "TLSv1_0", CURL_SSLVERSION_TLSv1_0);
+  table_entry(hSSLVersions, "TLSv1_1", CURL_SSLVERSION_TLSv1_1);
+  table_entry(hSSLVersions, "TLSv1_2", CURL_SSLVERSION_TLSv1_2);
+  table_entry(hSSLVersions, "TLSv1_3", CURL_SSLVERSION_TLSv1_3);
+  rb_define_const(cRequest, "SSL_VERSIONS", rb_ractor_make_shareable(hSSLVersions));
+
+  hHTTPVersions = shareable_table();
+  table_entry(hHTTPVersions, "None", CURL_HTTP_VERSION_NONE);
+  table_entry(hHTTPVersions, "HTTPv1_0", CURL_HTTP_VERSION_1_0);
+  table_entry(hHTTPVersions, "HTTPv1_1", CURL_HTTP_VERSION_1_1);
+  table_entry(hHTTPVersions, "HTTPv2_0", CURL_HTTP_VERSION_2_0);
+  table_entry(hHTTPVersions, "HTTPv2_TLS", CURL_HTTP_VERSION_2TLS);
+  table_entry(hHTTPVersions, "HTTPv2_PRIOR", CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE);
+  table_entry(hHTTPVersions, "HTTPv3", CURL_HTTP_VERSION_3);
+#if LIBCURL_VERSION_NUM >= 0x075800
+  table_entry(hHTTPVersions, "HTTPv3_ONLY", CURL_HTTP_VERSION_3ONLY);
+#endif
+  rb_define_const(cRequest, "HTTP_VERSIONS", rb_ractor_make_shareable(hHTTPVersions));
 
   mProxyType = rb_define_module_under(mPatron, "ProxyType");
   rb_define_const(mProxyType, "HTTP", LONG2NUM(CURLPROXY_HTTP));
   rb_define_const(mProxyType, "HTTP_1_0", LONG2NUM(CURLPROXY_HTTP_1_0));
+  rb_define_const(mProxyType, "HTTPS", LONG2NUM(CURLPROXY_HTTPS));
   rb_define_const(mProxyType, "SOCKS4", LONG2NUM(CURLPROXY_SOCKS4));
   rb_define_const(mProxyType, "SOCKS5", LONG2NUM(CURLPROXY_SOCKS5));
   rb_define_const(mProxyType, "SOCKS4A", LONG2NUM(CURLPROXY_SOCKS4A));