patron 1.0.0 → 1.1.0

data/ext/patron/session_ext.c

@@ -13,6 +13,13 @@
  * Thread#raise, Timeout and interpreter exit return promptly from any phase of a
  * transfer, including DNS and connect.
  *
+ * The same drive loop serves both shapes of request. A buffered request runs to completion
+ * and appends the body to a String. A streamed one (Session#stream) is driven by its consumer:
+ * transfer_start runs until the response head is complete, and every transfer_read runs it
+ * again until some body bytes have landed in the String the caller handed in. Between two
+ * reads the transfer is either paused or simply not driven, so no Ruby code ever runs
+ * inside libcurl on behalf of the consumer.
+ *
  * Requires Ruby >= 3.3 and libcurl >= 7.81.0.
  */
 #include <ruby.h>
@@ -24,6 +31,7 @@
 
 #include <stdio.h>
 #include <string.h>
+#include <time.h>
 #include <signal.h>
 #include <unistd.h>
 #include <sys/stat.h>
@@ -38,6 +46,7 @@
 
 #define INTERRUPT_ABORT 1
 #define INTERRUPT_DOWNLOAD_OVERFLOW 2
+#define INTERRUPT_REWIND_FAILED 3
 
 /* 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. */
@@ -63,6 +72,7 @@ static VALUE eTooManyRedirects;
 static VALUE eAborted;
 static VALUE eDownloadLimitExceeded;
 static VALUE eClientCertificateError;
+static VALUE eFiberError;
 
 /* Frozen, Ractor-shareable lookup tables exposed as Patron::Request::SSL_VERSIONS and
  * Patron::Request::HTTP_VERSIONS: version name => libcurl constant. */
@@ -76,15 +86,16 @@ static VALUE hHTTPVersions;
   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)
+  X(upload_data) X(file_name) X(multipart) X(read_timeout)
 
 #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_read, id_readpartial, id_size, id_pos, id_seek, id_rewind;
 static ID id_get, id_post, id_put, id_patch, id_delete, id_head;
-static ID id_ivar_curl_code;
+static ID id_ivar_curl_code, id_raise;
 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;
 
@@ -103,14 +114,36 @@ struct patron_session {
   CURL *easy;
   curl_mime *mime;
   struct curl_slist *headers;
-  FILE *download_file;
   FILE *request_body_file;
+  curl_off_t request_content_length;  /* from a Content-Length request header, or -1 */
+  int request_transfer_encoding;      /* whether the request headers carry a Transfer-Encoding */
+  curl_off_t upload_io_origin;        /* position of upload_io when the request started */
+  int upload_io_partial;              /* whether upload_io gets #readpartial rather than #read */
   char error_buf[CURL_ERROR_SIZE];
   curl_off_t download_byte_limit;
   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 */
+  VALUE upload_io;                    /* object responding to #read the body is streamed from, or nil */
+  VALUE upload_buf;                   /* String upload_io reads into, copied into libcurl's buffer */
+
+  /* Per request, the state the drive loop and the streaming primitives share */
+  int streaming;                      /* the body goes to read_buf instead of body_buf */
+  int paused;                         /* body_write_cb answered CURL_WRITEFUNC_PAUSE */
+  int head_complete;                  /* the final response head is in header_buf */
+  int done;                           /* CURLMSG_DONE was seen, `result` holds its code */
+  int read_timed_out;
+  CURLcode result;
+  long head_length;                   /* header_buf bytes up to head-complete; trailers follow */
+  size_t redeliver_skip;              /* bytes at the start of the next delivery already handed out */
+  long read_limit;                    /* length read_buf may grow to, -1 for unbounded */
+  double read_timeout;                /* seconds allowed between two deliveries, 0 for none */
+  double last_activity;               /* monotonic seconds of the last delivery */
+  VALUE read_buf;                     /* the caller's String, set only during transfer_read */
+  VALUE owner;                        /* the Fiber that started the transfer */
+  VALUE owner_thread;                 /* and its Thread */
+  int in_scheduler_wait;              /* the owner is parked in the Fiber scheduler by wait_with_scheduler() */
 
   /* 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. */
@@ -128,7 +161,18 @@ 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. */
+  /* A stream abandoned with its Fiber is still in flight here. No Ruby may run from this
+   * point on, and debug_cb would write to an IO that may have been collected already. */
+  s->debug_io = Qnil;
+  if (s->easy) {
+    curl_easy_setopt(s->easy, CURLOPT_VERBOSE, 0L);
+    curl_easy_setopt(s->easy, CURLOPT_NOPROGRESS, 1L);
+    if (s->multi) curl_multi_remove_handle(s->multi, s->easy);
+    curl_easy_cleanup(s->easy);
+  }
+  if (s->mime) curl_mime_free(s->mime);
+  if (s->headers) curl_slist_free_all(s->headers);
+  if (s->request_body_file) fclose(s->request_body_file);
   if (s->multi) curl_multi_cleanup(s->multi);
   if (s->base) curl_easy_cleanup(s->base);
   if (s->share) curl_share_cleanup(s->share);
@@ -144,7 +188,12 @@ static void session_mark(void *ptr) {
   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->upload_io);
+  rb_gc_mark_movable(s->upload_buf);
   rb_gc_mark_movable(s->pending_errinfo);
+  rb_gc_mark_movable(s->read_buf);
+  rb_gc_mark_movable(s->owner);
+  rb_gc_mark_movable(s->owner_thread);
   /* 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);
@@ -158,7 +207,12 @@ static void session_compact(void *ptr) {
   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->upload_io = rb_gc_location(s->upload_io);
+  s->upload_buf = rb_gc_location(s->upload_buf);
   s->pending_errinfo = rb_gc_location(s->pending_errinfo);
+  s->read_buf = rb_gc_location(s->read_buf);
+  s->owner = rb_gc_location(s->owner);
+  s->owner_thread = rb_gc_location(s->owner_thread);
 }
 
 static size_t session_memsize(const void *ptr) {
@@ -215,14 +269,18 @@ static VALUE error_class_for(CURLcode code) {
   }
 }
 
-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) {
+static VALUE build_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);
+  return exc;
+}
+
+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) {
+  rb_exc_raise(build_curl_error(klass, code, message));
 }
 
 /* curl_easy_setopt() only fails for options the installed libcurl cannot honour; that must
@@ -283,25 +341,211 @@ static size_t append_to_string(struct patron_session *s, VALUE str, const char *
   return len;
 }
 
+static double monotonic_now(void) {
+  struct timespec ts;
+  clock_gettime(CLOCK_MONOTONIC, &ts);
+  return (double)ts.tv_sec + (double)ts.tv_nsec / 1e9;
+}
+
+static void mark_head_complete(struct patron_session *s) {
+  if (s->head_complete) return;
+  s->head_complete = 1;
+  s->head_length = NIL_P(s->header_buf) ? 0 : RSTRING_LEN(s->header_buf);
+}
+
+/* libcurl drops the bodies of the redirects it follows and 1xx responses have none, so the
+ * first body byte always belongs to the final response: the head is complete by then.
+ *
+ * A streamed transfer writes into the caller's String. When a delivery does not fit, what
+ * fits is copied and the transfer paused; libcurl then delivers the very same bytes again
+ * after curl_easy_pause(CURLPAUSE_CONT), and redeliver_skip steps over the part handed out
+ * already. Outside of transfer_read there is no String to write to, so the transfer pauses
+ * without taking anything. */
 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;
+  size_t taken = 0, room, n;
+  long cur;
+
+  mark_head_complete(s);
+  s->last_activity = monotonic_now();
+  if (!s->streaming) return append_to_string(s, s->body_buf, ptr, len);
+
+  if (s->redeliver_skip) {
+    if (s->redeliver_skip >= len) {
+      s->redeliver_skip -= len;
+      return len;
+    }
+    taken = s->redeliver_skip;
+    s->redeliver_skip = 0;
+  }
+
+  if (NIL_P(s->read_buf)) {
+    s->redeliver_skip = taken;
+    s->paused = 1;
+    return CURL_WRITEFUNC_PAUSE;
+  }
 
-  if (s->download_file) {
-    if (fwrite(ptr, 1, len, s->download_file) != len) return 0;
+  if (s->read_limit < 0) {
+    if (append_to_string(s, s->read_buf, ptr + taken, len - taken) != len - taken) return 0;
     return len;
   }
-  return append_to_string(s, s->body_buf, ptr, len);
+
+  cur = RSTRING_LEN(s->read_buf);
+  room = s->read_limit > cur ? (size_t)(s->read_limit - cur) : 0;
+  n = len - taken < room ? len - taken : room;
+  if (n) {
+    memcpy(RSTRING_PTR(s->read_buf) + cur, ptr + taken, n);
+    rb_str_set_len(s->read_buf, cur + (long)n);
+  }
+  if (taken + n < len) {
+    s->redeliver_skip = taken + n;
+    s->paused = 1;
+    return CURL_WRITEFUNC_PAUSE;
+  }
+  return len;
 }
 
+/* The early head-complete trigger: the blank line ending a 2xx head. A 2xx is never followed
+ * or retried, so nothing else can come before its body, and a long-poll or an event stream
+ * gets its head before the first event. 3xx, 401 and 407 wait for the first body byte. */
 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);
