patron 0.13.3 → 0.13.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e766e45bfa71015943701e1340503df7f915d499cd001475649613175df4006d
-  data.tar.gz: 8b3a7d7fcb6d555dfff1705685c8685b925c900dfec95200816580028ffa9d53
+  metadata.gz: f900014f4c841d87c4db54f3db3f33d9b624d5a6dde0eb9352b7a70cc6f330b7
+  data.tar.gz: 31b35805166302cb5527734b70c3607f9dbb951e2c1e3aafd465f7f8d5dbbb75
 SHA512:
-  metadata.gz: 986e1bb343ea53368a6acb8f7d7ef84a48674408d4a08f7eabe1d2e2c6ff5c90f2afe0683d1e66ab751c72241a25c9f46c8e16c955c97b87c71a0bc2bd7db723
-  data.tar.gz: c285b097c1fc4022fce3484184ac44d471340a496bc246142233e655bfdf0a28653484490ce5b1802fac4d5b396bea8ca03cfd1c803867f7c07ff3d8a789335c
+  metadata.gz: 1989abb0ba1be73ed08df186d05349c6519a90663a7263799a1e97e024e5183ff6de9f49ab329ebf4e3b49c4c571d0e3ca7efed3bc5f803ad8edbe96a6554ff6
+  data.tar.gz: dc03c98c0f363d7d7bf273b72a62954dadb590c1236baf06739f6fdebd6ae5007afc243dc526c97359165c19244868779fc4168cc9f972c32cbf8fef81a56521

data/.github/workflows/ci.yml

@@ -0,0 +1,26 @@
+name: Tests
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby-version: [2.4, 2.5, 2.6, 2.7, '3.0', 3.1, 3.2, 3.3, 3.4.1]
+
+    name: Specs - Ruby ${{ matrix.ruby-version }}
+    steps:
+    - uses: actions/checkout@v4
+    - name: Install libcurl
+      run: |
+        sudo apt-get update
+        sudo apt-get -y install libcurl4 libcurl4-openssl-dev 
+    - name: Set up Ruby ${{ matrix.ruby-version }}
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # 'bundle install' and cache
+    - name: Run tests
+      run: bundle exec rake

data/.travis.yml

@@ -1,10 +1,13 @@
 rvm:
-- 1.9.3
-- 2.1.5
-- 2.2.2
-- 2.3.4
-- 2.4.1
-- 2.5.0
-sudo: false
+- 2.3.8
+- 2.4.5
+- 2.5.3
+- 2.6.1
+- ruby-head
+
 dist: trusty
 cache: bundler
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/CHANGELOG.md

@@ -1,6 +1,17 @@
+### 0.13.4
+
+* Format README a bit better using code fences
+* Depend explicitly on base64 for running tests
+* Remove C code used for Ruby support below < 2.4 (GVL unlock etc.) and drop support for these versions
+* In tests, close Tempfiles before allowing libcurl to use them (cookie jar)
+* Fix incorrect ptr type in uses of `curl_easy_escape` / `_unescape`
+* Define methods on `Session` as private instance methods from C instead of privatising them from Ruby
+* Speed up the /slow endpoint test
+* Remove use of `curl_easy_reset`. This should fix the bug with sessions resetting each other's state during `session_free`
+
 ### 0.13.3
 
-* Fix a number of specs that were failing due to use of threads
+* Run Puma test servers in separate processes instead of threads
 
 ### 0.13.2
 

data/Gemfile

@@ -1,4 +1,17 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in patron.gemspec
+# Runtime dependencies are in the gemspec
 gemspec
+
+# Gems below are only needed for Patron development
+# and tests
+gem "rake", ">= 12.3.3"
+gem "rspec", ">= 2.3.0"
+gem "simplecov", "~> 0.10"
+gem "yard", "~> 0.9.20"
+rack_version = RUBY_VERSION >= "3.3" ? "~> 2.2" : "~> 2.1.4"
+gem "rack", rack_version
+gem "puma", '~> 3.11'
+gem "rake-compiler"
+gem "webrick", "~> 1.8"
+gem "base64"

data/README.md

