patron 0.13.1 → 0.13.4

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;
@@ -163,6 +156,7 @@ static void cs_list_remove(struct patron_curl_state *state) {
   }
 }
 
+/* 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);
 
@@ -182,31 +176,64 @@ static void session_close_debug_file(struct patron_curl_state *curl) {
   curl->debug_file = NULL;
 }
 
-/* Cleans up the Curl handle 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;
-  }
+/* Cleans up the patron_curl_state data when the Session object is garbage collected. */
+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. */
 VALUE session_alloc(VALUE klass) {
-  struct patron_curl_state* curl;
-  VALUE obj = Data_Make_Struct(klass, struct patron_curl_state, NULL, session_free, curl);
-
-  membuffer_init( &curl->header_buffer );
-  membuffer_init( &curl->body_buffer );
-  cs_list_append(curl);
+  struct patron_curl_state* state;
+  VALUE obj = Data_Make_Struct(klass, struct patron_curl_state, NULL, session_free, state);
+
+  membuffer_init(&state->header_buffer);
+  membuffer_init(&state->body_buffer);
+  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();
+  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;
 }
@@ -215,25 +242,9 @@ VALUE session_alloc(VALUE klass) {
 static struct patron_curl_state* get_patron_curl_state(VALUE self) {
   struct patron_curl_state* state;
   Data_Get_Struct(self, struct patron_curl_state, state);
-
-  if (NULL == state->handle) {
-    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);
-  }
-
   return state;
 }
 
-
 /*----------------------------------------------------------------------------*/
 /* Method implementations                                                     */
 
@@ -274,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;
@@ -297,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;
 }
@@ -431,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;
@@ -452,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 {
@@ -473,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")) {
@@ -576,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)) {
@@ -720,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. */
@@ -739,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;
@@ -785,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
     
@@ -841,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) {
@@ -887,33 +881,9 @@ static VALUE session_handle_request(VALUE self, VALUE request) {
   return rb_ensure(&perform_request, self, &cleanup, self);
 }
 
-/*
- * FIXME: figure out how this method should be used at all given Session is not multithreaded.
- * FIXME: also: what is the difference with `interrupt()` and also relationship with `cleanup()`?
- * Reset the underlying cURL session. This effectively closes all open
- * connections and disables debug output. There is no need to call this method
- * manually after performing a request, since cleanup is performed automatically
- * but the method can be used from another thread
- * to abort a request currently in progress.
- *
- * @return self
- */
-static VALUE session_reset(VALUE self) {
-  struct patron_curl_state *state;
-  Data_Get_Struct(self, struct patron_curl_state, state);
-
-  if (NULL != state->handle) {
-    cleanup(self);
-    curl_easy_cleanup(state->handle);
-    state->handle = NULL;
-    session_close_debug_file(state);
-  }
-
-  return self;
-}
-
 /* Interrupt any currently executing request. This will cause the current
- * request to error and raise an exception.
+ * request to error and raise an exception. The method can be called from another thread to
+ * abort the request in-flight.
  *
  * @return [void] This method always raises
  */
@@ -934,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
@@ -955,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);
 
@@ -964,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;
 }
@@ -1008,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_method(cSession, "reset",          session_reset,          0);
+  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.1"
+  VERSION = "0.13.4"
 end

data/patron.gemspec

@@ -6,23 +6,23 @@ require 'patron/version'
 Gem::Specification.new do |spec|
   spec.name        = "patron"
   spec.version     = Patron::VERSION
+  spec.licenses    = ["MIT"]
   spec.platform    = Gem::Platform::RUBY
-  spec.authors     = ["Phillip Toland"]
-  spec.email       = ["phil.toland@gmail.com"]
+  spec.authors     = ["Aeryn Riley Dowling-Toland"]
+  spec.email       = ["aeryn.toland@gmail.com"]
   spec.homepage    = "https://github.com/toland/patron"
   spec.summary     = "Patron HTTP Client"
   spec.description = "Ruby HTTP client library based on libcurl"
 
-  # Prevent pushing this gem to RubyGemspec.org. To allow pushes either set the 'allowed_push_host'
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
   # to allow pushing to a single host or delete this section to allow pushing to any host.
   if spec.respond_to?(:metadata)
     spec.metadata['allowed_push_host'] = "https://rubygems.org"
   else
-    raise "RubyGems 2.0 or newer is required to protect against public gem pushespec."
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
   end
 
   spec.required_rubygems_version = ">= 1.2.0"
-  spec.rubyforge_project = "patron"
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.bindir        = "exe"
@@ -31,16 +31,8 @@ Gem::Specification.new do |spec|
   spec.extensions   = ["ext/patron/extconf.rb"]
   spec.post_install_message = %q{
 Thank you for installing Patron. On OSX, make sure you are using libCURL with OpenSSL.
-SecureTransport-based builds might cause crashes in forking environment.
+SecureTransport-based builds might cause crashes in forking environments.
 
 For more info see https://github.com/curl/curl/issues/788
 }
-  spec.add_development_dependency "rake", "~> 10"
-  spec.add_development_dependency "bundler", ">= 1"
-  spec.add_development_dependency "rspec", ">= 2.3.0"
-  spec.add_development_dependency "simplecov", "~> 0.10"
-  spec.add_development_dependency "yard", "~> 0.9.11"
-  spec.add_development_dependency "rack", "~> 1"
-  spec.add_development_dependency "puma", '~> 3.11'
-  spec.add_development_dependency "rake-compiler"
 end

data/spec/patron_spec.rb

@@ -10,7 +10,7 @@ describe Patron do
   
   it "should return the version number of the Patron library" do
     version = Patron.version
-    expect(version).to match(%r|^\d+.\d+.\d+$|)
+    expect(version).to match(%r|^\d+.\d+.\d+(\.\w+\.\d+)?$|)
   end
 
   it "should return the version string of the libcurl library" do