+  size_t len = size * nmemb;
+  size_t written = append_to_string(s, s->header_buf, ptr, len);
+
+  s->last_activity = monotonic_now();
+  if (!s->head_complete && ((len == 2 && ptr[0] == '\r' && ptr[1] == '\n') || (len == 1 && ptr[0] == '\n'))) {
+    long code = 0;
+    curl_easy_getinfo(s->easy, CURLINFO_RESPONSE_CODE, &code);
+    if (code >= 200 && code < 300) mark_head_complete(s);
+  }
+  return written;
 }
 
 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);
+  struct patron_session *s = userdata;
+  if (s->interrupt) return CURL_READFUNC_ABORT;
+  return fread(buffer, 1, size * nitems, s->request_body_file);
+}
+
+/* Same as io_seek_cb(): a failed rewind has to fail the request, not empty the body */
+static int file_seek_cb(void *userdata, curl_off_t offset, int origin) {
+  struct patron_session *s = userdata;
+
+  if (fseeko(s->request_body_file, (off_t)offset, origin) == 0) return CURL_SEEKFUNC_OK;
+  s->interrupt = INTERRUPT_REWIND_FAILED;
+  return CURL_SEEKFUNC_FAIL;
+}
+
+struct io_read_args {
+  struct patron_session *s;
+  size_t len;
+};
+
+static VALUE io_readpartial(VALUE arg) {
+  struct io_read_args *a = (struct io_read_args *)arg;
+  VALUE argv[2] = { SIZET2NUM(a->len), a->s->upload_buf };
+  return rb_funcallv(a->s->upload_io, id_readpartial, 2, argv);
+}
+
+static VALUE io_readpartial_eof(VALUE arg, VALUE err) {
+  return Qnil;
+}
+
+static VALUE io_read_protected(VALUE arg) {
+  struct io_read_args *a = (struct io_read_args *)arg;
+  struct patron_session *s = a->s;
+  VALUE argv[2] = { SIZET2NUM(a->len), s->upload_buf };
+  VALUE chunk;
+
+  if (s->upload_io_partial) {
+    chunk = rb_rescue2(io_readpartial, arg, io_readpartial_eof, Qnil, rb_eEOFError, (VALUE)0);
+  } else {
+    chunk = rb_funcallv(s->upload_io, id_read, 2, argv);
+  }
+
+  if (NIL_P(chunk)) return Qnil;
+  StringValue(chunk);
+  /* A readable that ignores the length would overflow libcurl's buffer */
+  if ((size_t)RSTRING_LEN(chunk) > a->len) {
+    raise_curl_error(ePatronError, CURLE_READ_ERROR, "The request body #read returned more bytes than asked for");
+  }
+  return chunk;
+}
+
+/* Streams the body from upload_io. #readpartial(len, buf), or #read(len, buf) when there is
+ * no #readpartial, reads into upload_buf, which is then copied into libcurl's buffer: Ruby
+ * cannot be handed memory it does not own. #read on a pipe or a socket waits for all of `len`
+ * (libcurl asks for 64KB), #readpartial returns what the writer has written so far, and ends
+ * with an EOFError rather than nil. Under a Fiber scheduler a blocking read yields to it like
+ * any other IO in the fiber. */
+static size_t io_read_cb(char *buffer, size_t size, size_t nitems, void *userdata) {
+  struct patron_session *s = userdata;
+  struct io_read_args args = { s, size * nitems };
+  int tag = 0;
+  VALUE chunk;
+
+  if (s->interrupt) return CURL_READFUNC_ABORT;
+  chunk = rb_protect(io_read_protected, (VALUE)&args, &tag);
+  if (tag) {
+    park_exception(s, tag);
+    return CURL_READFUNC_ABORT;
+  }
+  if (NIL_P(chunk)) return 0;
+  memcpy(buffer, RSTRING_PTR(chunk), (size_t)RSTRING_LEN(chunk));
+  return (size_t)RSTRING_LEN(chunk);
+}
+
+struct io_seek_args {
+  struct patron_session *s;
+  curl_off_t offset;
+  int origin;
+};
+
+/* IO::SEEK_SET and friends are the C SEEK_* values, so origin passes through as-is */
+static VALUE io_seek_protected(VALUE arg) {
+  struct io_seek_args *a = (struct io_seek_args *)arg;
+  VALUE io = a->s->upload_io;
+
+  if (rb_respond_to(io, id_seek)) {
+    VALUE argv[2] = { OFFT2NUM(a->offset), INT2FIX(a->origin) };
+    rb_funcallv(io, id_seek, 2, argv);
+    return Qtrue;
+  }
+  /* Zlib::GzipReader and friends can only start over */
+  if (a->origin == SEEK_SET && a->offset == 0 && rb_respond_to(io, id_rewind)) {
+    rb_funcallv(io, id_rewind, 0, NULL);
+    return Qtrue;
+  }
+  return Qfalse;
+}
+
+/* libcurl rewinds the body when it has to send it again: a 307/308 redirect, an auth
+ * round-trip. A pipe has #seek but raises ESPIPE, which only means "cannot seek".
+ * libcurl 8.7 logs a failed rewind and then follows the redirect with an empty body
+ * anyway, so we abort the transfer ourselves rather than trust it to. */
+static int io_seek_cb(void *userdata, curl_off_t offset, int origin) {
+  struct patron_session *s = userdata;
+  struct io_seek_args args = { s, offset, origin };
+  int tag = 0;
+  VALUE seeked;
+
+  if (origin == SEEK_SET) args.offset += s->upload_io_origin;
+  seeked = rb_protect(io_seek_protected, (VALUE)&args, &tag);
+  if (tag) {
+    VALUE err = rb_errinfo();
+    if (rb_obj_is_kind_of(err, rb_eSystemCallError) || rb_obj_is_kind_of(err, rb_eIOError)) {
+      rb_set_errinfo(Qnil);
+      seeked = Qfalse;
+    } else {
+      park_exception(s, tag);
+      return CURL_SEEKFUNC_FAIL;
+    }
+  }
+  if (RTEST(seeked)) return CURL_SEEKFUNC_OK;
+  s->interrupt = INTERRUPT_REWIND_FAILED;
+  return CURL_SEEKFUNC_CANTSEEK;
 }
 
 struct progress_args {
@@ -475,7 +719,14 @@ static VALUE session_alloc(VALUE klass) {
   s->upload_data = Qnil;
   s->header_buf = Qnil;
   s->body_buf = Qnil;
+  s->upload_io = Qnil;
+  s->upload_buf = Qnil;
+  s->request_content_length = -1;
   s->pending_errinfo = Qnil;
+  s->read_buf = Qnil;
+  s->owner = Qnil;
+  s->owner_thread = Qnil;
+  s->read_limit = -1;
   init_handles(s);
   return obj;
 }
@@ -614,6 +865,15 @@ static int each_http_header(VALUE key, VALUE value, VALUE self) {
     setopt_or_raise(s->easy, CURLOPT_ACCEPT_ENCODING, "gzip");
   }
 
+  /* A streamed body of unknown size goes by these, see set_request_body_from_io() */
+  if (header_name_is(name, "Content-Length")) {
+    VALUE length = rb_obj_as_string(value);
+    char *end = NULL;
+    long long parsed = strtoll(StringValueCStr(length), &end, 10);
+    if (end && *end == '\0' && parsed >= 0 && RSTRING_LEN(length) > 0) s->request_content_length = (curl_off_t)parsed;
+  }
+  if (header_name_is(name, "Transfer-Encoding")) s->request_transfer_encoding = 1;
+
   line = rb_sprintf("%"PRIsVALUE": %"PRIsVALUE, name, value);
   s->headers = curl_slist_append(s->headers, StringValueCStr(line));
   return ST_CONTINUE;
@@ -669,14 +929,57 @@ static void set_request_body_from_file(struct patron_session *s, VALUE path) {
 
   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_READDATA, s);
+  setopt_or_raise(s->easy, CURLOPT_SEEKFUNCTION, file_seek_cb);
+  setopt_or_raise(s->easy, CURLOPT_SEEKDATA, s);
   setopt_or_raise(s->easy, CURLOPT_INFILESIZE_LARGE, (curl_off_t)st.st_size);
 }
 
