curb 0.9.6 → 0.9.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 53aeed05cc43efb7e736097fd212e43a8b25e21b
-  data.tar.gz: 129c6741252ba30006df855fb7543eba7e706fca
+SHA256:
+  metadata.gz: ecd73a0ad8d98960321b8d523e25bad95ff25e8900e8acb187051ca40c7a1cba
+  data.tar.gz: c154996d92946fe83fa12d695b073d5026e4a55e92efd177bfad021461f2b313
 SHA512:
-  metadata.gz: e2f6065c80853bdc3d17d69316e202b7f7f73d5ab4925171fa50847e370978b67f4419144559305beb002a7e91dc5cf6b359b1d643237cb17699c37ba07d936f
-  data.tar.gz: b76fd1724733c9566e4150c4467370ca63a40838f59e8b6ab1412d8b893eca1ebfe12cca6bb8ac59f607292498daa4e97d06fd9239ac7d651b5441b4e2f2abfa
+  metadata.gz: 48854a4f0d77befe0e81b31a3d39e826b2ef65d58d0226b617a355ba8d063ab4998853a8709ae6d2e3c4629c09ff987099398a1c884b76d95dcf956d941fc660
+  data.tar.gz: 3291675a74eb40f42d936bb65689da7d5f295e038ed019482d2cf115ba878232ce4e40aeb125d0fe786b5e82428320938ff3c75592a5c54a2d51fbe8589a0931

data/README.markdown

