curb 0.9.3 → 1.0.2

data/ext/curb_easy.c

@@ -25,12 +25,18 @@ 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 ==============*/
 
 static VALUE callback_exception(VALUE unused) {
   return Qfalse;
-} 
+}
 
 /* These handle both body and header data */
 static size_t default_data_handler(char *stream,
@@ -223,12 +229,31 @@ 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);
   }
 
+  if (rbce->curl_resolve) {
+    curl_slist_free_all(rbce->curl_resolve);
+  }
+
   if (rbce->curl) {
+    /* disable any progress or debug events */
+    curl_easy_setopt(rbce->curl, CURLOPT_WRITEFUNCTION, NULL);
+    curl_easy_setopt(rbce->curl, CURLOPT_WRITEDATA, NULL);
+    curl_easy_setopt(rbce->curl, CURLOPT_HEADERFUNCTION, NULL);
+    curl_easy_setopt(rbce->curl, CURLOPT_HEADERDATA, NULL);
+    curl_easy_setopt(rbce->curl, CURLOPT_DEBUGFUNCTION, NULL);
+    curl_easy_setopt(rbce->curl, CURLOPT_DEBUGDATA, NULL);
+    curl_easy_setopt(rbce->curl, CURLOPT_VERBOSE, 0);
+    curl_easy_setopt(rbce->curl, CURLOPT_PROGRESSFUNCTION, NULL);
+    curl_easy_setopt(rbce->curl, CURLOPT_NOPROGRESS, 1);
     curl_easy_cleanup(rbce->curl);
+    rbce->curl = NULL;
   }
 }
 
@@ -243,8 +268,12 @@ void curl_easy_free(ruby_curl_easy *rbce) {
 static void ruby_curl_easy_zero(ruby_curl_easy *rbce) {
   rbce->opts = rb_hash_new();
 
+  memset(rbce->err_buf, 0, sizeof(rbce->err_buf));
+
   rbce->curl_headers = NULL;
+  rbce->curl_proxy_headers = NULL;
   rbce->curl_ftp_commands = NULL;
+  rbce->curl_resolve = NULL;
 
   /* various-typed opts */
   rbce->local_port = 0;
@@ -262,6 +291,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;
@@ -283,25 +314,37 @@ static void ruby_curl_easy_zero(ruby_curl_easy *rbce) {
   rbce->callback_active = 0;
 }
 
+/*
+ * Allocate space for a Curl::Easy instance.
+ */
+static VALUE ruby_curl_easy_allocate(VALUE klass) {
+  ruby_curl_easy *rbce;
+  rbce = ALLOC(ruby_curl_easy);
+  rbce->curl = NULL;
+  rbce->opts  = Qnil;
+  rbce->multi = Qnil;
+  ruby_curl_easy_zero(rbce);
+  return Data_Wrap_Struct(klass, curl_easy_mark, curl_easy_free, rbce);
+}
+
 /*
  * call-seq:
- *   Curl::Easy.new                                   => #<Curl::Easy...>
- *   Curl::Easy.new(url = nil)                        => #<Curl::Easy...>
- *   Curl::Easy.new(url = nil) { |self| ... }         => #<Curl::Easy...>
+ *   Curl::Easy.new                                   => #<Curl::Easy...>
+ *   Curl::Easy.new(url = nil)                        => #<Curl::Easy...>
+ *   Curl::Easy.new(url = nil) { |self| ... }         => #<Curl::Easy...>
  *
- * Create a new Curl::Easy instance, optionally supplying the URL.
+ * Initialize a new Curl::Easy instance, optionally supplying the URL.
  * The block form allows further configuration to be supplied before
  * the instance is returned.
  */
-static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
+static VALUE ruby_curl_easy_initialize(int argc, VALUE *argv, VALUE self) {
   CURLcode ecode;
   VALUE url, blk;
-  VALUE new_curl;
   ruby_curl_easy *rbce;
 
   rb_scan_args(argc, argv, "01&", &url, &blk);
 
-  rbce = ALLOC(ruby_curl_easy);
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
 
   /* handler */
   rbce->curl = curl_easy_init();
@@ -309,32 +352,32 @@ static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
     rb_raise(eCurlErrFailedInit, "Failed to initialize easy handle");
   }
 
-  new_curl = Data_Wrap_Struct(klass, curl_easy_mark, curl_easy_free, rbce);
-
   rbce->multi = Qnil;
   rbce->opts  = Qnil;
 
   ruby_curl_easy_zero(rbce);
 
+  curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, &rbce->err_buf);
+
   rb_easy_set("url", url);
 
-  /* set the new_curl pointer to the curl handle */
-  ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)new_curl);
+  /* 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);
   }
 
   if (blk != Qnil) {
-    rb_funcall(blk, idCall, 1, new_curl);
+    rb_funcall(blk, idCall, 1, self);
   }
 
-  return new_curl;
+  return self;
 }
 
 /*
  * call-seq:
- *   easy.clone                                       => #&lt;easy clone&gt;
- *   easy.dup                                         => #&lt;easy clone&gt;
+ *   easy.clone                                       => <easy clone>
+ *   easy.dup                                         => <easy clone>
  *
  * Clone this Curl::Easy instance, creating a new instance.
  * This method duplicates the underlying CURL* handle.
@@ -348,7 +391,11 @@ 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;
+
+  curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, &rbce->err_buf);
 
   return Data_Wrap_Struct(cCurlEasy, curl_easy_mark, curl_easy_free, newrbce);
 }
@@ -358,7 +405,7 @@ static VALUE ruby_curl_easy_clone(VALUE self) {
  *   easy.close                                      => nil
  *
  * Close the Curl::Easy instance. Any open connections are closed
- * The easy handle is reinitialized.  If a previous multi handle was 
+ * The easy handle is reinitialized.  If a previous multi handle was
  * open it is set to nil and will be cleared after a GC.
  */
 static VALUE ruby_curl_easy_close(VALUE self) {
@@ -419,7 +466,9 @@ static VALUE ruby_curl_easy_reset(VALUE self) {
   curl_easy_reset(rbce->curl);
   ruby_curl_easy_zero(rbce);
 
-  /* rest clobbers the private setting, so reset it to self */
+  curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, &rbce->err_buf);
+
+  /* reset clobbers the private setting, so reset it to self */
   ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)self);
   if (ecode != CURLE_OK) {
     raise_curl_easy_error_exception(ecode);
@@ -431,6 +480,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;
 }
 