+/* Size comes from #size when there is one (minus #pos, for a half-read StringIO), then from
+ * a Content-Length header, and failing both the body goes out chunked. libcurl would pick
+ * chunked by itself too, but it would then send it alongside an app-supplied Content-Length. */
+static void set_request_body_from_io(struct patron_session *s, VALUE io) {
+  curl_off_t size = -1;
+
+  SESSION_WRITE(s, upload_io, io);
+  SESSION_WRITE(s, upload_buf, rb_str_buf_new(0));
+  s->upload_io_origin = 0;
+  s->upload_io_partial = rb_respond_to(io, id_readpartial);
+
+  if (rb_respond_to(io, id_size)) {
+    VALUE value = rb_funcallv(io, id_size, 0, NULL);
+    if (!NIL_P(value)) {
+      size = NUM2OFFT(value);
+      if (rb_respond_to(io, id_pos)) {
+        s->upload_io_origin = NUM2OFFT(rb_funcallv(io, id_pos, 0, NULL));
+        size = size > s->upload_io_origin ? size - s->upload_io_origin : 0;
+      }
+    }
+  }
+  if (size < 0) size = s->request_content_length;
+  if (size < 0 && !s->request_transfer_encoding) {
+    s->headers = curl_slist_append(s->headers, "Transfer-Encoding: chunked");
+  }
+
+  setopt_or_raise(s->easy, CURLOPT_UPLOAD, 1L);
+  setopt_or_raise(s->easy, CURLOPT_READFUNCTION, io_read_cb);
+  setopt_or_raise(s->easy, CURLOPT_READDATA, s);
+  setopt_or_raise(s->easy, CURLOPT_SEEKFUNCTION, io_seek_cb);
+  setopt_or_raise(s->easy, CURLOPT_SEEKDATA, s);
+  if (size >= 0) setopt_or_raise(s->easy, CURLOPT_INFILESIZE_LARGE, size);
+}
+
+/* #to_path wins over #read so that a File keeps going through fread(). Every IO has a
+ * #to_path since Ruby 3.2, which is nil for a pipe or a socket. */
 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);