@@ -7,7 +7,7 @@ Curb (probably CUrl-RuBy or something) provides Ruby-language bindings for the
 libcurl(3), a fully-featured client-side URL transfer library.
 cURL and libcurl live at [http://curl.haxx.se/](http://curl.haxx.se/) .
 
-Curb is a work-in-progress, and currently only supports libcurl's 'easy' and 'multi' modes.
+Curb is a work-in-progress, and currently only supports libcurl's `easy` and `multi` modes.
 
 ## License
 
@@ -16,10 +16,26 @@ Ruby license. See the LICENSE file for the gory details.
 
 ## You will need
 
-* A working Ruby installation (1.8+, tested with 1.8.6, 1.8.7, 1.9.1, and 1.9.2)
-* A working (lib)curl installation, with development stuff (7.5+, tested with 7.19.x)
+* A working Ruby installation (`1.8.7+` will work but `2.1+` preferred)
+* A working libcurl development installation
+(Ideally one of the versions listed in the compatibility chart below that maps to your `curb` version)
 * A sane build environment (e.g. gcc, make)
 
+## Version Compatibility chart
+
+A **non-exhaustive** set of compatibility versions of the libcurl library
+with this gem are as follows. (Note that these are only the ones that have been
+tested and reported to work across a variety of platforms / rubies)
+
+| Gem Version | Release Date | libcurl versions |
+| ----------- | -----------  | ---------------- |
+| 0.9.8       | Jan 2019     | 7.58 - 7.63      |
+| 0.9.7       | Nov 2018     | 7.56 - 7.60      |
+| 0.9.6       | May 2018     | 7.51 - 7.59      |
+| 0.9.5       | May 2018     | 7.51 - 7.59      |
+| 0.9.4       | Aug 2017     | 7.41 - 7.58      |
+| 0.9.3       | Apr 2016     | 7.26 - 7.58      |
+
 ## Installation...
 
 ... will usually be as simple as:
@@ -30,7 +46,11 @@ On Windows, make sure you're using the [DevKit](http://rubyinstaller.org/downloa
 the [development version of libcurl](http://curl.haxx.se/gknw.net/7.39.0/dist-w32/curl-7.39.0-devel-mingw32.zip). Unzip, then run this in your command
 line (alter paths to your curl location, but remember to use forward slashes):
 
-    gem install curb --platform=ruby -- --with-curl-lib=C:/curl-7.39.0-devel-mingw32/bin --with-curl-include=C:/curl-7.39.0-devel-mingw32/include
+    gem install curb --platform=ruby -- --with-curl-lib=C:/curl-7.39.0-devel-mingw32/lib --with-curl-include=C:/curl-7.39.0-devel-mingw32/include
+    
+Note that with Windows moving from one method of compiling to another as of Ruby `2.4` (DevKit -> MYSYS2),
+the usage of Ruby `2.4+` with this gem on windows is unlikely to work. It is advised to use the
+latest version of Ruby 2.3 available [HERE](https://dl.bintray.com/oneclick/rubyinstaller/rubyinstaller-2.3.3.exe)
 
 Or, if you downloaded the archive:
 
@@ -134,9 +154,9 @@ c.perform
 ### HTTP "insecure" SSL connections (like curl -k, --insecure) to avoid Curl::Err::SSLCACertificateError:
 
 ```ruby
-    c = Curl::Easy.new("https://github.com/")
-    c.ssl_verify_peer = false
-    c.perform
+c = Curl::Easy.new("https://github.com/")
+c.ssl_verify_peer = false
+c.perform
 ```
 
 ### Supplying custom handlers:

data/Rakefile

@@ -2,11 +2,6 @@
 # 
 require 'rake/clean'
 require 'rake/testtask'
-begin
-  require 'rdoc/task'
-rescue LoadError => e
-  require 'rake/rdoctask'
-end
 
 CLEAN.include '**/*.o'
 CLEAN.include "**/*.#{(defined?(RbConfig) ? RbConfig : Config)::MAKEFILE_CONFIG['DLEXT']}"
@@ -15,6 +10,22 @@ CLOBBER.include '**/*.log'
 CLOBBER.include '**/Makefile'
 CLOBBER.include '**/extconf.h'
 
+# Not available for really old rubies, but that's ok.
+begin
+  require 'pry'
+rescue LoadError
+  puts "Failed to load pry."
+end
+
+# Load support ruby and rake files (in this order)
+Dir.glob('tasks/*.rb').each { |r| load r}
+Dir.glob('tasks/*.rake').each { |r| load r}
+
+desc 'Print Ruby major version (ie "2_5")'
+task :ruby_version do
+  print current_ruby_major
+end
+
 def announce(msg='')
   $stderr.puts msg
 end
@@ -43,12 +54,11 @@ end
 make_program = (/mswin/ =~ RUBY_PLATFORM) ? 'nmake' : 'make'
 MAKECMD = ENV['MAKE_CMD'] || make_program
 MAKEOPTS = ENV['MAKE_OPTS'] || ''
-
 CURB_SO = "ext/curb_core.#{(defined?(RbConfig) ? RbConfig : Config)::MAKEFILE_CONFIG['DLEXT']}"
 
 file 'ext/Makefile' => 'ext/extconf.rb' do
   Dir.chdir('ext') do
-    ruby "extconf.rb #{ENV['EXTCONF_OPTS']}"
+    shell('ruby', 'extconf.rb', ENV['EXTCONF_OPTS'].to_s, live_stdout: STDOUT)
   end
 end
 
@@ -89,12 +99,12 @@ if ENV['RELTEST']
 else
   task :alltests => [:unittests, :bugtests]
 end
-                    
+
 Rake::TestTask.new(:unittests) do |t|
   t.test_files = FileList['tests/tc_*.rb']
   t.verbose = false
 end
-                          
+
 Rake::TestTask.new(:bugtests) do |t|
   t.test_files = FileList['tests/bug_*.rb']
   t.verbose = false
@@ -136,6 +146,12 @@ end
 
 desc "Publish the RDoc documentation to project web site"
 task :doc_upload => [ :doc ] do
+  begin
+    require 'rdoc/task'
+  rescue LoadError => e
+    require 'rake/rdoctask'
+  end
+
   if ENV['RELTEST']
     announce "Release Task Testing, skipping doc upload"
   else    
@@ -170,7 +186,7 @@ else
     spec_source = File.read File.join(File.dirname(__FILE__),'curb.gemspec')
     spec = nil
     # see: http://gist.github.com/16215
-    Thread.new { spec = eval("$SAFE = 3\n#{spec_source}") }.join
+    Thread.new { spec = eval("#{spec_source}") }.join
     spec.validate
     Gem::Package.build(spec)
   end

data/ext/banned.h

@@ -0,0 +1,32 @@
+#ifndef BANNED_H
+#define BANNED_H
+
+/*
+ * This header lists functions that have been banned from our code base,
+ * because they're too easy to misuse (and even if used correctly,
+ * complicate audits). Including this header turns them into compile-time
+ * errors.
+ */
+
+#define BANNED(func) sorry_##func##_is_a_banned_function
+
+#undef strcpy
+#define strcpy(x,y) BANNED(strcpy)
+#undef strcat
+#define strcat(x,y) BANNED(strcat)
+#undef strncpy
+#define strncpy(x,y,n) BANNED(strncpy)
+#undef strncat
+#define strncat(x,y,n) BANNED(strncat)
+
+#undef sprintf
+#undef vsprintf
+#ifdef HAVE_VARIADIC_MACROS
+#define sprintf(...) BANNED(sprintf)
+#define vsprintf(...) BANNED(vsprintf)
+#else
+#define sprintf(buf,fmt,arg) BANNED(sprintf)
+#define vsprintf(buf,fmt,arg) BANNED(sprintf)
+#endif
+
+#endif /* BANNED_H */

data/ext/curb.c

@@ -352,6 +352,13 @@ void Init_curb_core() {
   rb_define_const(mCurl, "CURLPROXY_SOCKS5", LONG2NUM(-2));
 #endif
 
+  /* When passed to Curl::Easy#proxy_type , indicates that the proxy is a SOCKS5 proxy (and that the proxy should resolve the hostname). (libcurl >= 7.17.2) */
+#ifdef HAVE_CURLPROXY_SOCKS5_HOSTNAME
+  rb_define_const(mCurl, "CURLPROXY_SOCKS5_HOSTNAME", LONG2NUM(CURLPROXY_SOCKS5_HOSTNAME));
+#else
+  rb_define_const(mCurl, "CURLPROXY_SOCKS5_HOSTNAME", LONG2NUM(-2));
+#endif
+
   /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, directs libcurl to use Basic authentication. */
 #ifdef HAVE_CURLAUTH_BASIC
   rb_define_const(mCurl, "CURLAUTH_BASIC", LONG2NUM(CURLAUTH_BASIC));
@@ -585,6 +592,9 @@ void Init_curb_core() {
   CURB_DEFINE(CURLOPT_REFERER);
   CURB_DEFINE(CURLOPT_USERAGENT);
   CURB_DEFINE(CURLOPT_HTTPHEADER);
+#if HAVE_CURLOPT_PROXYHEADER
+  CURB_DEFINE(CURLOPT_PROXYHEADER);
+#endif
 #if HAVE_CURLOPT_HTTP200ALIASES
   CURB_DEFINE(CURLOPT_HTTP200ALIASES);
 #endif
@@ -1030,6 +1040,16 @@ void Init_curb_core() {
   CURB_DEFINE(CURLOPT_PIPEWAIT);
 #endif
 
+#if HAVE_CURLOPT_TCP_KEEPALIVE
+  CURB_DEFINE(CURLOPT_TCP_KEEPALIVE);
+  CURB_DEFINE(CURLOPT_TCP_KEEPIDLE);
+  CURB_DEFINE(CURLOPT_TCP_KEEPINTVL);
+#endif
+
+#if HAVE_CURLOPT_HAPROXYPROTOCOL
+  CURB_DEFINE(CURLOPT_HAPROXYPROTOCOL);
+#endif
+
 #if LIBCURL_VERSION_NUM >= 0x072B00 /* 7.43.0 */
   CURB_DEFINE(CURLPIPE_NOTHING);
   CURB_DEFINE(CURLPIPE_HTTP1);

data/ext/curb.h

@@ -9,8 +9,16 @@
 #define __CURB_H
 
 #include <ruby.h>
+
+#ifdef HAVE_RUBY_IO_H
+#include "ruby/io.h"
+#else
+#include "rubyio.h" // ruby 1.8
+#endif
+
 #include <curl/curl.h>
 
+#include "banned.h"
 #include "curb_config.h"
 #include "curb_easy.h"
 #include "curb_errors.h"
@@ -20,11 +28,11 @@
 #include "curb_macros.h"
 
 // These should be managed from the Rake 'release' task.
-#define CURB_VERSION   "0.9.6"
-#define CURB_VER_NUM   906
+#define CURB_VERSION   "0.9.11"
+#define CURB_VER_NUM   9011
 #define CURB_VER_MAJ   0
-#define CURB_VER_MIN   6
-#define CURB_VER_MIC   0
+#define CURB_VER_MIN   9
+#define CURB_VER_MIC   11
 #define CURB_VER_PATCH 0
 
 

data/ext/curb_easy.c

@@ -25,6 +25,12 @@ static VALUE rbstrAmp;
 
 VALUE cCurlEasy;
 
+// for Ruby 1.8
+#ifndef HAVE_RB_IO_STDIO_FILE
+static FILE * rb_io_stdio_file(rb_io_t *fptr) {
+  return fptr->f;
+}
+#endif
 
 /* ================== CURL HANDLER FUNCS ==============*/
 
@@ -223,6 +229,10 @@ static void ruby_curl_easy_free(ruby_curl_easy *rbce) {
     curl_slist_free_all(rbce->curl_headers);
   }
 
+  if (rbce->curl_proxy_headers) {
+    curl_slist_free_all(rbce->curl_proxy_headers);
+  }
+
   if (rbce->curl_ftp_commands) {
     curl_slist_free_all(rbce->curl_ftp_commands);
   }
@@ -243,6 +253,7 @@ static void ruby_curl_easy_free(ruby_curl_easy *rbce) {
     curl_easy_setopt(rbce->curl, CURLOPT_PROGRESSFUNCTION, NULL);
     curl_easy_setopt(rbce->curl, CURLOPT_NOPROGRESS, 1);
     curl_easy_cleanup(rbce->curl);
+    rbce->curl = NULL;
   }
 }
 
@@ -258,6 +269,7 @@ static void ruby_curl_easy_zero(ruby_curl_easy *rbce) {
   rbce->opts = rb_hash_new();
 
   rbce->curl_headers = NULL;
+  rbce->curl_proxy_headers = NULL;
   rbce->curl_ftp_commands = NULL;
   rbce->curl_resolve = NULL;
 
@@ -277,6 +289,8 @@ static void ruby_curl_easy_zero(ruby_curl_easy *rbce) {
   rbce->ftp_response_timeout = 0;
   rbce->low_speed_limit = 0;
   rbce->low_speed_time = 0;
+  rbce->max_send_speed_large = 0;
+  rbce->max_recv_speed_large = 0;
   rbce->ssl_version = -1;
   rbce->use_ssl = -1;
   rbce->ftp_filemethod = -1;
@@ -343,7 +357,8 @@ static VALUE ruby_curl_easy_initialize(int argc, VALUE *argv, VALUE self) {
 
   rb_easy_set("url", url);
 
-  /* set the new_curl pointer to the curl handle */
+
+  /* set the pointer to the curl handle */
   ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)self);
   if (ecode != CURLE_OK) {
     raise_curl_easy_error_exception(ecode);
@@ -373,6 +388,7 @@ static VALUE ruby_curl_easy_clone(VALUE self) {
   memcpy(newrbce, rbce, sizeof(ruby_curl_easy));
   newrbce->curl = curl_easy_duphandle(rbce->curl);
   newrbce->curl_headers = NULL;
+  newrbce->curl_proxy_headers = NULL;
   newrbce->curl_ftp_commands = NULL;
   newrbce->curl_resolve = NULL;
 
@@ -457,6 +473,12 @@ static VALUE ruby_curl_easy_reset(VALUE self) {
     rbce->curl_headers = NULL;
   }
 
+  /* Free everything up */
+  if (rbce->curl_proxy_headers) {
+    curl_slist_free_all(rbce->curl_proxy_headers);
+    rbce->curl_proxy_headers = NULL;
+  }
+
   return opts_dup;
 }
 
@@ -509,6 +531,10 @@ static VALUE ruby_curl_easy_headers_set(VALUE self, VALUE headers) {
   CURB_OBJECT_HSETTER(ruby_curl_easy, headers);
 }
 
+static VALUE ruby_curl_easy_proxy_headers_set(VALUE self, VALUE proxy_headers) {
+  CURB_OBJECT_HSETTER(ruby_curl_easy, proxy_headers);
+}
+
 /*
  * call-seq:
  *   easy.headers                                     => Hash, Array or Str
@@ -524,6 +550,41 @@ static VALUE ruby_curl_easy_headers_get(VALUE self) {
   return headers;
 }
 
+/*
+ * call-seq:
+ *   easy.proxy_headers = "Header: val"                              => "Header: val"
+ *   easy.proxy_headers = {"Header" => "val" ..., "Header" => "val"} => {"Header: val", ...}
+ *   easy.proxy_headers = ["Header: val" ..., "Header: val"]         => ["Header: val", ...]
+ *
+ *
+ * For example to set a standard or custom header:
+ *
+ *    easy.proxy_headers["MyHeader"] = "myval"
+ *
+ * To remove a standard header (this is useful when removing libcurls default
+ * 'Expect: 100-Continue' header when using HTTP form posts):
+ *
+ *    easy.proxy_headers["Expect"] = ''
+ *
+ * Anything passed to libcurl as a header will be converted to a string during
+ * the perform step.
+ */
+
+/*
+ * call-seq:
+ *   easy.proxy_headers                                     => Hash, Array or Str
+ *
+ * Obtain the custom HTTP proxy_headers for following requests.
+ */
+static VALUE ruby_curl_easy_proxy_headers_get(VALUE self) {
+  ruby_curl_easy *rbce;
+  VALUE proxy_headers;
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  proxy_headers = rb_easy_get("proxy_headers");//rb_hash_aref(rbce->opts, rb_intern("proxy_headers"));
+  if (proxy_headers == Qnil) { proxy_headers = rb_easy_set("proxy_headers", rb_hash_new()); }
+  return proxy_headers;
+}
+
 /*
  * call-seq:
  *   easy.interface                                   => string
@@ -1139,7 +1200,7 @@ static VALUE ruby_curl_easy_max_redirects_get(VALUE self) {
 
 /*
  * call-seq:
- *   easy.timeout = fixnum or nil                     => fixnum or nil
+ *   easy.timeout = float, fixnum or nil              => numeric
  *
  * Set the maximum time in seconds that you allow the libcurl transfer
  * operation to take. Normally, name lookups can take a considerable time
@@ -1148,20 +1209,39 @@ static VALUE ruby_curl_easy_max_redirects_get(VALUE self) {
  *
  * Set to nil (or zero) to disable timeout (it will then only timeout
  * on the system's internal timeouts).
+ *
+ * Uses timeout_ms internally instead of timeout because it allows for
+ * better precision and libcurl will use the last set value when both
+ * timeout and timeout_ms are set.
+ *
  */
-static VALUE ruby_curl_easy_timeout_set(VALUE self, VALUE timeout) {
-  CURB_IMMED_SETTER(ruby_curl_easy, timeout, 0);
+static VALUE ruby_curl_easy_timeout_set(VALUE self, VALUE timeout_s) {
+  ruby_curl_easy *rbce;
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+
+  if (Qnil == timeout_s || NUM2DBL(timeout_s) <= 0.0) {
+    rbce->timeout_ms = 0;
+  } else {
+    rbce->timeout_ms = (unsigned long)(NUM2DBL(timeout_s) * 1000);
+  }
+
+  return DBL2NUM(rbce->timeout_ms / 1000.0);
 }
 
 /*
  * call-seq:
- *   easy.timeout                                     => fixnum or nil
+ *   easy.timeout                                     => numeric
  *
  * Obtain the maximum time in seconds that you allow the libcurl transfer
  * operation to take.
+ *
+ * Uses timeout_ms internally instead of timeout.
+ *
  */
-static VALUE ruby_curl_easy_timeout_get(VALUE self, VALUE timeout) {
-  CURB_IMMED_GETTER(ruby_curl_easy, timeout, 0);
+static VALUE ruby_curl_easy_timeout_get(VALUE self) {
+  ruby_curl_easy *rbce;
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  return DBL2NUM(rbce->timeout_ms / 1000.0);
 }
 
 /*
@@ -1177,7 +1257,16 @@ static VALUE ruby_curl_easy_timeout_get(VALUE self, VALUE timeout) {
  * on the system's internal timeouts).
  */
 static VALUE ruby_curl_easy_timeout_ms_set(VALUE self, VALUE timeout_ms) {
-  CURB_IMMED_SETTER(ruby_curl_easy, timeout_ms, 0);
+  ruby_curl_easy *rbce;
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+
+  if (Qnil == timeout_ms || NUM2DBL(timeout_ms) <= 0.0) {
+    rbce->timeout_ms = 0;
+  } else {
+    rbce->timeout_ms = NUM2ULONG(timeout_ms);
+  }
+
+  return ULONG2NUM(rbce->timeout_ms);
 }
 
 /*
@@ -1187,8 +1276,10 @@ static VALUE ruby_curl_easy_timeout_ms_set(VALUE self, VALUE timeout_ms) {
  * Obtain the maximum time in milliseconds that you allow the libcurl transfer
  * operation to take.
  */
-static VALUE ruby_curl_easy_timeout_ms_get(VALUE self, VALUE timeout_ms) {
-  CURB_IMMED_GETTER(ruby_curl_easy, timeout_ms, 0);
+static VALUE ruby_curl_easy_timeout_ms_get(VALUE self) {
+  ruby_curl_easy *rbce;
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  return LONG2NUM(rbce->timeout_ms);
 }
 
 /*
@@ -1338,6 +1429,46 @@ static VALUE ruby_curl_easy_low_speed_time_get(VALUE self, VALUE low_speed_time)
   CURB_IMMED_GETTER(ruby_curl_easy, low_speed_time, 0);
 }
 
+/*
+ * call-seq:
+ *   easy.max_send_speed_large = fixnum or nil        => fixnum or nil
+ *
+ * Set the maximal sending transfer speed (in bytes per second) 
+ */
+static VALUE ruby_curl_easy_max_send_speed_large_set(VALUE self, VALUE max_send_speed_large) {
+  CURB_IMMED_SETTER(ruby_curl_easy, max_send_speed_large, 0);
+}
+
+/*
+ * call-seq:
+ *   easy.max_send_speed_large = fixnum or nil        => fixnum or nil
+ *
+ * Get the maximal sending transfer speed (in bytes per second) 
+ */
+static VALUE ruby_curl_easy_max_send_speed_large_get(VALUE self, VALUE max_send_speed_large) {
+  CURB_IMMED_GETTER(ruby_curl_easy, max_send_speed_large, 0);
+}
+
+/*
+ * call-seq:
+ *   easy.max_recv_speed_large = fixnum or nil        => fixnum or nil
+ *
+ * Set the maximal receiving transfer speed (in bytes per second) 
+ */
+static VALUE ruby_curl_easy_max_recv_speed_large_set(VALUE self, VALUE max_recv_speed_large) {
+  CURB_IMMED_SETTER(ruby_curl_easy, max_recv_speed_large, 0);
+}
+
+/*
+ * call-seq:
+ *   easy.max_recv_speed_large = fixnum or nil        => fixnum or nil
+ *
+ * Get the maximal receiving transfer speed (in bytes per second) 
+ */
+static VALUE ruby_curl_easy_max_recv_speed_large_get(VALUE self, VALUE max_recv_speed_large) {
+  CURB_IMMED_GETTER(ruby_curl_easy, max_recv_speed_large, 0);
+}
+
 /*
  * call-seq:
  *   easy.username = string                           => string
@@ -2012,6 +2143,38 @@ static VALUE cb_each_http_header(VALUE header, VALUE wrap) {
   return header_str;
 }
 
+/***********************************************
+ * This is an rb_iterate callback used to set up http proxy headers.
+ */
+static VALUE cb_each_http_proxy_header(VALUE proxy_header, VALUE wrap) {
+  struct curl_slist **list;
+  VALUE proxy_header_str = Qnil;
+
+  Data_Get_Struct(wrap, struct curl_slist *, list);
+
+  //rb_p(proxy_header);
+
+  if (rb_type(proxy_header) == T_ARRAY) {
+    // we're processing a hash, proxy header is [name, val]
+    VALUE name, value;
+
+    name = rb_obj_as_string(rb_ary_entry(proxy_header, 0));
+    value = rb_obj_as_string(rb_ary_entry(proxy_header, 1));
+
+    // This is a bit inefficient, but we don't want to be modifying
+    // the actual values in the original hash.
+    proxy_header_str = rb_str_plus(name, rb_str_new2(": "));
+    proxy_header_str = rb_str_plus(proxy_header_str, value);
+  } else {
+    proxy_header_str = rb_obj_as_string(proxy_header);
+  }
+
+  //rb_p(header_str);
+
+  *list = curl_slist_append(*list, StringValuePtr(proxy_header_str));
+  return proxy_header_str;
+}
+
 /***********************************************
  * This is an rb_iterate callback used to set up ftp commands.
  */
@@ -2051,6 +2214,7 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
   CURL *curl;
   VALUE url, _url = rb_easy_get("url");
   struct curl_slist **hdrs = &(rbce->curl_headers);
+  struct curl_slist **phdrs = &(rbce->curl_proxy_headers);
   struct curl_slist **cmds = &(rbce->curl_ftp_commands);
   struct curl_slist **rslv = &(rbce->curl_resolve);
 
@@ -2061,7 +2225,6 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
   }
 
   url = rb_check_string_type(_url);
-
   curl_easy_setopt(curl, CURLOPT_URL, StringValuePtr(url));
 
   // network stuff and auth
@@ -2174,15 +2337,14 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
 
   curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, rbce->unrestricted_auth);
 
-  /* timeouts override each other we cannot blindly set timeout and timeout_ms */
-  if (rbce->timeout && rbce->timeout > 0) {
-    curl_easy_setopt(curl, CURLOPT_TIMEOUT, rbce->timeout);
-  }
-  if (rbce->timeout_ms && rbce->timeout_ms > 0) {
-    curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, rbce->timeout_ms);
-  }
+#if HAVE_CURLOPT_TIMEOUT_MS
+  curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, rbce->timeout_ms);
+#endif
+
   curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, rbce->connect_timeout);
+#if HAVE_CURLOPT_CONNECTTIMEOUT_MS
   curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT_MS, rbce->connect_timeout_ms);
+#endif
   curl_easy_setopt(curl, CURLOPT_DNS_CACHE_TIMEOUT, rbce->dns_cache_timeout);
 
   curl_easy_setopt(curl, CURLOPT_IGNORE_CONTENT_LENGTH, rbce->ignore_content_length);
@@ -2201,6 +2363,9 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
   curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, rbce->low_speed_limit);
   curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, rbce->low_speed_time);
 
+  curl_easy_setopt(curl, CURLOPT_MAX_RECV_SPEED_LARGE, rbce->max_recv_speed_large);
+  curl_easy_setopt(curl, CURLOPT_MAX_SEND_SPEED_LARGE, rbce->max_send_speed_large);
+
   // Set up localport / proxy port
   // FIXME these won't get returned to default if they're unset Ruby
   if (rbce->proxy_port > 0) {
@@ -2334,6 +2499,25 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
     }
   }
 
+#if HAVE_CURLOPT_PROXYHEADER
+  /* Setup HTTP proxy headers if necessary */
+  curl_easy_setopt(curl, CURLOPT_PROXYHEADER, NULL);   // XXX: maybe we shouldn't be clearing this?
+
+  if (!rb_easy_nil("proxy_headers")) {
+    if (rb_easy_type_check("proxy_headers", T_ARRAY) || rb_easy_type_check("proxy_headers", T_HASH)) {
+      VALUE wrap = Data_Wrap_Struct(rb_cObject, 0, 0, phdrs);
+      rb_iterate(rb_each, rb_easy_get("proxy_headers"), cb_each_http_proxy_header, wrap);
+    } else {
+      VALUE proxy_headers_str = rb_obj_as_string(rb_easy_get("proxy_headers"));
+      *phdrs = curl_slist_append(*hdrs, StringValuePtr(proxy_headers_str));
+    }
+
+    if (*phdrs) {
+      curl_easy_setopt(curl, CURLOPT_PROXYHEADER, *phdrs);
+    }
+  }
+#endif
+
   /* Setup FTP commands if necessary */
   if (!rb_easy_nil("ftp_commands")) {
     if (rb_easy_type_check("ftp_commands", T_ARRAY)) {
@@ -2346,6 +2530,7 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
     }
   }
 
+#if HAVE_CURLOPT_RESOLVE
   /* Setup resolve list if necessary */
   if (!rb_easy_nil("resolve")) {
     if (rb_easy_type_check("resolve", T_ARRAY)) {
@@ -2357,6 +2542,7 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
       curl_easy_setopt(curl, CURLOPT_RESOLVE, *rslv);
     }
   }
+#endif
 
   return Qnil;
 }