@@ -483,6 +538,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
@@ -493,11 +552,46 @@ static VALUE ruby_curl_easy_headers_get(VALUE self) {
   ruby_curl_easy *rbce;
   VALUE headers;
   Data_Get_Struct(self, ruby_curl_easy, rbce);
-  headers = rb_easy_get("headers");//rb_hash_aref(rbce->opts, rb_intern("headers")); 
+  headers = rb_easy_get("headers");//rb_hash_aref(rbce->opts, rb_intern("headers"));
   if (headers == Qnil) { headers = rb_easy_set("headers", rb_hash_new()); }
   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
@@ -705,29 +799,29 @@ static VALUE ruby_curl_easy_useragent_get(VALUE self) {
 /*
  * call-seq:
  *   easy.post_body = "some=form%20data&to=send"      => string or nil
- * 
+ *
  * Sets the POST body of this Curl::Easy instance.  This is expected to be
  * URL encoded; no additional processing or encoding is done on the string.
  * The content-type header will be set to application/x-www-form-urlencoded.
- * 
+ *
  * This is handy if you want to perform a POST against a Curl::Multi instance.
  */
 static VALUE ruby_curl_easy_post_body_set(VALUE self, VALUE post_body) {
   ruby_curl_easy *rbce;
   CURL *curl;
-  
+
   char *data;
   long len;
 
   Data_Get_Struct(self, ruby_curl_easy, rbce);
-  
+
   curl = rbce->curl;
-  
+
   if ( post_body == Qnil ) {
     rb_easy_del("postdata_buffer");
     curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);
-    
-  } else {  
+
+  } else {
     if (rb_type(post_body) == T_STRING) {
       data = StringValuePtr(post_body);
       len = RSTRING_LEN(post_body);
@@ -740,19 +834,19 @@ static VALUE ruby_curl_easy_post_body_set(VALUE self, VALUE post_body) {
     else {
       rb_raise(rb_eRuntimeError, "post data must respond_to .to_s");
     }
-  
-    // Store the string, since it has to hang around for the duration of the 
+
+    // Store the string, since it has to hang around for the duration of the
     // request.  See CURLOPT_POSTFIELDS in the libcurl docs.
     //rbce->postdata_buffer = post_body;
     rb_easy_set("postdata_buffer", post_body);
-  
+
     curl_easy_setopt(curl, CURLOPT_POST, 1);
     curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
     curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, len);
-    
+
     return post_body;
   }
-  
+
   return Qnil;
 }
 
@@ -769,7 +863,7 @@ static VALUE ruby_curl_easy_post_body_get(VALUE self) {
 /*
  * call-seq:
  *   easy.put_data = data                             => ""
- * 
+ *
  * Points this Curl::Easy instance to data to be uploaded via PUT.  This
  * sets the request to a PUT type request - useful if you want to PUT via
  * a multi handle.
@@ -801,7 +895,7 @@ static VALUE ruby_curl_easy_put_data_set(VALUE self, VALUE data) {
   curl_easy_setopt(curl, CURLOPT_SEEKDATA, rbce);
 #endif
 
-  /* 
+  /*
    * we need to set specific headers for the PUT to work... so
    * convert the internal headers structure to a HASH if one is set
    */
@@ -815,7 +909,7 @@ static VALUE ruby_curl_easy_put_data_set(VALUE self, VALUE data) {
   if (NIL_P(data)) { return data; }
 
   headers = rb_easy_get("headers");
-  if( headers == Qnil ) { 
+  if( headers == Qnil ) {
     headers = rb_hash_new();
   }
 
@@ -863,13 +957,32 @@ static VALUE ruby_curl_easy_ftp_commands_set(VALUE self, VALUE ftp_commands) {
 }
 
 /*
- * call-seq
+ * call-seq:
  *   easy.ftp_commands                                => array or nil
  */
 static VALUE ruby_curl_easy_ftp_commands_get(VALUE self) {
   CURB_OBJECT_HGETTER(ruby_curl_easy, ftp_commands);
 }
 
+/*
+ * call-seq:
+ *   easy.resolve = [ "example.com:80:127.0.0.1" ]   => [ "example.com:80:127.0.0.1" ]
+ *
+ * Set the resolve list to statically resolve hostnames to IP addresses,
+ * bypassing DNS for matching hostname/port combinations.
+ */
+static VALUE ruby_curl_easy_resolve_set(VALUE self, VALUE resolve) {
+  CURB_OBJECT_HSETTER(ruby_curl_easy, resolve);
+}
+
+/*
+ * call-seq:
+ *   easy.resolve                                => array or nil
+ */
+static VALUE ruby_curl_easy_resolve_get(VALUE self) {
+  CURB_OBJECT_HGETTER(ruby_curl_easy, resolve);
+}
+
 /* ================== IMMED ATTRS ==================*/
 
 /*
@@ -980,7 +1093,7 @@ static VALUE ruby_curl_easy_proxy_type_get(VALUE self) {
   (!strncmp("ntlm",node,4)) ? CURLAUTH_NTLM : \
   (!strncmp("anysafe",node,7)) ? CURLAUTH_ANYSAFE : \
   (!strncmp("any",node,3)) ? CURLAUTH_ANY : 0
-#else 
+#else
 #define CURL_HTTPAUTH_STR_TO_NUM(node) \
   (!strncmp("basic",node,5)) ? CURLAUTH_BASIC : \
   (!strncmp("digest",node,6)) ? CURLAUTH_DIGEST : \
@@ -1012,7 +1125,7 @@ static VALUE ruby_curl_easy_http_auth_types_set(int argc, VALUE *argv, VALUE sel
 
   if (len == 1 && (rb_ary_entry(args_ary,0) == Qnil || TYPE(rb_ary_entry(args_ary,0)) == T_FIXNUM ||
         TYPE(rb_ary_entry(args_ary,0)) == T_BIGNUM)) {
-    if (rb_ary_entry(args_ary,0) == Qnil) { 
+    if (rb_ary_entry(args_ary,0) == Qnil) {
       rbce->http_auth_types = 0;
     }
     else {
@@ -1094,7 +1207,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
@@ -1103,20 +1216,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);
 }
 
 /*
@@ -1132,7 +1264,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);
 }
 
 /*
@@ -1142,8 +1283,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);
 }
 
 /*
@@ -1293,6 +1436,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
@@ -1310,7 +1493,7 @@ static VALUE ruby_curl_easy_username_set(VALUE self, VALUE username) {
 /*
  * call-seq:
  *   easy.username                                    => string
- * 
+ *
  * Get the current username
  */
 static VALUE ruby_curl_easy_username_get(VALUE self, VALUE username) {
@@ -1338,7 +1521,7 @@ static VALUE ruby_curl_easy_password_set(VALUE self, VALUE password) {
 /*
  * call-seq:
  *   easy.password                                    => string
- * 
+ *
  * Get the current password
  */
 static VALUE ruby_curl_easy_password_get(VALUE self, VALUE password) {
@@ -1363,6 +1546,7 @@ static VALUE ruby_curl_easy_password_get(VALUE self, VALUE password) {
  *   Curl::CURL_SSLVERSION_TLSv1_0
  *   Curl::CURL_SSLVERSION_TLSv1_1
  *   Curl::CURL_SSLVERSION_TLSv1_2
+ *   Curl::CURL_SSLVERSION_TLSv1_3
  */
 static VALUE ruby_curl_easy_ssl_version_set(VALUE self, VALUE ssl_version) {
   CURB_IMMED_SETTER(ruby_curl_easy, ssl_version, -1);
@@ -1381,7 +1565,7 @@ static VALUE ruby_curl_easy_ssl_version_get(VALUE self, VALUE ssl_version) {
 /*
  * call-seq:
  *   easy.use_ssl = value                             => fixnum or nil
- * 
+ *
  * Ensure libcurl uses SSL for FTP connections. Valid options are Curl::CURL_USESSL_NONE,
  * Curl::CURL_USESSL_TRY, Curl::CURL_USESSL_CONTROL, and Curl::CURL_USESSL_ALL.
  */
@@ -1411,7 +1595,7 @@ static VALUE ruby_curl_easy_ftp_filemethod_set(VALUE self, VALUE ftp_filemethod)
 }
 
 /*
- * call-seq
+ * call-seq:
  *   easy.ftp_filemethod                              => fixnum
  *
  * Get the configuration for how libcurl will reach files on the server.
@@ -1783,7 +1967,7 @@ static VALUE ruby_curl_easy_resolve_mode_set(VALUE self, VALUE resolve_mode) {
 
 /*
  * call-seq:
- *   easy.on_body { |body_data| ... }                 => &lt;old handler&gt;
+ *   easy.on_body { |body_data| ... }                 => <old handler>
  *
  * Assign or remove the +on_body+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1802,7 +1986,7 @@ static VALUE ruby_curl_easy_on_body_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_success { |easy| ... }                   => &lt;old handler&gt;
+ *   easy.on_success { |easy| ... }                   => <old handler>
  *
  * Assign or remove the +on_success+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1817,7 +2001,7 @@ static VALUE ruby_curl_easy_on_success_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_failure {|easy,code| ... }               => &lt;old handler&gt;
+ *   easy.on_failure {|easy,code| ... }               => <old handler>
  *
  * Assign or remove the +on_failure+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1832,13 +2016,13 @@ static VALUE ruby_curl_easy_on_failure_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *  easy.on_missing {|easy,code| ... }                => &lt;old handler;&gt;
+ *  easy.on_missing {|easy,code| ... }                => <old handler;>
  *
  *  Assign or remove the on_missing handler for this Curl::Easy instance.
  *  To remove a previously-supplied handler, call this method with no attached
  *  block.
  *
- *  The +on_missing+ handler is called when request is finished with a 
+ *  The +on_missing+ handler is called when request is finished with a
  *  status of 40x
  */
 static VALUE ruby_curl_easy_on_missing_set(int argc, VALUE *argv, VALUE self) {
@@ -1847,13 +2031,13 @@ static VALUE ruby_curl_easy_on_missing_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *  easy.on_redirect {|easy,code| ... }                => &lt;old handler;&gt;
+ *  easy.on_redirect {|easy,code| ... }                => <old handler;>
  *
  *  Assign or remove the on_redirect handler for this Curl::Easy instance.
  *  To remove a previously-supplied handler, call this method with no attached
  *  block.
  *
- *  The +on_redirect+ handler is called when request is finished with a 
+ *  The +on_redirect+ handler is called when request is finished with a
  *  status of 30x
  */
 static VALUE ruby_curl_easy_on_redirect_set(int argc, VALUE *argv, VALUE self) {
@@ -1862,7 +2046,7 @@ static VALUE ruby_curl_easy_on_redirect_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_complete {|easy| ... }                   => &lt;old handler&gt;
+ *   easy.on_complete {|easy| ... }                   => <old handler>
  *
  * Assign or remove the +on_complete+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1876,7 +2060,7 @@ static VALUE ruby_curl_easy_on_complete_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_header { |header_data| ... }             => &lt;old handler&gt;
+ *   easy.on_header { |header_data| ... }             => <old handler>
  *
  * Assign or remove the +on_header+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1892,7 +2076,7 @@ static VALUE ruby_curl_easy_on_header_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_progress { |dl_total, dl_now, ul_total, ul_now| ... } => &lt;old handler&gt;
+ *   easy.on_progress { |dl_total, dl_now, ul_total, ul_now| ... } => <old handler>
  *
  * Assign or remove the +on_progress+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1913,7 +2097,7 @@ static VALUE ruby_curl_easy_on_progress_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_debug { |type, data| ... }               => &lt;old handler&gt;
+ *   easy.on_debug { |type, data| ... }               => <old handler>
  *
  * Assign or remove the +on_debug+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1952,11 +2136,14 @@ static VALUE cb_each_http_header(VALUE header, VALUE wrap) {
 
     name = rb_obj_as_string(rb_ary_entry(header, 0));
     value = rb_obj_as_string(rb_ary_entry(header, 1));
-
-    // This is a bit inefficient, but we don't want to be modifying
-    // the actual values in the original hash.
-    header_str = rb_str_plus(name, rb_str_new2(": "));
-    header_str = rb_str_plus(header_str, value);
+    if (rb_str_strlen(value) == 0) { // removing the header e.g. Accept: with nothing trailing should remove it see: https://curl.se/libcurl/c/CURLOPT_HTTPHEADER.html
+      header_str = rb_str_plus(name, rb_str_new2(":"));
+    } else {
+      // This is a bit inefficient, but we don't want to be modifying
+      // the actual values in the original hash.
+      header_str = rb_str_plus(name, rb_str_new2(": "));
+      header_str = rb_str_plus(header_str, value);
+    }
   } else {
     header_str = rb_obj_as_string(header);
   }
@@ -1967,6 +2154,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.
  */
@@ -1981,6 +2200,20 @@ static VALUE cb_each_ftp_command(VALUE ftp_command, VALUE wrap) {
   return ftp_command_string;
 }
 
+/***********************************************
+ * This is an rb_iterate callback used to set up the resolve list.
+ */
+static VALUE cb_each_resolve(VALUE resolve, VALUE wrap) {
+  struct curl_slist **list;
+  VALUE resolve_string;
+  Data_Get_Struct(wrap, struct curl_slist *, list);
+
+  resolve_string = rb_obj_as_string(resolve);
+  *list = curl_slist_append(*list, StringValuePtr(resolve));
+
+  return resolve_string;
+}
+
 /***********************************************
  *
  * Setup a connection
@@ -1992,7 +2225,9 @@ 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);
 
   curl = rbce->curl;
 
@@ -2001,7 +2236,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
@@ -2114,15 +2348,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);
@@ -2141,6 +2374,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) {
@@ -2247,7 +2483,7 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
     rb_warn("libcurl is not configured with SSL support");
   }
 #endif
-  
+
   if (rbce->ftp_filemethod > 0) {
     curl_easy_setopt(curl, CURLOPT_FTP_FILEMETHOD, rbce->ftp_filemethod);
   }
@@ -2274,6 +2510,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)) {
@@ -2286,18 +2541,33 @@ 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)) {
+      VALUE wrap = Data_Wrap_Struct(rb_cObject, 0, 0, rslv);
+      rb_iterate(rb_each, rb_easy_get("resolve"), cb_each_resolve, wrap);
+    }
+
+    if (*rslv) {
+      curl_easy_setopt(curl, CURLOPT_RESOLVE, *rslv);
+    }
+  }
+#endif
+
   return Qnil;
 }
 /***********************************************
  *
  * Clean up a connection
  *
- * Always returns Qtrue.
+ * Always returns Qnil.
  */
 VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce ) {
 
   CURL *curl = rbce->curl;
   struct curl_slist *ftp_commands;
+  struct curl_slist *resolve;
 
   /* Free everything up */
   if (rbce->curl_headers) {
@@ -2305,12 +2575,23 @@ 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);
     rbce->curl_ftp_commands = NULL;
   }
 
+  resolve = rbce->curl_resolve;
+  if (resolve) {
+    curl_slist_free_all(resolve);
+    rbce->curl_resolve = NULL;
+  }
+
   /* clean up a PUT request's curl options. */
   if (!rb_easy_nil("upload")) {
     rb_easy_del("upload"); // set the upload object to Qnil to let the GC clean up
@@ -2320,6 +2601,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;
 }
 
@@ -2334,6 +2618,8 @@ static VALUE ruby_curl_easy_perform_verb_str(VALUE self, const char *verb) {
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl = rbce->curl;
 
+  memset(rbce->err_buf, 0, sizeof(rbce->err_buf));
+
   curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, verb);
 
   retval = rb_funcall(self, rb_intern("perform"), 0);
@@ -2399,6 +2685,8 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl = rbce->curl;
 
+  memset(rbce->err_buf, 0, sizeof(rbce->err_buf));
+
   curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, NULL);
 
   if (rbce->multipart_form_post) {
@@ -2470,6 +2758,8 @@ static VALUE ruby_curl_easy_perform_put(VALUE self, VALUE data) {
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl = rbce->curl;
 
+  memset(rbce->err_buf, 0, sizeof(rbce->err_buf));
+
   curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, NULL);
   ruby_curl_easy_put_data_set(self, data);
 
@@ -2488,6 +2778,10 @@ static VALUE ruby_curl_easy_perform_put(VALUE self, VALUE data) {
  * your own body handler, this string will be empty.
  */
 static VALUE ruby_curl_easy_body_str_get(VALUE self) {
+  /*
+     TODO: can we force_encoding on the return here if we see charset=utf-8 in the content-type header?
+     Content-Type: application/json; charset=utf-8
+  */
   CURB_OBJECT_HGETTER(ruby_curl_easy, body_data);
 }
 
@@ -2564,7 +2858,7 @@ static VALUE ruby_curl_easy_response_code_get(VALUE self) {
 static VALUE ruby_curl_easy_primary_ip_get(VALUE self) {
   ruby_curl_easy *rbce;
   char* ip;
-  
+
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_PRIMARY_IP, &ip);
 
@@ -2682,7 +2976,7 @@ static VALUE ruby_curl_easy_connect_time_get(VALUE self) {
  * Retrieve the time, in seconds, it took from the start until the SSL/SSH
  * connect/handshake to the remote host was completed. This time is most often
  * very near to the pre transfer time, except for cases such as HTTP
- * pippelining where the pretransfer time can be delayed due to waits in line
+ * pipelining where the pretransfer time can be delayed due to waits in line
  * for the pipeline and more.
  */
 #if defined(HAVE_CURLINFO_APPCONNECT_TIME)
@@ -2789,7 +3083,7 @@ static VALUE ruby_curl_easy_redirect_count_get(VALUE self) {
  * call-seq:
  *   easy.redirect_url                               => "http://some.url" or nil
  *
- * Retrieve  the URL a redirect would take you to if you 
+ * Retrieve  the URL a redirect would take you to if you
  * would enable CURLOPT_FOLLOWLOCATION.
  *
  * Requires libcurl 7.18.2 or higher, otherwise -1 is always returned.
@@ -3072,12 +3366,40 @@ static VALUE ruby_curl_easy_num_connects_get(VALUE self) {
 }
 
 
-/* TODO this needs to be implemented.
+/*
+ * call-seq:
+ *   easy.cookielist                                => array
+ *
+ * Retrieves the cookies curl knows in an array of strings.
+ * Returned strings are in Netscape cookiejar format or in Set-Cookie format.
+ *
+ * See also option CURLINFO_COOKIELIST of curl_easy_getopt(3) to see how libcurl behaves.
+ *
+ * (requires libcurl 7.14.1 or higher, otherwise -1 is always returned).
+*/
+static VALUE ruby_curl_easy_cookielist_get(VALUE self) {
+#ifdef HAVE_CURLINFO_COOKIELIST
+  ruby_curl_easy *rbce;
+  struct curl_slist *cookies;
+  struct curl_slist *cookie;
+  VALUE rb_cookies;
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  curl_easy_getinfo(rbce->curl, CURLINFO_COOKIELIST, &cookies);
+  if (!cookies)
+    return Qnil;
+  rb_cookies = rb_ary_new();
+  for (cookie = cookies; cookie; cookie = cookie->next)
+    rb_ary_push(rb_cookies, rb_str_new2(cookie->data));
+  curl_slist_free_all(cookies);
+  return rb_cookies;
 
-CURLINFO_COOKIELIST
+#else
+    rb_warn("Installed libcurl is too old to support cookielist");
+    return INT2FIX(-1);
+#endif
+}
 
-Pass a pointer to a 'struct curl_slist *' to receive a linked-list of all cookies cURL knows (expired ones, too). Don't forget to curl_slist_free_all(3) the list after it has been used. If there are no cookies (cookies for the handle have not been enabled or simply none have been received) 'struct curl_slist *' will be set to point to NULL. (Added in 7.14.1)
-*/
 
 /* TODO this needs to be implemented. Could probably support CONNECT_ONLY by having this
  *      return an open Socket or something.
@@ -3147,6 +3469,21 @@ static VALUE ruby_curl_easy_last_result(VALUE self) {
   return LONG2NUM(rbce->last_result);
 }
 
+/*
+ * call-seq:
+ *   easy.last_error                                     => "Error details" or nil
+ */
+static VALUE ruby_curl_easy_last_error(VALUE self) {
+  ruby_curl_easy *rbce;
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+
+  if (rbce->err_buf[0]) {    // curl returns NULL or empty string if none
+    return rb_str_new2(rbce->err_buf);
+  } else {
+    return Qnil;
+  }
+}
+
 /*
  * call-seq:
  *   easy.setopt Fixnum, value  => value
@@ -3156,6 +3493,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);
 
@@ -3193,6 +3531,12 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
   case CURLOPT_HEADER:
   case CURLOPT_NOPROGRESS:
   case CURLOPT_NOSIGNAL:
+#if HAVE_CURLOPT_PATH_AS_IS
+  case CURLOPT_PATH_AS_IS:
+#endif
+#if HAVE_CURLOPT_PIPEWAIT
+  case CURLOPT_PIPEWAIT:
+#endif
   case CURLOPT_HTTPGET:
   case CURLOPT_NOBODY: {
     int type = rb_type(val);
@@ -3238,6 +3582,9 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
   case CURLOPT_TCP_NODELAY: {
     curl_easy_setopt(rbce->curl, CURLOPT_TCP_NODELAY, NUM2LONG(val));
     } break;
+  case CURLOPT_RANGE: {
+    curl_easy_setopt(rbce->curl, CURLOPT_RANGE, StringValueCStr(val));
+    } break;
   case CURLOPT_RESUME_FROM: {
     curl_easy_setopt(rbce->curl, CURLOPT_RESUME_FROM, NUM2LONG(val));
     } break;
@@ -3259,6 +3606,58 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
   case CURLOPT_UNIX_SOCKET_PATH: {
 	curl_easy_setopt(rbce->curl, CURLOPT_UNIX_SOCKET_PATH, StringValueCStr(val));
     } break;
+#endif
+#if HAVE_CURLOPT_MAX_SEND_SPEED_LARGE
+  case CURLOPT_MAX_SEND_SPEED_LARGE: {
+    curl_easy_setopt(rbce->curl, CURLOPT_MAX_SEND_SPEED_LARGE, (curl_off_t) NUM2LL(val));
+    } break;
+#endif
+#if HAVE_CURLOPT_MAX_RECV_SPEED_LARGE
+  case CURLOPT_MAX_RECV_SPEED_LARGE: {
+    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;
+  case CURLOPT_PROTOCOLS:
+  case CURLOPT_REDIR_PROTOCOLS:
+    curl_easy_setopt(rbce->curl, option, NUM2LONG(val));
+    break;
+#if HAVE_CURLOPT_SSL_SESSIONID_CACHE
+  case CURLOPT_SSL_SESSIONID_CACHE:
+    curl_easy_setopt(rbce->curl, CURLOPT_SSL_SESSIONID_CACHE, NUM2LONG(val));
+    break;
+#endif
+#if HAVE_CURLOPT_PROXY_SSL_VERIFYHOST
+  case CURLOPT_PROXY_SSL_VERIFYHOST:
+    curl_easy_setopt(rbce->curl, CURLOPT_PROXY_SSL_VERIFYHOST, NUM2LONG(val));
+    break;
 #endif
   default:
     rb_raise(rb_eTypeError, "Curb unsupported option");
@@ -3376,6 +3775,7 @@ static VALUE ruby_curl_easy_error_message(VALUE klass, VALUE code) {
 }
 
 /* =================== INIT LIB =====================*/
+// TODO: https://bugs.ruby-lang.org/issues/18007
 void init_curb_easy() {
   idCall = rb_intern("call");
   idJoin = rb_intern("join");
@@ -3386,12 +3786,19 @@ void init_curb_easy() {
   cCurlEasy = rb_define_class_under(mCurl, "Easy", rb_cObject);
 
   /* Class methods */
-  rb_define_singleton_method(cCurlEasy, "new", ruby_curl_easy_new, -1);
+  rb_define_alloc_func(cCurlEasy, ruby_curl_easy_allocate);
   rb_define_singleton_method(cCurlEasy, "error", ruby_curl_easy_error_message, 1);
 
+  /* Initialize method */
+  rb_define_method(cCurlEasy, "initialize", ruby_curl_easy_initialize, -1);
+
   /* 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);
@@ -3418,6 +3825,8 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "put_data=", ruby_curl_easy_put_data_set, 1);
   rb_define_method(cCurlEasy, "ftp_commands=", ruby_curl_easy_ftp_commands_set, 1);
   rb_define_method(cCurlEasy, "ftp_commands", ruby_curl_easy_ftp_commands_get, 0);
+  rb_define_method(cCurlEasy, "resolve=", ruby_curl_easy_resolve_set, 1);
+  rb_define_method(cCurlEasy, "resolve", ruby_curl_easy_resolve_get, 0);
 
   rb_define_method(cCurlEasy, "local_port=", ruby_curl_easy_local_port_set, 1);
   rb_define_method(cCurlEasy, "local_port", ruby_curl_easy_local_port_get, 0);
@@ -3449,6 +3858,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);
@@ -3536,6 +3949,7 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "content_type", ruby_curl_easy_content_type_get, 0);
   rb_define_method(cCurlEasy, "os_errno", ruby_curl_easy_os_errno_get, 0);
   rb_define_method(cCurlEasy, "num_connects", ruby_curl_easy_num_connects_get, 0);
+  rb_define_method(cCurlEasy, "cookielist", ruby_curl_easy_cookielist_get, 0);
   rb_define_method(cCurlEasy, "ftp_entry_path", ruby_curl_easy_ftp_entry_path_get, 0);
 
   rb_define_method(cCurlEasy, "close", ruby_curl_easy_close, 0);
@@ -3553,6 +3967,7 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "multi", ruby_curl_easy_multi_get, 0);
   rb_define_method(cCurlEasy, "multi=", ruby_curl_easy_multi_set, 1);
   rb_define_method(cCurlEasy, "last_result", ruby_curl_easy_last_result, 0);
+  rb_define_method(cCurlEasy, "last_error", ruby_curl_easy_last_error, 0);
 
   rb_define_method(cCurlEasy, "setopt", ruby_curl_easy_set_opt, 2);
   rb_define_method(cCurlEasy, "getinfo", ruby_curl_easy_get_opt, 1);