+  VALUE path = Qnil;
+
+  if (rb_respond_to(stringable_or_file, id_to_path)) path = rb_funcallv(stringable_or_file, id_to_path, 0, NULL);
+
+  if (!NIL_P(path)) {
     set_request_body_from_file(s, rb_obj_as_string(path));
+  } else if (rb_respond_to(stringable_or_file, id_read)) {
+    set_request_body_from_io(s, stringable_or_file);
   } else {
     VALUE data = rb_obj_as_string(stringable_or_file);
     SESSION_WRITE(s, upload_data, data);
@@ -744,10 +1047,8 @@ static void set_options_from_request(struct patron_session *s, VALUE request) {
       set_request_body(s, upload_data);
       setopt_or_raise(easy, CURLOPT_CUSTOMREQUEST, "GET");
     }
-    if (RTEST(file_name)) {
-      s->download_file = open_file(file_name, "wb");
-      SESSION_WRITE(s, body_buf, Qnil);
-    }
+    /* Downloads go through Session#get_file, which streams into the file from Ruby */
+    if (RTEST(file_name)) rb_raise(rb_eArgError, "A GET with a file name has to go through Session#get_file");
   } 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";
@@ -867,6 +1168,9 @@ static void set_options_from_request(struct patron_session *s, VALUE request) {
 
   value = request_attr(request, id_buffer_size);
   if (RTEST(value)) setopt_or_raise(easy, CURLOPT_BUFFERSIZE, NUM2LONG(value));
+
+  value = request_attr(request, id_read_timeout);
+  s->read_timeout = RTEST(value) ? NUM2DBL(value) : 0.0;
 }
 
 /*----------------------------------------------------------------------------*/
@@ -923,12 +1227,13 @@ static VALUE create_response(struct patron_session *s) {
 
 struct poll_context {
   CURLM *multi;
+  int timeout_ms;
   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);
+  ctx->rc = curl_multi_poll(ctx->multi, NULL, 0, ctx->timeout_ms, NULL);
   return NULL;
 }
 