@@ -2364,7 +2550,7 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
  *
  * Clean up a connection
  *
- * Always returns Qtrue.
+ * Always returns Qnil.
  */
 VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce ) {
 
@@ -2378,6 +2564,11 @@ VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce ) {
     rbce->curl_headers = NULL;
   }
 
+  if (rbce->curl_proxy_headers) {
+    curl_slist_free_all(rbce->curl_proxy_headers);
+    rbce->curl_proxy_headers = NULL;
+  }
+
   ftp_commands = rbce->curl_ftp_commands;
   if (ftp_commands) {
     curl_slist_free_all(ftp_commands);
@@ -2399,6 +2590,9 @@ VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce ) {
     curl_easy_setopt(curl, CURLOPT_INFILESIZE, 0);
   }
 
+  // set values on cleanup to nil
+  rb_easy_del("multi");
+
   return Qnil;
 }
 
@@ -3263,6 +3457,7 @@ static VALUE ruby_curl_easy_last_result(VALUE self) {
 static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
   ruby_curl_easy *rbce;
   long option = NUM2LONG(opt);
+  rb_io_t *open_f_ptr;
 
   Data_Get_Struct(self, ruby_curl_easy, rbce);
 
@@ -3383,6 +3578,34 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
     curl_easy_setopt(rbce->curl, CURLOPT_MAX_RECV_SPEED_LARGE, (curl_off_t) NUM2LL(val));
     } break;
 #endif
