curb 0.9.2 → 0.9.11

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;
   }
 }
 
@@ -244,7 +269,9 @@ 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;
 
   /* various-typed opts */
   rbce->local_port = 0;
@@ -262,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;
@@ -283,25 +312,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...>
  *
- * 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,8 +350,6 @@ 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;
 
@@ -318,17 +357,18 @@ static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
 
   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;
 }
 
 /*
@@ -348,7 +388,9 @@ 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;
 
   return Data_Wrap_Struct(cCurlEasy, curl_easy_mark, curl_easy_free, newrbce);
 }
@@ -358,7 +400,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) {
@@ -431,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;
 }
 
@@ -483,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
@@ -493,11 +545,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 +792,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 +827,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 +856,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 +888,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 +902,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();
   }
 
@@ -870,6 +957,25 @@ 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 +1086,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 +1118,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 +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
@@ -1103,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);
 }
 
 /*
@@ -1132,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);
 }
 
 /*
@@ -1142,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);
 }
 
 /*
@@ -1293,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
@@ -1310,7 +1486,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 +1514,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) {
@@ -1381,7 +1557,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.
  */
@@ -1838,7 +2014,7 @@ static VALUE ruby_curl_easy_on_failure_set(int argc, VALUE *argv, VALUE self) {
  *  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) {
@@ -1853,7 +2029,7 @@ static VALUE ruby_curl_easy_on_missing_set(int argc, VALUE *argv, VALUE self) {
  *  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) {
@@ -1967,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.
  */
@@ -1981,6 +2189,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 +2214,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 +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
@@ -2114,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);
@@ -2141,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) {
@@ -2247,7 +2472,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 +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)) {
@@ -2286,18 +2530,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 +2564,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 +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;
 }
 
@@ -2564,7 +2837,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);
 
@@ -2789,7 +3062,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 +3345,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.
@@ -3156,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);
 
@@ -3193,6 +3495,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);
@@ -3260,6 +3568,44 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
 	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;
   default:
     rb_raise(rb_eTypeError, "Curb unsupported option");
   }
@@ -3386,12 +3732,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 +3771,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 +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);
@@ -3536,6 +3895,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);