@@ -1,3 +1,7 @@
+# Patron
+
+[![Build Status](https://travis-ci.org/toland/patron.svg?branch=master)](https://travis-ci.org/toland/patron)
+
 Patron is a Ruby HTTP client library based on libcurl. It does not try to expose
 the full "power" (read complexity) of libcurl but instead tries to provide a
 sane API while taking advantage of libcurl under the hood.
@@ -8,47 +12,63 @@ First, you instantiate a Session object. You can set a few
 default options on the Session instance that will be used by all subsequent
 requests:
 
-    sess = Patron::Session.new
-    sess.timeout = 10
-    sess.base_url = "http://myserver.com:9900"
-    sess.headers['User-Agent'] = 'myapp/1.0'
+```ruby
+sess = Patron::Session.new
+sess.timeout = 10
+sess.base_url = "http://myserver.com:9900"
+sess.headers['User-Agent'] = 'myapp/1.0'
+```
 
 You can set options with a hash in the constructor:
 
-    sess = Patron::Session.new({ :timeout => 10,
-                                 :base_url => 'http://myserver.com:9900',
-                                 :headers => {'User-Agent' => 'myapp/1.0'} } )
+```ruby
+sess = Patron::Session.new({ :timeout => 10,
+                             :base_url => 'http://myserver.com:9900',
+                             :headers => {'User-Agent' => 'myapp/1.0'} } )
+```
 
 Or the set options in a block:
 
-    sess = Patron::Session.new do |patron|
-        patron.timeout = 10
-        patron.base_url = 'http://myserver.com:9900'
-        patron.headers = {'User-Agent' => 'myapp/1.0'}
-    end
+```ruby
+sess = Patron::Session.new do |patron|
+    patron.timeout = 10
+    patron.base_url = 'http://myserver.com:9900'
+    patron.headers = {'User-Agent' => 'myapp/1.0'}
+end
+```
 
 Output debug log:
 
-    sess.enable_debug "/tmp/patron.debug"
+```ruby
+sess.enable_debug "/tmp/patron.debug"
+```
 
 The Session is used to make HTTP requests.
 
-    resp = sess.get("/foo/bar")
+```ruby
+resp = sess.get("/foo/bar")
+```
 
 Requests return a Response object:
 
-    if resp.status < 400
-      puts resp.body
-    end
+```ruby
+if resp.status < 400
+  puts resp.body
+end
+```
 
 The GET, HEAD, PUT, POST and DELETE operations are all supported.
 
-    sess.put("/foo/baz", "some data")
-    sess.delete("/foo/baz")
+```ruby
+sess.put("/foo/baz", "some data")
+sess.delete("/foo/baz")
+```
 
 You can ship custom headers with a single request:
 
-    sess.post("/foo/stuff", "some data", {"Content-Type" => "text/plain"})
+```ruby
+sess.post("/foo/stuff", "some data", {"Content-Type" => "text/plain"})
+```
 
 ## Threading
 
@@ -58,16 +78,18 @@ for doing concurrent requests. However, the actual code that interacts with libC
 so using multiple `Session` objects in different threads actually enables a high degree of parallelism.
 For sharing a resource of sessions between threads we recommend using the excellent [connection_pool](https://rubygems.org/gems/connection_pool) gem by Mike Perham.
 
-    patron_pool = ConnectionPool.new(size: 5, timeout: 5) { Patron::Session.new }
-    patron_pool.with do |session|
-      session.get(...)
-    end
+```ruby
+patron_pool = ConnectionPool.new(size: 5, timeout: 5) { Patron::Session.new }
+patron_pool.with do |session|
+  session.get(...)
+end
+```
 
 Sharing Session objects between requests will also allow you to benefit from persistent connections (connection reuse), see below.
 
 ## Persistent connections
 
-Patron follows the libCURL guidelines on [connection reuse.](https://ec.haxx.se/libcurl-connectionreuse.html) If you create the Session
+Patron follows the libCURL guidelines on [connection reuse.](https://everything.curl.dev/libcurl/connectionreuse.html) If you create the Session
 object once and use it for multiple requests, the same libCURL handle is going to be used across these requests and if requests go to
 the same hostname/port/protocol the connection should get reused.
 
@@ -81,8 +103,10 @@ that are currently active in the process.
 
 ## Requirements
 
-Patron uses encoding features of Ruby, so you need at least Ruby 1.9. Also, a
-recent version of libCURL is required. We recommend at least 7.19.4 because
+Patron 1.0 and up requires MRI Ruby 2.3 or newer. The 0.x versions support
+Ruby 1.9.3 and these versions get tagged and developed on the `v0.x` branch.
+
+A recent version of libCURL is required. We recommend at least 7.19.4 because
 it [supports limiting the protocols](https://curl.haxx.se/libcurl/c/CURLOPT_PROTOCOLS.html),
 and that is very important for security - especially if you follow redirects. 
 
@@ -90,9 +114,6 @@ On OSX the provided libcurl is sufficient if you are not using fork+SSL combinat
 You will have to install the libcurl development packages on Debian or Ubuntu. Other Linux systems are probably
 similar. For Windows we do not have an established build instruction at the moment, unfortunately.
 
-Versions of Patron below 1.0 will maintain compatibility down to Ruby 1.9.3,
-versions below 2.0 will maintain compatibility down to Ruby 2.3
-
 ## Forking webservers on macOS and SSL
 
 Currently, [an issue is at play](https://github.com/curl/curl/issues/788) with OSX builds of `curl` which use

data/ext/patron/extconf.rb

@@ -19,9 +19,8 @@ if CONFIG['CC'] =~ /gcc/
   $CFLAGS << ' -pedantic -Wall'
 end
 
-$defs.push("-DUSE_TBR")
-$defs.push("-DHAVE_THREAD_H") if have_header('ruby/thread.h')
-$defs.push("-DHAVE_TBR") if have_func('rb_thread_blocking_region', 'ruby.h')
-$defs.push("-DHAVE_TCWOGVL") if have_header('ruby/thread.h') && have_func('rb_thread_call_without_gvl', 'ruby/thread.h')
+if CONFIG['CC'] =~ /clang/
+  $CFLAGS << ' -pedantic -Wall -Wno-void-pointer-to-enum-cast'
+end
 
 create_makefile 'patron/session_ext'

data/ext/patron/session_ext.c

@@ -1,7 +1,5 @@
 #include <ruby.h>
-#if defined(USE_TBR) && defined(HAVE_THREAD_H)
 #include <ruby/thread.h>
-#endif
 #include <sys/stat.h>
 #include <curl/curl.h>
 #include "membuffer.h"
@@ -29,6 +27,8 @@ static VALUE eAborted = Qnil;
 
 struct patron_curl_state {
   CURL* handle;
+  CURL* base_handle;
+  CURLSH* share;
   char* upload_buf;
   FILE* download_file;
   FILE* debug_file;
@@ -77,7 +77,7 @@ static size_t file_write_handler(void* stream, size_t size, size_t nmemb, FILE*
 static int call_user_rb_progress_blk(void* vd_curl_state) {
   struct patron_curl_state* state = (struct patron_curl_state*)vd_curl_state;
   // Invoke the block with the array
-  VALUE blk_result = rb_funcall(state->user_progress_blk,
+  rb_funcall(state->user_progress_blk,
     rb_intern("call"), 4,
     LONG2NUM(state->dltotal),
     LONG2NUM(state->dlnow),
@@ -103,15 +103,7 @@ static int session_progress_handler(void* clientp, size_t dltotal, size_t dlnow,
   // `call_user_rb_progress_blk`. TODO: use the retval of that proc
   // to permit premature abort 
   if(RTEST(state->user_progress_blk)) {
-    // Even though it is not documented, rb_thread_call_with_gvl is available even when
-    // rb_thread_call_without_gvl is not. See https://bugs.ruby-lang.org/issues/5543#note-4
-    // > rb_thread_call_with_gvl() is globally-visible (but not in headers)
-    // > for 1.9.3: https://bugs.ruby-lang.org/issues/4328
-    #if (defined(HAVE_TBR) || defined(HAVE_TCWOGVL)) && defined(USE_TBR)
-        rb_thread_call_with_gvl((void *(*)(void *)) call_user_rb_progress_blk, (void*)state);
-    #else
-        call_user_rb_progress_blk((void*)state);
-    #endif
+    rb_thread_call_with_gvl((void *(*)(void *)) call_user_rb_progress_blk, (void*)state);
   }
 
   // Set the interrupt if the download byte limit has been reached
@@ -129,9 +121,10 @@ static int session_progress_handler(void* clientp, size_t dltotal, size_t dlnow,
 }
 
 
-/*----------------------------------------------------------------------------*/
-/* List of active curl sessions                                               */
-
+/*
+  List of active curl sessions, used exclusively to be able to set interrupts
+  for all of them if the Ruby interpreter gets shut down with libCURL requests still in flight.
+*/
 struct patron_curl_state_list {
   struct patron_curl_state       *state;
   struct patron_curl_state_list  *next;
@@ -184,20 +177,18 @@ static void session_close_debug_file(struct patron_curl_state *curl) {
 }
 
 /* Cleans up the patron_curl_state data when the Session object is garbage collected. */
-void session_free(struct patron_curl_state *curl) {
-  if (curl->handle) {
-    curl_easy_cleanup(curl->handle);
-    curl->handle = NULL;
-  }
+void session_free(struct patron_curl_state *state) {
+  curl_easy_cleanup(state->base_handle);
+  curl_share_cleanup(state->share);
 
-  session_close_debug_file(curl);
+  session_close_debug_file(state);
 
-  membuffer_destroy( &curl->header_buffer );
-  membuffer_destroy( &curl->body_buffer );
+  membuffer_destroy(&state->header_buffer);
+  membuffer_destroy(&state->body_buffer);
 
-  cs_list_remove(curl);
+  cs_list_remove(state);
 
-  free(curl);
+  free(state);
 }
 
 /* Allocates patron_curl_state data needed for a new Session object. */
@@ -215,16 +206,34 @@ VALUE session_alloc(VALUE klass) {
     reuse the TCP connection and can speed things up if the same resource - like a backend service -
     gets accessed over and over with requests.
   */
-  state->handle = curl_easy_init();
-  curl_easy_setopt(state->handle, CURLOPT_NOSIGNAL, 1);
-  curl_easy_setopt(state->handle, CURLOPT_NOPROGRESS, 0);
-  #if LIBCURL_VERSION_NUM >= 0x072000
-    /* this is libCURLv7.32.0 or later, supports CURLOPT_XFERINFOFUNCTION */
-    curl_easy_setopt(state->handle, CURLOPT_XFERINFOFUNCTION, &session_progress_handler);
-  #else
-    curl_easy_setopt(state->handle, CURLOPT_PROGRESSFUNCTION, &session_progress_handler);
-  #endif
-  curl_easy_setopt(state->handle, CURLOPT_PROGRESSDATA, state);
+  state->share = curl_share_init();
+  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();
+  curl_easy_setopt(state->base_handle, CURLOPT_SHARE, state->share);
+  curl_easy_setopt(state->base_handle, CURLOPT_WRITEFUNCTION, &session_write_handler);
+  curl_easy_setopt(state->base_handle, CURLOPT_WRITEDATA, &state->body_buffer);
+  curl_easy_setopt(state->base_handle, CURLOPT_HEADERFUNCTION, &session_write_handler);
+  curl_easy_setopt(state->base_handle, CURLOPT_HEADERDATA, &state->header_buffer);
+  curl_easy_setopt(state->base_handle, CURLOPT_NOSIGNAL, 1);
+  curl_easy_setopt(state->base_handle, CURLOPT_NOPROGRESS, 0);
+#if LIBCURL_VERSION_NUM >= 0x072000
+  /* this is libCURLv7.32.0 or later, supports CURLOPT_XFERINFOFUNCTION */
+  curl_easy_setopt(state->base_handle, CURLOPT_XFERINFOFUNCTION, &session_progress_handler);
+#else
+  curl_easy_setopt(state->base_handle, CURLOPT_PROGRESSFUNCTION, &session_progress_handler);
+#endif
+  curl_easy_setopt(state->base_handle, CURLOPT_PROGRESSDATA, state);
+#ifdef CURLPROTO_HTTP
+  // Security: do not allow Curl to go looking on gopher/SMTP etc.
+  // Must prevent situations like this:
+  // https://hackerone.com/reports/115748
+  curl_easy_setopt(state->base_handle, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
+  curl_easy_setopt(state->base_handle, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
+#endif
 
   return obj;
 }
@@ -276,13 +285,22 @@ static VALUE session_escape(VALUE self, VALUE value) {
   char* escaped = NULL;
   VALUE retval = Qnil;
 
-  struct patron_curl_state* state = curl_easy_init();
-  escaped = curl_easy_escape(state->handle,
+#if LIBCURL_VERSION_NUM >= 0x075200
+  /* this is libCURLv7.82.0 or later, the curl parameter is ignored */
+  CURL *curl = NULL;
+#else
+  CURL* curl = curl_easy_init();
+#endif
+  escaped = curl_easy_escape(curl,
                              RSTRING_PTR(string),
                              (int) RSTRING_LEN(string));
 
   retval = rb_str_new2(escaped);
-  curl_easy_cleanup(state);
+#if LIBCURL_VERSION_NUM >= 0x075200
+  /* this is libCURLv7.82.0 or later, the curl parameter is ignored */
+#else
+  curl_easy_cleanup(curl);
+#endif
   curl_free(escaped);
 
   return retval;
@@ -299,15 +317,24 @@ static VALUE session_unescape(VALUE self, VALUE value) {
   char* unescaped = NULL;
   VALUE retval = Qnil;
 
-  struct patron_curl_state* state = curl_easy_init();
-  unescaped = curl_easy_unescape(state->handle,
+#if LIBCURL_VERSION_NUM >= 0x075200
+  /* this is libCURLv7.82.0 or later, the curl parameter is ignored */
+  CURL *curl = NULL;
+#else
+  CURL *curl = curl_easy_init();
+#endif
+  unescaped = curl_easy_unescape(curl,
                                  RSTRING_PTR(string),
                                  (int) RSTRING_LEN(string),
                                  NULL);
 
   retval = rb_str_new2(unescaped);
   curl_free(unescaped);
-  curl_easy_cleanup(state);
+#if LIBCURL_VERSION_NUM >= 0x075200
+  /* this is libCURLv7.82.0 or later, the curl parameter is ignored */
+#else
+  curl_easy_cleanup(curl);
+#endif
 
   return retval;
 }
@@ -433,7 +460,7 @@ static void set_request_body(struct patron_curl_state* state, VALUE stringable_o
  */
 static void set_options_from_request(VALUE self, VALUE request) {
   struct patron_curl_state* state = get_patron_curl_state(self);
-  CURL* curl = state->handle;
+  CURL* curl = curl_easy_duphandle(state->base_handle);
 
   ID    action                = Qnil;
   VALUE headers               = Qnil;
@@ -454,6 +481,9 @@ static void set_options_from_request(VALUE self, VALUE request) {
   VALUE download_byte_limit   = rb_funcall(request, rb_intern("download_byte_limit"), 0);
   VALUE maybe_progress_proc   = rb_funcall(request, rb_intern("progress_callback"), 0);
 
+  state->handle = curl;
+  curl_easy_setopt(curl, CURLOPT_SHARE, state->share);
+
   if (RTEST(download_byte_limit)) {
     state->download_byte_limit = FIX2INT(download_byte_limit);
   } else {
@@ -475,7 +505,7 @@ static void set_options_from_request(VALUE self, VALUE request) {
   }
 
   action = SYM2ID(action_name);
-  if(rb_funcall(request, rb_intern("force_ipv4"), 0)) {
+  if (RTEST(rb_funcall(request, rb_intern("force_ipv4"), 0))) {
     curl_easy_setopt(curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
   }
   if (action == rb_intern("get")) {
@@ -578,13 +608,6 @@ static void set_options_from_request(VALUE self, VALUE request) {
   }
   curl_easy_setopt(curl, CURLOPT_URL, StringValuePtr(url));
   
-#ifdef CURLPROTO_HTTP
-  // Security: do not allow Curl to go looking on gopher/SMTP etc.
-  // Must prevent situations like this:
-  // https://hackerone.com/reports/115748
-  curl_easy_setopt(curl, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
-  curl_easy_setopt(curl, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
-#endif
     
   timeout = rb_funcall(request, rb_intern("timeout"), 0);
   if (RTEST(timeout)) {
@@ -722,11 +745,6 @@ static void set_options_from_request(VALUE self, VALUE request) {
   if (RTEST(buffer_size)) {
      curl_easy_setopt(curl, CURLOPT_BUFFERSIZE, NUM2LONG(buffer_size));
   }
-
-  if(state->debug_file) {
-    curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
-    curl_easy_setopt(curl, CURLOPT_STDERR, state->debug_file);
-  }
 }
 
 /* Use the info in a Curl handle to create a new Response object. */
@@ -741,10 +759,10 @@ static VALUE create_response(VALUE self, CURL* curl, VALUE header_buffer, VALUE
   args[0] = rb_str_new2(effective_url);
 
   curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
-  args[1] = INT2NUM(code);
+  args[1] = LONG2NUM(code);
 
   curl_easy_getinfo(curl, CURLINFO_REDIRECT_COUNT, &count);
-  args[2] = INT2NUM(count);
+  args[2] = LONG2NUM(count);
 
   args[3] = header_buffer;
   args[4] = body_buffer;
@@ -787,48 +805,19 @@ void session_ubf_abort(void* patron_state) {
 static VALUE perform_request(VALUE self) {
   struct patron_curl_state *state = get_patron_curl_state(self);
   CURL* curl = state->handle;
-  membuffer* header_buffer = NULL;
-  membuffer* body_buffer = NULL;
   CURLcode ret = 0;
 
   state->interrupt = 0;            /* clear the interrupt flag */
 
-  header_buffer = &state->header_buffer;
-  body_buffer = &state->body_buffer;
-
-  membuffer_clear(header_buffer);
-  membuffer_clear(body_buffer);
-
-  /* headers */
-  curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, &session_write_handler);
-  curl_easy_setopt(curl, CURLOPT_HEADERDATA, header_buffer);
-
-  /* body */
-  if (!state->download_file) {
-    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &session_write_handler);
-    curl_easy_setopt(curl, CURLOPT_WRITEDATA, body_buffer);
-  }
-
-#if (defined(HAVE_TBR) || defined(HAVE_TCWOGVL)) && defined(USE_TBR)
-  #if defined(HAVE_TCWOGVL)
-    ret = (CURLcode) rb_thread_call_without_gvl(
-            (void *(*)(void *)) curl_easy_perform, curl,
-            session_ubf_abort, (void*)state
-          );
-  #else
-    ret = (CURLcode) rb_thread_blocking_region(
-            (rb_blocking_function_t*) curl_easy_perform, curl,
-            session_ubf_abort, (void*)state
-          );
-  #endif
-#else
-  ret = curl_easy_perform(curl);
-#endif
+  ret = (CURLcode) rb_thread_call_without_gvl(
+          (void *(*)(void *)) curl_easy_perform, curl,
+          session_ubf_abort, (void*)state
+        );
 
   if (CURLE_OK == ret) {
-    VALUE header_str = membuffer_to_rb_str(header_buffer);
+    VALUE header_str = membuffer_to_rb_str(&state->header_buffer);
     VALUE body_str = Qnil;
-    if (!state->download_file) { body_str = membuffer_to_rb_str(body_buffer); }
+    if (!state->download_file) { body_str = membuffer_to_rb_str(&state->body_buffer); }
     
     curl_easy_setopt(curl, CURLOPT_COOKIELIST, "FLUSH"); // Flush cookies to the cookie jar
     
@@ -843,16 +832,19 @@ static VALUE perform_request(VALUE self) {
  */
 static VALUE cleanup(VALUE self) {
   struct patron_curl_state *state = get_patron_curl_state(self);
-  curl_easy_reset(state->handle);
+  curl_easy_cleanup(state->handle);
 
   if (state->headers) {
     curl_slist_free_all(state->headers);
     state->headers = NULL;
   }
+  membuffer_clear(&state->header_buffer);
 
   if (state->download_file) {
     fclose(state->download_file);
     state->download_file = NULL;
+  } else {
+    membuffer_clear(&state->body_buffer);
   }
 
   if (state->request_body_file) {
@@ -912,7 +904,7 @@ static VALUE session_interrupt(VALUE self) {
  */
 static VALUE add_cookie_file(VALUE self, VALUE file) {
   struct patron_curl_state *state = get_patron_curl_state(self);
-  CURL* curl = state->handle;
+  CURL* curl = state->base_handle;
   char* file_path = NULL;
 
   // FIXME: http://websystemsengineering.blogspot.nl/2013/03/curloptcookiefile-vs-curloptcookiejar.html
@@ -933,7 +925,8 @@ static VALUE add_cookie_file(VALUE self, VALUE file) {
  */
 static VALUE set_debug_file(VALUE self, VALUE file) {
   struct patron_curl_state *state = get_patron_curl_state(self);
-  char* file_path = RSTRING_PTR(file);
+  CURL *curl = state->base_handle;
+  char *file_path = RSTRING_PTR(file);
 
   session_close_debug_file(state);
 
@@ -942,6 +935,8 @@ static VALUE set_debug_file(VALUE self, VALUE file) {
   } else {
     state->debug_file = stderr;
   }
+  curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
+  curl_easy_setopt(curl, CURLOPT_STDERR, state->debug_file);
 
   return self;
 }
@@ -986,11 +981,11 @@ void Init_session_ext() {
   rb_define_singleton_method(cSession, "unescape",   session_unescape,         1);
   rb_define_method(cSession, "unescape",       session_unescape,       1);
 
-  rb_define_method(cSession, "handle_request", session_handle_request, 1);
+  rb_define_private_method(cSession, "handle_request", session_handle_request, 1);
   rb_define_method(cSession, "reset",          session_interrupt,      0);
   rb_define_method(cSession, "interrupt",      session_interrupt,      0);
-  rb_define_method(cSession, "add_cookie_file", add_cookie_file, 1);
-  rb_define_method(cSession, "set_debug_file", set_debug_file, 1);
+  rb_define_private_method(cSession, "add_cookie_file", add_cookie_file, 1);
+  rb_define_private_method(cSession, "set_debug_file", set_debug_file, 1);
   rb_define_alias(cSession, "urlencode", "escape");
   rb_define_alias(cSession, "urldecode", "unescape");
 

data/lib/patron/request.rb

@@ -34,8 +34,8 @@ module Patron
       :low_speed_time, :low_speed_limit, :progress_callback
     ]
 
-    attr_reader *READER_VARS
-    attr_writer *WRITER_VARS
+    attr_reader(*READER_VARS)
+    attr_writer(*WRITER_VARS)
 
     # Set the type of authentication to use for this request.
     #

data/lib/patron/session.rb

@@ -103,8 +103,6 @@ module Patron
     # @see low_speed_time
     attr_accessor :low_speed_limit
 
-    private :handle_request, :add_cookie_file, :set_debug_file
-
     # @return [#call, nil] callable object that will be called with 4 arguments
     #    during request/response execution - `dltotal`, `dlnow`, `ultotal`, `ulnow`.
     #    All these arguments are in bytes.
@@ -146,9 +144,9 @@ module Patron
       if file_path
         path = Pathname(file_path).expand_path
         
-        if !File.exists?(file_path) && !File.writable?(path.dirname)
+        if !File.exist?(file_path) && !File.writable?(path.dirname)
           raise ArgumentError, "Can't create file #{path} (permission error)"
-        elsif File.exists?(file_path) && !File.writable?(file_path)
+        elsif File.exist?(file_path) && !File.writable?(file_path)
           raise ArgumentError, "Can't read or write file #{path} (permission error)"
         end
       else

data/lib/patron/version.rb

@@ -1,3 +1,3 @@
 module Patron
-  VERSION = "0.13.3"
+  VERSION = "0.13.4"
 end