@@ -941,8 +1246,8 @@ static void wakeup_poll(void *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 };
+static void wait_without_scheduler(struct patron_session *s, long max_ms) {
+  struct poll_context ctx = { s->multi, (int)max_ms, 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);
@@ -955,7 +1260,8 @@ static VALUE float_seconds(long milliseconds) {
 
 /* 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. */
+ * set of sockets changes and after every request, 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);
@@ -972,7 +1278,7 @@ static VALUE socket_io(struct patron_session *s, int fd) {
 /* 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) {
+static void wait_with_scheduler(struct patron_session *s, VALUE scheduler, long max_ms) {
   fd_set rd, wr, ex;
   int maxfd = -1, fd, nfds = 0, i;
   int fds[MAX_WAIT_FDS], events[MAX_WAIT_FDS];
@@ -982,7 +1288,7 @@ static void wait_with_scheduler(struct patron_session *s, VALUE scheduler) {
   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;
+  if (timeout_ms < 0 || timeout_ms > max_ms) timeout_ms = max_ms;
 
   for (fd = 0; fd <= maxfd && nfds < MAX_WAIT_FDS; fd++) {
     int ev = 0;
@@ -998,7 +1304,9 @@ static void wait_with_scheduler(struct patron_session *s, VALUE scheduler) {
   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;
+    s->in_scheduler_wait = 1;
     rb_fiber_scheduler_kernel_sleep(scheduler, float_seconds(timeout_ms));
+    s->in_scheduler_wait = 0;
     return;
   }
 
@@ -1013,7 +1321,10 @@ static void wait_with_scheduler(struct patron_session *s, VALUE scheduler) {
 
   timeout = float_seconds(timeout_ms);
   if (nfds == 1) {
-    rb_fiber_scheduler_io_wait(scheduler, socket_io(s, fds[0]), INT2NUM(events[0]), timeout);
+    VALUE io = socket_io(s, fds[0]);
+    s->in_scheduler_wait = 1;
+    rb_fiber_scheduler_io_wait(scheduler, io, INT2NUM(events[0]), timeout);
+    s->in_scheduler_wait = 0;
     return;
   }
 
@@ -1027,79 +1338,148 @@ static void wait_with_scheduler(struct patron_session *s, VALUE scheduler) {
       if (events[i] & RUBY_IO_WRITABLE) rb_ary_push(writables, io);
       if (events[i] & RUBY_IO_PRIORITY) rb_ary_push(exceptables, io);
     }
+    s->in_scheduler_wait = 1;
     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));
     }
+    s->in_scheduler_wait = 0;
+  }
+}
+
+/* Where drive_transfer() may stop before the transfer is done */
+enum drive_until {
+  UNTIL_DONE,
+  UNTIL_HEAD,   /* the final response head is complete */
+  UNTIL_DATA,   /* some bytes landed in read_buf, or it is full */
+};
+
+static void collect_done(struct patron_session *s) {
+  CURLMsg *msg;
+  int remaining = 0;
+
+  while ((msg = curl_multi_info_read(s->multi, &remaining))) {
+    if (msg->msg == CURLMSG_DONE && msg->easy_handle == s->easy) {
+      s->done = 1;
+      s->result = msg->data.result;
+    }
   }
 }
 
-static void drive_transfer(struct patron_session *s) {
+static int drive_should_stop(struct patron_session *s, enum drive_until until, long read_from) {
+  switch (until) {
+    case UNTIL_HEAD: return s->head_complete;
+    case UNTIL_DATA: return s->paused || RSTRING_LEN(s->read_buf) > read_from;
+    default:         return 0;
+  }
+}
+
+/* Drives the transfer until it is done or `until` holds. read_timeout is a deadline counted
+ * from the last delivery, so the waits are capped at what is left of it. `read_from` is the
+ * read_buf length that does not count as new data. */
+static void drive_transfer(struct patron_session *s, enum drive_until until, long read_from) {
   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();
 
-  mc = curl_multi_add_handle(s->multi, s->easy);
-  if (mc != CURLM_OK) rb_raise(ePatronError, "%s", curl_multi_strerror(mc));
+  for (;;) {
+    long wait_ms = POLL_TIMEOUT_MS;
 
-  while (running) {
     mc = curl_multi_perform(s->multi, &running);
     if (mc != CURLM_OK) rb_raise(ePatronError, "%s", curl_multi_strerror(mc));
+    collect_done(s);
     if (s->pending_tag || s->interrupt) break;
-    if (!running) break;
+    if (!running) s->done = 1;
+    if (s->done || drive_should_stop(s, until, read_from)) break;
+
+    if (s->read_timeout > 0) {
+      double left = s->last_activity + s->read_timeout - monotonic_now();
+      if (left <= 0) {
+        s->read_timed_out = 1;
+        break;
+      }
+      if (left * 1000.0 < (double)wait_ms) wait_ms = (long)(left * 1000.0) + 1;
+    }
 
     if (NIL_P(scheduler)) {
-      wait_without_scheduler(s);
+      wait_without_scheduler(s, wait_ms);
     } else {
-      wait_with_scheduler(s, scheduler);
+      wait_with_scheduler(s, scheduler, wait_ms);
     }
     if (s->interrupt) break;
   }
+  if (s->done) mark_head_complete(s);
 }
 
-static CURLcode transfer_result(struct patron_session *s) {
-  CURLcode result = CURLE_OK;
-  CURLMsg *msg;
-  int remaining = 0;
+/* Raises whatever ended the transfer early, and the transfer's own failure when
+ * `include_result` is set and it is done. */
+static void raise_if_failed(struct patron_session *s, int include_result) {
+  if (s->pending_tag) reraise_parked(s);
 
-  while ((msg = curl_multi_info_read(s->multi, &remaining))) {
-    if (msg->msg == CURLMSG_DONE && msg->easy_handle == s->easy) result = msg->data.result;
+  if (s->interrupt == INTERRUPT_DOWNLOAD_OVERFLOW) {
+    raise_curl_error(eDownloadLimitExceeded, CURLE_ABORTED_BY_CALLBACK, "Download byte limit exceeded");
+  }
+  if (s->interrupt == INTERRUPT_REWIND_FAILED) {
+    raise_curl_error(ePatronError, CURLE_SEND_FAIL_REWIND, "The request body has to be sent again, but it cannot be rewound");
+  }
+  if (s->interrupt) {
+    raise_curl_error(eAborted, CURLE_ABORTED_BY_CALLBACK, "Request interrupted");
+  }
+  if (s->read_timed_out) {
+    char message[128];
+    snprintf(message, sizeof(message), "Read timeout: no data received for %.3g seconds", s->read_timeout);
+    raise_curl_error(eTimeoutError, CURLE_OPERATION_TIMEDOUT, message);
+  }
+  if (include_result && s->done && s->result != CURLE_OK) {
+    raise_curl_error(error_class_for(s->result), s->result, s->error_buf);
   }
-  return result;
 }
 
-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;
+/* Today's request setup plus curl_multi_add_handle(). Everything it allocates is released
+ * by cleanup(), which the caller must make sure runs. */
+static void begin_transfer(struct patron_session *s, VALUE request, int streaming) {
+  CURLMcode mc;
 
   s->interrupt = 0;
+  s->in_scheduler_wait = 0;
   s->pending_tag = 0;
   s->error_buf[0] = '\0';
+  s->streaming = streaming;
+  s->paused = 0;
+  s->head_complete = 0;
+  s->head_length = 0;
+  s->done = 0;
+  s->result = CURLE_OK;
+  s->read_timed_out = 0;
+  s->redeliver_skip = 0;
+  s->read_limit = -1;
   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));
+  SESSION_WRITE(s, body_buf, streaming ? Qnil : rb_str_buf_new(BODY_BUFFER_INITIAL_CAPACITY));
 
-  set_options_from_request(s, args->request);
-  drive_transfer(s);
+  set_options_from_request(s, request);
+  /* A proxy's "200 Connection established" would otherwise trip the early head trigger;
+   * HeaderParser keeps only the last response anyway */
+  if (streaming) setopt_or_raise(s->easy, CURLOPT_SUPPRESS_CONNECT_HEADERS, 1L);
 
-  if (s->pending_tag) reraise_parked(s);
+  s->last_activity = monotonic_now();
+  mc = curl_multi_add_handle(s->multi, s->easy);
+  if (mc != CURLM_OK) rb_raise(ePatronError, "%s", curl_multi_strerror(mc));
+}
 
-  if (s->interrupt == INTERRUPT_DOWNLOAD_OVERFLOW) {
-    raise_curl_error(eDownloadLimitExceeded, CURLE_ABORTED_BY_CALLBACK, "Download byte limit exceeded");
-  }
-  if (s->interrupt) {
-    raise_curl_error(eAborted, CURLE_ABORTED_BY_CALLBACK, "Request interrupted");
-  }
+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;
 
-  result = transfer_result(s);
-  if (result != CURLE_OK) raise_curl_error(error_class_for(result), result, s->error_buf);
+  begin_transfer(s, args->request, 0);
+  drive_transfer(s, UNTIL_DONE, 0);
+  raise_if_failed(s, 1);
 
   /* Write the cookies accumulated in the share out to the jar, if one is configured */
   curl_easy_setopt(s->easy, CURLOPT_COOKIELIST, "FLUSH");
@@ -1124,10 +1504,6 @@ static VALUE cleanup(VALUE self) {
     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;
@@ -1137,11 +1513,39 @@ static VALUE cleanup(VALUE self) {
   SESSION_WRITE(s, upload_data, Qnil);
   SESSION_WRITE(s, header_buf, Qnil);
   SESSION_WRITE(s, body_buf, Qnil);
+  SESSION_WRITE(s, upload_io, Qnil);
+  SESSION_WRITE(s, upload_buf, Qnil);
+  SESSION_WRITE(s, read_buf, Qnil);
+  SESSION_WRITE(s, owner, Qnil);
+  SESSION_WRITE(s, owner_thread, Qnil);
+  s->in_scheduler_wait = 0;
+  /* An aborted transfer closes its socket, and the next one tends to get the same number. Handed
+   * the same IO again, io-event's epoll selector takes it for still registered and never wakes. */
+  if (!NIL_P(s->socket_ios)) rb_hash_clear(s->socket_ios);
+  s->upload_io_origin = 0;
+  s->upload_io_partial = 0;
+  s->request_content_length = -1;
+  s->request_transfer_encoding = 0;
   s->download_byte_limit = 0;
+  s->streaming = 0;
+  s->paused = 0;
+  s->read_timeout = 0.0;
   s->busy = 0;
   return Qnil;
 }
 
+static void raise_if_busy(struct patron_session *s) {
+  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");
+  }
+}
+
+static void claim(struct patron_session *s) {
+  s->busy = 1;
+  SESSION_WRITE(s, owner, rb_fiber_current());
+  SESSION_WRITE(s, owner_thread, rb_thread_current());
+}
+
 /*
  * 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.
@@ -1153,17 +1557,226 @@ static VALUE session_handle_request(VALUE self, VALUE request) {
   struct patron_session *s = get_session(self);
   struct perform_args args = { s, request };
 
-  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");
-  }
+  raise_if_busy(s);
   ensure_handles_for_this_process(s);
-  s->busy = 1;
+  claim(s);
   return rb_ensure(perform, (VALUE)&args, cleanup, self);
 }
 
+/*----------------------------------------------------------------------------*/
+/* Streaming primitives. Session#stream calls them in order inside one begin/ensure:
+ * transfer_start, any number of transfer_read, transfer_finish. */
+
+static VALUE start_stream(VALUE ptr) {
+  struct perform_args *args = (struct perform_args *)ptr;
+  struct patron_session *s = args->s;
+  CURL *easy;
+  char *effective_url = NULL;
+  long code = 0, redirect_count = 0;
+
+  begin_transfer(s, args->request, 1);
+  drive_transfer(s, UNTIL_HEAD, 0);
+  raise_if_failed(s, 1);
+
+  easy = s->easy;
+  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);
+  return rb_ary_new_from_args(4,
+    LONG2NUM(code),
+    effective_url ? rb_usascii_str_new_cstr(effective_url) : Qnil,
+    LONG2NUM(redirect_count),
+    rb_str_subseq(s->header_buf, 0, s->head_length));
+}
+
+/*
+ * Starts a streamed transfer and drives it until the head of the final response is complete.
+ * Raises the usual Patron::Error when the transfer fails before that, having cleaned up.
+ *
+ * @api private
+ * @param request [Patron::Request]
+ * @return [Array] status, effective URL, redirect count and the raw header data
+ */
+static VALUE session_transfer_start(VALUE self, VALUE request) {
+  struct patron_session *s = get_session(self);
+  struct perform_args args = { s, request };
+  int state = 0;
+  VALUE head;
+
+  raise_if_busy(s);
+  ensure_handles_for_this_process(s);
+  claim(s);
+  head = rb_protect(start_stream, (VALUE)&args, &state);
+  if (state) {
+    cleanup(self);
+    rb_jump_tag(state);
+  }
+  return head;
+}
+
+static struct patron_session *open_stream(VALUE self) {
+  struct patron_session *s = get_session(self);
+
+  if (!s->easy || !s->streaming) rb_raise(ePatronError, "No streamed transfer is open on this Session");
+  if (s->owner != rb_fiber_current()) rb_raise(ePatronError, "The streamed transfer belongs to another thread or fiber");
+  return s;
+}
+
+struct read_args {
+  struct patron_session *s;
+  long maxlen;  /* -1 for whatever the next deliveries bring */
+  long keep;    /* bytes at the start of buf to leave alone */
+  VALUE buf;
+};
+
+static VALUE read_into_buf(VALUE ptr) {
+  struct read_args *a = (struct read_args *)ptr;
+  struct patron_session *s = a->s;
+  long placed;
+
+  if (s->paused) {
+    CURLcode rc;
+    s->paused = 0;
+    s->last_activity = monotonic_now();
+    /* This may deliver the paused bytes right here, before any curl_multi_perform() */
+    rc = curl_easy_pause(s->easy, CURLPAUSE_CONT);
+    if (rc != CURLE_OK) raise_curl_error(error_class_for(rc), rc, s->error_buf);
+  }
+
+  if (!s->paused && RSTRING_LEN(a->buf) == a->keep && !s->done) {
+    s->last_activity = monotonic_now();
+    drive_transfer(s, UNTIL_DATA, a->keep);
+  }
+
+  placed = RSTRING_LEN(a->buf) - a->keep;
+  raise_if_failed(s, placed == 0);
+  if (placed == 0 && s->done) return Qnil;
+  return LONG2NUM(placed);
+}
+
+static VALUE read_done(VALUE ptr) {
+  struct read_args *a = (struct read_args *)ptr;
+  SESSION_WRITE(a->s, read_buf, Qnil);
+  /* An exception out of the scheduler wait leaves it set, and the stream's own
+   * ensure blocks run before transfer_finish gets to cleanup() */
+  a->s->in_scheduler_wait = 0;
+  return Qnil;
+}
+
+/*
+ * Receives the next bytes of the streamed body into +buf+, which libcurl writes into directly.
+ * The String is only ever written to during this call.
+ *
+ * @api private
+ * @overload transfer_read(maxlen, buf, keep = 0)
+ *   @param maxlen [Integer, nil] most bytes to place, nil for whatever the next deliveries bring
+ *   @param buf [String] truncated to +keep+ bytes and appended to, made binary
+ *   @param keep [Integer] bytes at the start of +buf+ to leave in place
+ * @return [Integer, nil] the bytes placed, nil at the end of the body
+ */
+static VALUE session_transfer_read(int argc, VALUE *argv, VALUE self) {
+  struct patron_session *s = open_stream(self);
+  VALUE maxlen, buf, keep;
+  struct read_args args;
+
+  rb_scan_args(argc, argv, "21", &maxlen, &buf, &keep);
+  StringValue(buf);
+  args.s = s;
+  args.buf = buf;
+  args.maxlen = NIL_P(maxlen) ? -1 : NUM2LONG(maxlen);
+  args.keep = NIL_P(keep) ? 0 : NUM2LONG(keep);
+  if (args.maxlen < -1) rb_raise(rb_eArgError, "negative length %ld given", args.maxlen);
+  if (args.keep < 0 || args.keep > RSTRING_LEN(buf)) rb_raise(rb_eArgError, "keep out of range");
+
+  /* A frozen or shared String raises or gets its own copy here, rather than being scribbled on */
+  rb_str_modify(buf);
+  rb_str_set_len(buf, args.keep);
+  if (ENCODING_GET(buf) != rb_ascii8bit_encindex()) rb_enc_associate_index(buf, rb_ascii8bit_encindex());
+  if (args.maxlen == 0) return INT2FIX(0);
+  if (args.maxlen > 0) rb_str_modify_expand(buf, args.maxlen);
+
+  s->read_limit = args.maxlen < 0 ? -1 : args.keep + args.maxlen;
+  SESSION_WRITE(s, read_buf, buf);
+  return rb_ensure(read_into_buf, (VALUE)&args, read_done, (VALUE)&args);
+}
+
+static VALUE finish_stream(VALUE ptr) {
+  struct patron_session *s = (struct patron_session *)ptr;
+  curl_off_t downloaded = 0, uploaded = 0;
+  int complete = s->done && s->result == CURLE_OK && !s->interrupt && !s->pending_tag;
+  VALUE trailer_data;
+
+  curl_easy_getinfo(s->easy, CURLINFO_SIZE_DOWNLOAD_T, &downloaded);
+  curl_easy_getinfo(s->easy, CURLINFO_SIZE_UPLOAD_T, &uploaded);
+  if (complete && RSTRING_LEN(s->header_buf) > s->head_length) {
+    trailer_data = rb_str_subseq(s->header_buf, s->head_length, RSTRING_LEN(s->header_buf) - s->head_length);
+  } else {
+    trailer_data = rb_str_new(NULL, 0);
+  }
+  curl_easy_setopt(s->easy, CURLOPT_COOKIELIST, "FLUSH");
+
+  return rb_ary_new_from_args(5, LL2NUM(downloaded), LL2NUM(uploaded), create_timings(s->easy),
+                              complete ? Qtrue : Qfalse, trailer_data);
+}
+
+/*
+ * Ends the streamed transfer, whether or not its body was received in full. A no-op when
+ * this thread or fiber has no streamed transfer open.
+ *
+ * @api private
+ * @return [Array, nil] downloaded bytes, uploaded bytes, timings, whether the transfer completed,
+ *   and the raw trailer lines
+ */
+static VALUE session_transfer_finish(VALUE self) {
+  struct patron_session *s = get_session(self);
+
+  if (!s->easy || !s->streaming || s->owner != rb_fiber_current()) return Qnil;
+  return rb_ensure(finish_stream, (VALUE)s, cleanup, self);
+}
+
+struct scheduler_raise_args {
+  VALUE scheduler;
+  VALUE fiber;
+  VALUE exc;
+};
+
+static VALUE scheduler_raise(VALUE ptr) {
+  struct scheduler_raise_args *a = (struct scheduler_raise_args *)ptr;
+  return rb_funcall(a->scheduler, id_raise, 2, a->fiber, a->exc);
+}
+
+/* curl_multi_wakeup() does not reach an owner parked in the Fiber scheduler: libcurl's wakeup
+ * socket is not among the ones curl_multi_fdset() hands out. So raise into the owner instead,
+ * through the scheduler's #raise, which is what Async::Task#stop uses. That queues the calling
+ * fiber to be resumed; a bare Fiber#raise would transfer away from it for good. Without such a
+ * scheduler the owner notices the flag at its next wait cap. */
+static void raise_into_waiting_owner(struct patron_session *s) {
+  struct scheduler_raise_args args;
+  int state = 0;
+
+  if (!s->in_scheduler_wait) return;
+  if (s->owner_thread != rb_thread_current() || s->owner == rb_fiber_current()) return;
+  if (!RTEST(rb_fiber_alive_p(s->owner))) return;
+  args.scheduler = rb_fiber_scheduler_current();
+  if (NIL_P(args.scheduler) || !rb_respond_to(args.scheduler, id_raise)) return;
+
+  args.fiber = s->owner;
+  args.exc = build_curl_error(eAborted, CURLE_ABORTED_BY_CALLBACK, "Request interrupted");
+  s->in_scheduler_wait = 0;
+  rb_protect(scheduler_raise, (VALUE)&args, &state);
+  if (state) {
+    /* Could not raise into the owner, so the flag stops it at its next wait cap. Anything
+     * else, such as this fiber being stopped while it waited to be resumed, is not ours. */
+    if (!rb_obj_is_kind_of(rb_errinfo(), eFiberError)) rb_jump_tag(state);
+    rb_set_errinfo(Qnil);
+  }
+}
+
 /*
  * Aborts the request currently in flight on this Session, which then raises Patron::Aborted.
- * Safe to call from another thread.
+ * Safe to call from another thread. Called from another fiber on the thread of the request,
+ * under a Fiber scheduler with a #raise of its own (Async), it raises the Aborted into the
+ * waiting fiber at once, the way Async::Task#stop does.
  *
  * @return self
  */
@@ -1172,6 +1785,7 @@ static VALUE session_interrupt(VALUE self) {
 
   s->interrupt = INTERRUPT_ABORT;
   if (s->multi) curl_multi_wakeup(s->multi);
+  raise_into_waiting_owner(s);
   return self;
 }
 
@@ -1224,6 +1838,12 @@ void Init_session_ext(void) {
 #undef DEFINE_ID
   id_to_path = rb_intern_const("to_path");
   id_to_s = rb_intern_const("to_s");
+  id_read = rb_intern_const("read");
+  id_readpartial = rb_intern_const("readpartial");
+  id_size = rb_intern_const("size");
+  id_pos = rb_intern_const("pos");
+  id_seek = rb_intern_const("seek");
+  id_rewind = rb_intern_const("rewind");
   id_response_class = rb_intern_const("response_class");
   id_default_response_charset = rb_intern_const("default_response_charset");
   id_get = rb_intern_const("get");
@@ -1233,6 +1853,7 @@ void Init_session_ext(void) {
   id_delete = rb_intern_const("delete");
   id_head = rb_intern_const("head");
   id_ivar_curl_code = rb_intern_const("@curl_code");
+  id_raise = rb_intern_const("raise");
   id_url_kw = rb_intern_const("url");
   id_status_kw = rb_intern_const("status");
   id_redirect_count_kw = rb_intern_const("redirect_count");
@@ -1261,6 +1882,7 @@ void Init_session_ext(void) {
   rb_global_variable(&eAborted);
   rb_global_variable(&eDownloadLimitExceeded);
   rb_global_variable(&eClientCertificateError);
+  rb_global_variable(&eFiberError);
 
   ePatronError = rb_const_get(mPatron, rb_intern("Error"));
   eUnsupportedProtocol = rb_const_get(mPatron, rb_intern("UnsupportedProtocol"));
@@ -1273,6 +1895,7 @@ void Init_session_ext(void) {
   eTimeoutError = rb_const_get(mPatron, rb_intern("TimeoutError"));
   eTooManyRedirects = rb_const_get(mPatron, rb_intern("TooManyRedirects"));
   eAborted = rb_const_get(mPatron, rb_intern("Aborted"));
+  eFiberError = rb_const_get(rb_cObject, rb_intern("FiberError"));
   eDownloadLimitExceeded = rb_const_get(mPatron, rb_intern("DownloadLimitExceeded"));
   eClientCertificateError = rb_const_get(mPatron, rb_intern("ClientCertificateError"));
 
@@ -1294,6 +1917,9 @@ void Init_session_ext(void) {
   rb_define_alias(cSession, "urldecode", "unescape");
 
   rb_define_private_method(cSession, "handle_request", session_handle_request, 1);
+  rb_define_private_method(cSession, "transfer_start", session_transfer_start, 1);
+  rb_define_private_method(cSession, "transfer_read", session_transfer_read, -1);
+  rb_define_private_method(cSession, "transfer_finish", session_transfer_finish, 0);
   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);