+#if HAVE_CURLOPT_MAXFILESIZE
+  case CURLOPT_MAXFILESIZE:
+    curl_easy_setopt(rbce->curl, CURLOPT_MAXFILESIZE, NUM2LONG(val));
+    break;
+#endif
+#if HAVE_CURLOPT_TCP_KEEPALIVE
+  case CURLOPT_TCP_KEEPALIVE:
+    curl_easy_setopt(rbce->curl, CURLOPT_TCP_KEEPALIVE, NUM2LONG(val));
+    break;
+  case CURLOPT_TCP_KEEPIDLE:
+    curl_easy_setopt(rbce->curl, CURLOPT_TCP_KEEPIDLE, NUM2LONG(val));
+    break;
+  case CURLOPT_TCP_KEEPINTVL:
+    curl_easy_setopt(rbce->curl, CURLOPT_TCP_KEEPINTVL, NUM2LONG(val));
+    break;
+#endif
+#if HAVE_CURLOPT_HAPROXYPROTOCOL
+  case CURLOPT_HAPROXYPROTOCOL:
+    curl_easy_setopt(rbce->curl, CURLOPT_HAPROXYPROTOCOL, NUM2LONG(val));
+    break;
+#endif
+  case CURLOPT_STDERR:
+    // libcurl requires raw FILE pointer and this should be IO object in Ruby.
+    // Tempfile or StringIO won't work.
+    Check_Type(val, T_FILE);
+    GetOpenFile(val, open_f_ptr);
+    curl_easy_setopt(rbce->curl, CURLOPT_STDERR, rb_io_stdio_file(open_f_ptr));
+    break;
   default:
     rb_raise(rb_eTypeError, "Curb unsupported option");
   }
@@ -3518,6 +3741,10 @@ void init_curb_easy() {
   /* Attributes for config next perform */
   rb_define_method(cCurlEasy, "url", ruby_curl_easy_url_get, 0);
   rb_define_method(cCurlEasy, "proxy_url", ruby_curl_easy_proxy_url_get, 0);
+
+  rb_define_method(cCurlEasy, "proxy_headers=", ruby_curl_easy_proxy_headers_set, 1);
+  rb_define_method(cCurlEasy, "proxy_headers", ruby_curl_easy_proxy_headers_get, 0);
+
   rb_define_method(cCurlEasy, "headers=", ruby_curl_easy_headers_set, 1);
   rb_define_method(cCurlEasy, "headers", ruby_curl_easy_headers_get, 0);
   rb_define_method(cCurlEasy, "interface", ruby_curl_easy_interface_get, 0);
@@ -3577,6 +3804,10 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "low_speed_limit", ruby_curl_easy_low_speed_limit_get, 0);
   rb_define_method(cCurlEasy, "low_speed_time=", ruby_curl_easy_low_speed_time_set, 1);
   rb_define_method(cCurlEasy, "low_speed_time", ruby_curl_easy_low_speed_time_get, 0);
+  rb_define_method(cCurlEasy, "max_send_speed_large=", ruby_curl_easy_max_send_speed_large_set, 1);
+  rb_define_method(cCurlEasy, "max_send_speed_large", ruby_curl_easy_max_send_speed_large_get, 0);
+  rb_define_method(cCurlEasy, "max_recv_speed_large=", ruby_curl_easy_max_recv_speed_large_set, 1);
+  rb_define_method(cCurlEasy, "max_recv_speed_large", ruby_curl_easy_max_recv_speed_large_get, 0);
   rb_define_method(cCurlEasy, "ssl_version=", ruby_curl_easy_ssl_version_set, 1);
   rb_define_method(cCurlEasy, "ssl_version", ruby_curl_easy_ssl_version_get, 0);
   rb_define_method(cCurlEasy, "use_ssl=", ruby_curl_easy_use_ssl_set, 1);