curb 0.6.5.0 → 0.8.4

data/ext/curb_easy.c

@@ -28,6 +28,10 @@ VALUE cCurlEasy;
 
 /* ================== 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,
                                    size_t size,
@@ -57,7 +61,7 @@ static size_t read_data_handler(void *ptr,
       return 0;
     }
   }
-  else {
+  else if (rb_respond_to(stream, rb_intern("to_s"))) {
     ruby_curl_upload *rbcu;
     VALUE str;
     size_t len;
@@ -68,6 +72,7 @@ static size_t read_data_handler(void *ptr,
     len = RSTRING_LEN(str);
     remaining = len - rbcu->offset;
     str_ptr = RSTRING_PTR(str);
+
     if( remaining < read_bytes ) {
       if( remaining > 0 ) {
         memcpy(ptr, str_ptr+rbcu->offset, remaining);
@@ -86,7 +91,9 @@ static size_t read_data_handler(void *ptr,
     }
     return read_bytes;
   }
-
+  else {
+    return 0;
+  }
 }
 
 static size_t proc_data_handler(char *stream,
@@ -108,114 +115,117 @@ static size_t proc_data_handler(char *stream,
   }
 }
 
+static size_t proc_data_handler_body(char *stream,
+                                     size_t size,
+                                     size_t nmemb,
+                                     ruby_curl_easy *rbce)
+{
+  size_t ret;
+  rbce->callback_active = 1;
+  ret = proc_data_handler(stream, size, nmemb, rb_easy_get("body_proc"));
+  rbce->callback_active = 0;
+  return ret;
+}
+static size_t proc_data_handler_header(char *stream,
+                                       size_t size,
+                                       size_t nmemb,
+                                       ruby_curl_easy *rbce)
+{
+  size_t ret;
+  rbce->callback_active = 1;
+  ret = proc_data_handler(stream, size, nmemb, rb_easy_get("header_proc"));
+  rbce->callback_active = 0;
+  return ret;
+}
+
+
+static VALUE call_progress_handler(VALUE ary) {
+  return rb_funcall(rb_ary_entry(ary, 0), idCall, 4,
+                    rb_ary_entry(ary, 1), // rb_float_new(dltotal),
+                    rb_ary_entry(ary, 2), // rb_float_new(dlnow),
+                    rb_ary_entry(ary, 3), // rb_float_new(ultotal),
+                    rb_ary_entry(ary, 4)); // rb_float_new(ulnow));
+}
+
 static int proc_progress_handler(VALUE proc,
                                  double dltotal,
                                  double dlnow,
                                  double ultotal,
                                  double ulnow) {
   VALUE procret;
+  VALUE callargs = rb_ary_new2(5);
+
+  rb_ary_store(callargs, 0, proc);
+  rb_ary_store(callargs, 1, rb_float_new(dltotal));
+  rb_ary_store(callargs, 2, rb_float_new(dlnow));
+  rb_ary_store(callargs, 3, rb_float_new(ultotal));
+  rb_ary_store(callargs, 4, rb_float_new(ulnow));
 
-  procret = rb_funcall(proc, idCall, 4, rb_float_new(dltotal),
-                                        rb_float_new(dlnow),
-                                        rb_float_new(ultotal),
-                                        rb_float_new(ulnow));
+	//v = rb_rescue(range_check, (VALUE)args, range_failed, 0);
+  //procret = rb_funcall(proc, idCall, 4, rb_float_new(dltotal),
+  //                                      rb_float_new(dlnow),
+  //                                      rb_float_new(ultotal),
+  //                                      rb_float_new(ulnow));
+  procret = rb_rescue(call_progress_handler, callargs, callback_exception, Qnil);
 
   return(((procret == Qfalse) || (procret == Qnil)) ? -1 : 0);
 }
 
+static VALUE call_debug_handler(VALUE ary) {
+  return rb_funcall(rb_ary_entry(ary, 0), idCall, 2,
+                    rb_ary_entry(ary, 1), // INT2FIX(type),
+                    rb_ary_entry(ary, 2)); // rb_str_new(data, data_len)
+}
 static int proc_debug_handler(CURL *curl,
                               curl_infotype type,
                               char *data,
                               size_t data_len,
                               VALUE proc) {
-  rb_funcall(proc, idCall, 2, INT2FIX(type), rb_str_new(data, data_len));
+  VALUE callargs = rb_ary_new2(3);
+  rb_ary_store(callargs, 0, proc);
+  rb_ary_store(callargs, 1, INT2FIX(type));
+  rb_ary_store(callargs, 2, rb_str_new(data, data_len));
+  rb_rescue(call_debug_handler, callargs, callback_exception, Qnil);
+  /* no way to indicate to libcurl that we should break out given an exception in the on_debug handler...
+   * this means exceptions will be swallowed
+   */
+  //rb_funcall(proc, idCall, 2, INT2FIX(type), rb_str_new(data, data_len));
   return 0;
 }
 
 /* ================== MARK/FREE FUNC ==================*/
 void curl_easy_mark(ruby_curl_easy *rbce) {
-#if 0
-  rb_gc_mark(rbce->url);
-  rb_gc_mark(rbce->proxy_url);
-  rb_gc_mark(rbce->body_proc);
-  rb_gc_mark(rbce->body_data);
-  rb_gc_mark(rbce->header_proc);
-  rb_gc_mark(rbce->header_data);
-  rb_gc_mark(rbce->progress_proc);
-  rb_gc_mark(rbce->debug_proc);
-  rb_gc_mark(rbce->interface_hm);
-  rb_gc_mark(rbce->userpwd);
-#if HAVE_CURLOPT_USERNAME
-  rb_gc_mark(rbce->username);
-#endif
-#if HAVE_CURLOPT_PASSWORD
-  rb_gc_mark(rbce->password);
-#endif
-  rb_gc_mark(rbce->proxypwd);
-  rb_gc_mark(rbce->headers);
-  rb_gc_mark(rbce->cookies);
-  rb_gc_mark(rbce->cookiefile);
-  rb_gc_mark(rbce->cookiejar);
-  rb_gc_mark(rbce->cert);
-  rb_gc_mark(rbce->cacert);
-  rb_gc_mark(rbce->certpassword);
-  rb_gc_mark(rbce->certtype);
-  rb_gc_mark(rbce->encoding);
-  rb_gc_mark(rbce->useragent);
-  rb_gc_mark(rbce->success_proc);
-  rb_gc_mark(rbce->failure_proc);
-  rb_gc_mark(rbce->complete_proc);
-
-  rb_gc_mark(rbce->postdata_buffer);
-  rb_gc_mark(rbce->bodybuf);
-  rb_gc_mark(rbce->headerbuf);
-
-  if( rbce->upload != Qnil ) {
-    rb_gc_mark(rbce->upload);
-  }
-#endif
-  rb_gc_mark(rbce->opts);
+  if (!NIL_P(rbce->opts)) { rb_gc_mark(rbce->opts); }
+  if (!NIL_P(rbce->multi)) { rb_gc_mark(rbce->multi); }
 }
 
-void curl_easy_free(ruby_curl_easy *rbce) {
+static void ruby_curl_easy_free(ruby_curl_easy *rbce) {
   if (rbce->curl_headers) {
     curl_slist_free_all(rbce->curl_headers);
   }
-  curl_easy_cleanup(rbce->curl);
-  free(rbce);
-}
-
 
-/* ================= ALLOC METHODS ====================*/
+  if (rbce->curl_ftp_commands) {
+    curl_slist_free_all(rbce->curl_ftp_commands);
+  }
 
-/*
- * call-seq:
- *   Curl::Easy.new                                   => #&lt;Curl::Easy...&gt;
- *   Curl::Easy.new(url = nil)                        => #&lt;Curl::Easy...&gt;
- *   Curl::Easy.new(url = nil) { |self| ... }         => #&lt;Curl::Easy...&gt;
- *
- * Create 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) {
-  CURLcode ecode;
-  VALUE url, blk;
-  VALUE new_curl;
-  ruby_curl_easy *rbce;
+  if (rbce->curl) {
+    curl_easy_cleanup(rbce->curl);
+  }
+}
 
-  rb_scan_args(argc, argv, "01&", &url, &blk);
+void curl_easy_free(ruby_curl_easy *rbce) {
+  ruby_curl_easy_free(rbce);
+  free(rbce);
+}
 
-  rbce = ALLOC(ruby_curl_easy);
 
-  /* handler */
-  rbce->curl = curl_easy_init();
+/* ================= ALLOC METHODS ====================*/
 
+static void ruby_curl_easy_zero(ruby_curl_easy *rbce) {
   rbce->opts = rb_hash_new();
 
-  rb_easy_set("url", url);
-
   rbce->curl_headers = NULL;
+  rbce->curl_ftp_commands = NULL;
 
   /* various-typed opts */
   rbce->local_port = 0;
@@ -229,12 +239,18 @@ static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
   rbce->connect_timeout = 0;
   rbce->dns_cache_timeout = 60;
   rbce->ftp_response_timeout = 0;
+  rbce->low_speed_limit = 0;
+  rbce->low_speed_time = 0;
+  rbce->ssl_version = -1;
+  rbce->use_ssl = -1;
+  rbce->ftp_filemethod = -1;
+  rbce->resolve_mode = CURL_IPRESOLVE_WHATEVER;
 
   /* bool opts */
   rbce->proxy_tunnel = 0;
   rbce->fetch_file_time = 0;
   rbce->ssl_verify_peer = 1;
-  rbce->ssl_verify_host = 1;
+  rbce->ssl_verify_host = 2;
   rbce->header_in_body = 0;
   rbce->use_netrc = 0;
   rbce->follow_location = 0;
@@ -242,9 +258,45 @@ static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
   rbce->verbose = 0;
   rbce->multipart_form_post = 0;
   rbce->enable_cookies = 0;
+  rbce->ignore_content_length = 0;
+  rbce->callback_active = 0;
+}
+
+/*
+ * call-seq:
+ *   Curl::Easy.new                                   => #&lt;Curl::Easy...&gt;
+ *   Curl::Easy.new(url = nil)                        => #&lt;Curl::Easy...&gt;
+ *   Curl::Easy.new(url = nil) { |self| ... }         => #&lt;Curl::Easy...&gt;
+ *
+ * Create 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) {
+  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);
+
+  /* handler */
+  rbce->curl = curl_easy_init();
+  if (!rbce->curl) {
+    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);
+
+  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);
   if (ecode != CURLE_OK) {
@@ -275,67 +327,108 @@ 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_ftp_commands = NULL;
 
   return Data_Wrap_Struct(cCurlEasy, curl_easy_mark, curl_easy_free, newrbce);
 }
 
-
-/* ================ OBJ ATTRIBUTES ==================*/
-
 /*
  * call-seq:
- *   easy.url = "http://some.url/"                    => "http://some.url/"
+ *   easy.close                                      => nil
  *
- * Set the URL for subsequent calls to +perform+. It is acceptable
- * (and even recommended) to reuse Curl::Easy instances by reassigning
- * the URL between calls to +perform+.
+ * Close the Curl::Easy instance. Any open connections are closed
+ * 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_url_set(VALUE self, VALUE url) {
-  CURB_OBJECT_HSETTER(ruby_curl_easy, url);
+static VALUE ruby_curl_easy_close(VALUE self) {
+  CURLcode ecode;
+  ruby_curl_easy *rbce;
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+
+  if (rbce->callback_active) {
+    rb_raise(rb_eRuntimeError, "Cannot close an active curl handle within a callback");
+  }
+
+  ruby_curl_easy_free(rbce);
+
+  /* reinit the handle */
+  rbce->curl = curl_easy_init();
+  if (!rbce->curl) {
+    rb_raise(eCurlErrFailedInit, "Failed to initialize easy handle");
+  }
+
+  rbce->multi = Qnil;
+
+  ruby_curl_easy_zero(rbce);
+
+  /* give the new curl handle a reference back to the ruby object */
+  ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)self);
+  if (ecode != CURLE_OK) {
+    raise_curl_easy_error_exception(ecode);
+  }
+
+  return Qnil;
 }
 
 /*
  * call-seq:
- *   easy.url                                         => "http://some.url/"
+ *   easy.reset                                      => Hash
  *
- * Obtain the URL that will be used by subsequent calls to +perform+.
+ * Reset the Curl::Easy instance, clears out all settings.
+ *
+ * from http://curl.haxx.se/libcurl/c/curl_easy_reset.html
+ * Re-initializes all options previously set on a specified CURL handle to the default values. This puts back the handle to the same state as it was in when it was just created with curl_easy_init(3).
+ * It does not change the following information kept in the handle: live connections, the Session ID cache, the DNS cache, the cookies and shares.
+ *
+ * The return value contains all settings stored.
  */
-static VALUE ruby_curl_easy_url_get(VALUE self) {
-  CURB_OBJECT_HGETTER(ruby_curl_easy, url);
+static VALUE ruby_curl_easy_reset(VALUE self) {
+  CURLcode ecode;
+  ruby_curl_easy *rbce;
+  VALUE opts_dup;
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+
+  if (rbce->callback_active) {
+    rb_raise(rb_eRuntimeError, "Cannot close an active curl handle within a callback");
+  }
+
+  opts_dup = rb_funcall(rbce->opts, rb_intern("dup"), 0);
+
+  curl_easy_reset(rbce->curl);
+  ruby_curl_easy_zero(rbce);
+
+  /* rest 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);
+  }
+
+  /* Free everything up */
+  if (rbce->curl_headers) {
+    curl_slist_free_all(rbce->curl_headers);
+    rbce->curl_headers = NULL;
+  }
+
+  return opts_dup;
 }
 
+
+/* ================ OBJ ATTRIBUTES ==================*/
+
 /*
  * call-seq:
- *   easy.proxy_url = "some.url"                      => "some.url"
- *
- * Set the URL of the HTTP proxy to use for subsequent calls to +perform+.
- * The URL should specify the the host name or dotted IP address. To specify
- * port number in this string, append :[port] to the end of the host name.
- * The proxy string may be prefixed with [protocol]:// since any such prefix
- * will be ignored. The proxy's port number may optionally be specified with
- * the separate option proxy_port .
- *
- * When you tell the library to use an HTTP proxy, libcurl will transparently
- * convert operations to HTTP even if you specify an FTP URL etc. This may have
- * an impact on what other features of the library you can use, such as
- * FTP specifics that don't work unless you tunnel through the HTTP proxy. Such
- * tunneling is activated with proxy_tunnel = true.
+ *   easy.url                                         => string
  *
- * libcurl respects the environment variables *http_proxy*, *ftp_proxy*,
- * *all_proxy* etc, if any of those is set. The proxy_url option does however
- * override any possibly set environment variables.
- *
- * Starting with libcurl 7.14.1, the proxy host string given in environment
- * variables can be specified the exact same way as the proxy can be set with
- * proxy_url, including protocol prefix (http://) and embedded user + password.
-  */
-static VALUE ruby_curl_easy_proxy_url_set(VALUE self, VALUE proxy_url) {
-  CURB_OBJECT_HSETTER(ruby_curl_easy, proxy_url);
+ * Obtain the URL that will be used by subsequent calls to +perform+.
+ */
+static VALUE ruby_curl_easy_url_get(VALUE self) {
+  CURB_OBJECT_HGETTER(ruby_curl_easy, url);
 }
 
 /*
  * call-seq:
- *   easy.proxy_url                                   => "some.url"
+ *   easy.proxy_url                                   => string
  *
  * Obtain the HTTP Proxy URL that will be used by subsequent calls to +perform+.
  */
@@ -345,8 +438,8 @@ static VALUE ruby_curl_easy_proxy_url_get(VALUE self) {
 
 /*
  * call-seq:
- *   easy.headers = "Header: val"                              => ["Header: val", ...]
- *   easy.headers = {"Header" => "val" ..., "Header" => "val"} => ["Header: val", ...]
+ *   easy.headers = "Header: val"                              => "Header: val"
+ *   easy.headers = {"Header" => "val" ..., "Header" => "val"} => {"Header: val", ...}
  *   easy.headers = ["Header: val" ..., "Header: val"]         => ["Header: val", ...]
  *
  * Set custom HTTP headers for following requests. This can be used to add
@@ -360,7 +453,7 @@ static VALUE ruby_curl_easy_proxy_url_get(VALUE self) {
  * To remove a standard header (this is useful when removing libcurls default
  * 'Expect: 100-Continue' header when using HTTP form posts):
  *
- *    easy.headers["Expect:"] = ''
+ *    easy.headers["Expect"] = ''
  *
  * Anything passed to libcurl as a header will be converted to a string during
  * the perform step.
@@ -371,7 +464,7 @@ static VALUE ruby_curl_easy_headers_set(VALUE self, VALUE headers) {
 
 /*
  * call-seq:
- *   easy.headers                                              => Hash, Array or Str
+ *   easy.headers                                     => Hash, Array or Str
  *
  * Obtain the custom HTTP headers for following requests.
  */
@@ -386,18 +479,7 @@ static VALUE ruby_curl_easy_headers_get(VALUE self) {
 
 /*
  * call-seq:
- *   easy.interface = "interface"                     => "interface"
- *
- * Set the interface name to use as the outgoing network interface.
- * The name can be an interface name, an IP address or a host name.
- */
-static VALUE ruby_curl_easy_interface_set(VALUE self, VALUE interface_hm) {
-  CURB_OBJECT_HSETTER(ruby_curl_easy, interface_hm);
-}
-
-/*
- * call-seq:
- *   easy.interface                                   => "interface"
+ *   easy.interface                                   => string
  *
  * Obtain the interface name that is used as the outgoing network interface.
  * The name can be an interface name, an IP address or a host name.
@@ -408,18 +490,7 @@ static VALUE ruby_curl_easy_interface_get(VALUE self) {
 
 /*
  * call-seq:
- *   easy.userpwd = "pwd string"                      => "pwd string"
- *
- * Set the username/password string to use for subsequent calls to +perform+.
- * The supplied string should have the form "username:password"
- */
-static VALUE ruby_curl_easy_userpwd_set(VALUE self, VALUE userpwd) {
-  CURB_OBJECT_HSETTER(ruby_curl_easy, userpwd);
-}
-
-/*
- * call-seq:
- *   easy.userpwd                                     => "pwd string"
+ *   easy.userpwd                                     => string
  *
  * Obtain the username/password string that will be used for subsequent
  * calls to +perform+.
@@ -430,19 +501,7 @@ static VALUE ruby_curl_easy_userpwd_get(VALUE self) {
 
 /*
  * call-seq:
- *   easy.proxypwd = "pwd string"                     => "pwd string"
- *
- * Set the username/password string to use for proxy connection during
- * subsequent calls to +perform+. The supplied string should have the
- * form "username:password"
- */
-static VALUE ruby_curl_easy_proxypwd_set(VALUE self, VALUE proxypwd) {
-  CURB_OBJECT_HSETTER(ruby_curl_easy, proxypwd);
-}
-
-/*
- * call-seq:
- *   easy.proxypwd                                    => "pwd string"
+ *   easy.proxypwd                                    => string
  *
  * Obtain the username/password string that will be used for proxy
  * connection during subsequent calls to +perform+. The supplied string
@@ -452,22 +511,9 @@ static VALUE ruby_curl_easy_proxypwd_get(VALUE self) {
   CURB_OBJECT_HGETTER(ruby_curl_easy, proxypwd);
 }
 
-
 /*
  * call-seq:
- *   easy.cookies = "name1=content1; name2=content2;"                => "pwd string"
- *
- * Set cookies to be sent by this Curl::Easy instance. The format of the string should
- * be NAME=CONTENTS, where NAME is the cookie name and CONTENTS is what the cookie should contain.
- * Set multiple cookies in one string like this: "name1=content1; name2=content2;" etc.
- */
-static VALUE ruby_curl_easy_cookies_set(VALUE self, VALUE cookies) {
-  CURB_OBJECT_HSETTER(ruby_curl_easy, cookies);
-}
-
-/*
- * call-seq:
- *   easy.cookies                                   => "name1=content1; name2=content2;"
+ *   easy.cookies                                     => "name1=content1; name2=content2;"
  *
  * Obtain the cookies for this Curl::Easy instance.
  */
@@ -477,20 +523,7 @@ static VALUE ruby_curl_easy_cookies_get(VALUE self) {
 
 /*
  * call-seq:
- *   easy.cookiefile = "cookies.txt"                => "pwd string"
- *
- * Set a file that contains cookies to be sent in subsequent requests by this Curl::Easy instance.
- *
- * *Note* that you must set enable_cookies true to enable the cookie
- * engine, or this option will be ignored.
- */
-static VALUE ruby_curl_easy_cookiefile_set(VALUE self, VALUE cookiefile) {
-  CURB_OBJECT_HSETTER(ruby_curl_easy, cookiefile);
-}
-
-/*
- * call-seq:
- *   easy.cookiefile                                   => "cookies.txt"
+ *   easy.cookiefile                                  => string
  *
  * Obtain the cookiefile file for this Curl::Easy instance.
  */
@@ -500,21 +533,7 @@ static VALUE ruby_curl_easy_cookiefile_get(VALUE self) {
 
 /*
  * call-seq:
- *   easy.cookiejar = "cookiejar.file"                => "pwd string"
- *
- * Set a cookiejar file to use for this Curl::Easy instance.
- * Cookies from the response will be written into this file.
- *
- * *Note* that you must set enable_cookies true to enable the cookie
- * engine, or this option will be ignored.
- */
-static VALUE ruby_curl_easy_cookiejar_set(VALUE self, VALUE cookiejar) {
-  CURB_OBJECT_HSETTER(ruby_curl_easy, cookiejar);
-}
-
-/*
- * call-seq:
- *   easy.cookiejar                                   => "cookiejar.file"
+ *   easy.cookiejar                                   => string
  *
  * Obtain the cookiejar file to use for this Curl::Easy instance.
  */
@@ -524,7 +543,7 @@ static VALUE ruby_curl_easy_cookiejar_get(VALUE self) {
 
 /*
  * call-seq:
- *   easy.cert = "cert.file"                          => ""
+ *   easy.cert = string                               => ""
  *
  * Set a cert file to use for this Curl::Easy instance. This file
  * will be used to validate SSL connections.
@@ -536,7 +555,7 @@ static VALUE ruby_curl_easy_cert_set(VALUE self, VALUE cert) {
 
 /*
  * call-seq:
- *   easy.cert                                        => "cert.file"
+ *   easy.cert                                        => string
  *
  * Obtain the cert file to use for this Curl::Easy instance.
  */
@@ -546,7 +565,29 @@ static VALUE ruby_curl_easy_cert_get(VALUE self) {
 
 /*
  * call-seq:
- *   easy.cacert = "cacert.file"                      => ""
+ *   easy.cert_key = "cert_key.file"                  => ""
+ *
+ * Set a cert key to use for this Curl::Easy instance. This file
+ * will be used to validate SSL certificates.
+ *
+ */
+static VALUE ruby_curl_easy_cert_key_set(VALUE self, VALUE cert_key) {
+  CURB_OBJECT_HSETTER(ruby_curl_easy, cert_key);
+}
+
+/*
+ * call-seq:
+ *   easy.cert_key                                    => "cert_key.file"
+ *
+ * Obtain the cert key file to use for this Curl::Easy instance.
+ */
+static VALUE ruby_curl_easy_cert_key_get(VALUE self) {
+  CURB_OBJECT_HGETTER(ruby_curl_easy, cert_key);
+}
+
+/*
+ * call-seq:
+ *   easy.cacert = string                             => ""
  *
  * Set a cacert bundle to use for this Curl::Easy instance. This file
  * will be used to validate SSL certificates.
@@ -558,7 +599,7 @@ static VALUE ruby_curl_easy_cacert_set(VALUE self, VALUE cacert) {
 
 /*
  * call-seq:
- *   easy.cacert                                      => "cacert.file"
+ *   easy.cacert                                      => string
  *
  * Obtain the cacert file to use for this Curl::Easy instance.
  */
@@ -568,7 +609,7 @@ static VALUE ruby_curl_easy_cacert_get(VALUE self) {
 
 /*
  * call-seq:
- *   easy.certpassword = "cert password"                   => ""
+ *   easy.certpassword = string                       => ""
  *
  * Set a password used to open the specified cert
  */
@@ -590,7 +631,7 @@ static VALUE ruby_curl_easy_certtype_set(VALUE self, VALUE certtype) {
 
 /*
  * call-seq:
- *   easy.certtype                                  => "cert.type"
+ *   easy.certtype                                    => string
  *
  * Obtain the cert type used for this Curl::Easy instance
  */
@@ -600,7 +641,7 @@ static VALUE ruby_curl_easy_certtype_get(VALUE self) {
 
 /*
  * call-seq:
- *   easy.encoding=                                     => "string"
+ *   easy.encoding = string                           => string
  *
  * Set the accepted encoding types, curl will handle all of the decompression
  *
@@ -610,7 +651,7 @@ static VALUE ruby_curl_easy_encoding_set(VALUE self, VALUE encoding) {
 }
 /*
  * call-seq:
- *   easy.encoding                                     => "string"
+ *   easy.encoding                                    => string
  *
  * Get the set encoding types
  *
@@ -621,7 +662,7 @@ static VALUE ruby_curl_easy_encoding_get(VALUE self) {
 
 /*
  * call-seq:
- *   easy.useragent = "Ruby/Curb"                      => ""
+ *   easy.useragent = "Ruby/Curb"                     => ""
  *
  * Set the user agent string for this Curl::Easy instance
  *
@@ -642,7 +683,7 @@ static VALUE ruby_curl_easy_useragent_get(VALUE self) {
 
 /*
  * call-seq:
- *   easy.post_body = "some=form%20data&to=send" => string or nil
+ *   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.
@@ -662,12 +703,22 @@ static VALUE ruby_curl_easy_post_body_set(VALUE self, VALUE post_body) {
   curl = rbce->curl;
   
   if ( post_body == Qnil ) {
-    //rbce->postdata_buffer = Qnil;
     rb_easy_del("postdata_buffer");
+    curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);
     
   } else {  
-    data = StringValuePtr(post_body);
-    len = RSTRING_LEN(post_body);
+    if (rb_type(post_body) == T_STRING) {
+      data = StringValuePtr(post_body);
+      len = RSTRING_LEN(post_body);
+    }
+    else if (rb_respond_to(post_body, rb_intern("to_s"))) {
+      VALUE str_body = rb_funcall(post_body, rb_intern("to_s"), 0);
+      data = StringValuePtr(str_body);
+      len = RSTRING_LEN(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 
     // request.  See CURLOPT_POSTFIELDS in the libcurl docs.
@@ -686,7 +737,7 @@ static VALUE ruby_curl_easy_post_body_set(VALUE self, VALUE post_body) {
 
 /*
  * call-seq:
- *   easy.post_body                                  => "string" or nil
+ *   easy.post_body                                  => string or nil
  *
  * Obtain the POST body used in this Curl::Easy instance.
  */
@@ -706,6 +757,7 @@ static VALUE ruby_curl_easy_put_data_set(VALUE self, VALUE data) {
   ruby_curl_easy *rbce;
   CURL *curl;
   VALUE upload;
+  VALUE headers;
 
   Data_Get_Struct(self, ruby_curl_easy, rbce);
 
@@ -717,7 +769,7 @@ static VALUE ruby_curl_easy_put_data_set(VALUE self, VALUE data) {
                                     the easy handle is active or until the upload
                                     is complete or terminated... */
 
-  curl_easy_setopt(curl, CURLOPT_NOBODY,0);
+  curl_easy_setopt(curl, CURLOPT_NOBODY, 0);
   curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
   curl_easy_setopt(curl, CURLOPT_READFUNCTION, (curl_read_callback)read_data_handler);
   curl_easy_setopt(curl, CURLOPT_READDATA, rbce);
@@ -732,23 +784,31 @@ static VALUE ruby_curl_easy_put_data_set(VALUE self, VALUE data) {
     }
   }
 
-  VALUE headers = rb_easy_get("headers");
+  // exit fast if the payload is empty
+  if (NIL_P(data)) { return data; }
+
+  headers = rb_easy_get("headers");
   if( headers == Qnil ) { 
     headers = rb_hash_new();
   }
+
   if (rb_respond_to(data, rb_intern("read"))) {
     VALUE stat = rb_funcall(data, rb_intern("stat"), 0);
-    if( stat ) {
+    if( stat && rb_hash_aref(headers, rb_str_new2("Content-Length")) == Qnil) {
       VALUE size;
       if( rb_hash_aref(headers, rb_str_new2("Expect")) == Qnil ) {
         rb_hash_aset(headers, rb_str_new2("Expect"), rb_str_new2(""));
       }
       size = rb_funcall(stat, rb_intern("size"), 0);
-      curl_easy_setopt(curl, CURLOPT_INFILESIZE, FIX2INT(size));
+      curl_easy_setopt(curl, CURLOPT_INFILESIZE, FIX2LONG(size));
     }
-    else if( rb_hash_aref(headers, rb_str_new2("Transfer-Encoding")) == Qnil ) {
+    else if( rb_hash_aref(headers, rb_str_new2("Content-Length")) == Qnil && rb_hash_aref(headers, rb_str_new2("Transfer-Encoding")) == Qnil ) {
       rb_hash_aset(headers, rb_str_new2("Transfer-Encoding"), rb_str_new2("chunked"));
     }
+    else if( rb_hash_aref(headers, rb_str_new2("Content-Length")) ) {
+      VALUE size = rb_funcall(rb_hash_aref(headers, rb_str_new2("Content-Length")), rb_intern("to_i"), 0);
+      curl_easy_setopt(curl, CURLOPT_INFILESIZE, FIX2LONG(size));
+    }
   }
   else if (rb_respond_to(data, rb_intern("to_s"))) {
     curl_easy_setopt(curl, CURLOPT_INFILESIZE, RSTRING_LEN(data));
@@ -760,11 +820,29 @@ static VALUE ruby_curl_easy_put_data_set(VALUE self, VALUE data) {
     rb_raise(rb_eRuntimeError, "PUT data must respond to read or to_s");
   }
   rb_easy_set("headers",headers);
-  
+
   // if we made it this far, all should be well.
   return data;
 }
 
+/*
+ * call-seq:
+ *   easy.ftp_commands = ["CWD /", "MKD directory"]   => ["CWD /", ...]
+ *
+ * Explicitly sets the list of commands to execute on the FTP server when calling perform
+ */
+static VALUE ruby_curl_easy_ftp_commands_set(VALUE self, VALUE ftp_commands) {
+  CURB_OBJECT_HSETTER(ruby_curl_easy, ftp_commands);
+}
+
+/*
+ * 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);
+}
+
 /* ================== IMMED ATTRS ==================*/
 
 /*
@@ -896,12 +974,15 @@ static VALUE ruby_curl_easy_proxy_type_get(VALUE self) {
 static VALUE ruby_curl_easy_http_auth_types_set(int argc, VALUE *argv, VALUE self) {//VALUE self, VALUE http_auth_types) {
   ruby_curl_easy *rbce;
   VALUE args_ary;
-  rb_scan_args(argc, argv, "*", &args_ary);
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
-  int i, len = RARRAY_LEN(args_ary);
+  int i, len;
   char* node = NULL;
   long mask = 0x000000;
 
+  rb_scan_args(argc, argv, "*", &args_ary);
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+
+  len = (int)RARRAY_LEN(args_ary);
+
   if (len == 1 && (TYPE(rb_ary_entry(args_ary,0)) == T_FIXNUM || rb_ary_entry(args_ary,0) == Qnil)) {
     if (rb_ary_entry(args_ary,0) == Qnil) { 
       rbce->http_auth_types = 0;
@@ -1088,7 +1169,52 @@ static VALUE ruby_curl_easy_ftp_response_timeout_get(VALUE self, VALUE ftp_respo
 
 /*
  * call-seq:
- *   easy.username = "foo"  => String
+ *   easy.low_speed_limit = fixnum or nil        => fixnum or nil
+ *
+ * Set the transfer speed (in bytes per second) that the transfer should be
+ * below during +low_speed_time+ seconds for the library to consider it too
+ * slow and abort.
+ */
+static VALUE ruby_curl_easy_low_speed_limit_set(VALUE self, VALUE low_speed_limit) {
+  CURB_IMMED_SETTER(ruby_curl_easy, low_speed_limit, 0);
+}
+
+/*
+ * call-seq:
+ *   easy.low_speed_limit                        => fixnum or nil
+ *
+ * Obtain the minimum transfer speed over +low_speed+time+ below which the
+ * transfer will be aborted.
+ */
+static VALUE ruby_curl_easy_low_speed_limit_get(VALUE self, VALUE low_speed_limit) {
+  CURB_IMMED_GETTER(ruby_curl_easy, low_speed_limit, 0);
+}
+
+/*
+ * call-seq:
+ *   easy.low_speed_time = fixnum or nil        => fixnum or nil
+ *
+ * Set the time (in seconds) that the transfer should be below the
+ * +low_speed_limit+ for the library to consider it too slow and abort.
+ */
+static VALUE ruby_curl_easy_low_speed_time_set(VALUE self, VALUE low_speed_time) {
+  CURB_IMMED_SETTER(ruby_curl_easy, low_speed_time, 0);
+}
+
+/*
+ * call-seq:
+ *   easy.low_speed_time                        => fixnum or nil
+ *
+ * Obtain the time that the transfer should be below +low_speed_limit+ for
+ * the library to abort it.
+ */
+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.username = string                           => string
  *
  * Set the HTTP Authentication username.
  */
@@ -1102,7 +1228,7 @@ static VALUE ruby_curl_easy_username_set(VALUE self, VALUE username) {
 
 /*
  * call-seq:
- *   easy.username   => String
+ *   easy.username                                    => string
  * 
  * Get the current username
  */
@@ -1116,7 +1242,7 @@ static VALUE ruby_curl_easy_username_get(VALUE self, VALUE username) {
 
 /*
  * call-seq:
- *   easy.password = "foo"  => String
+ *   easy.password = string                           => string
  *
  * Set the HTTP Authentication password.
  */
@@ -1130,7 +1256,7 @@ static VALUE ruby_curl_easy_password_set(VALUE self, VALUE password) {
 
 /*
  * call-seq:
- *   easy.password   => String
+ *   easy.password                                    => string
  * 
  * Get the current password
  */
@@ -1142,11 +1268,75 @@ static VALUE ruby_curl_easy_password_get(VALUE self, VALUE password) {
 #endif
 }
 
+/*
+ * call-seq:
+ *   easy.ssl_version = value                         => fixnum or nil
+ *
+ * Sets the version of SSL/TLS that libcurl will attempt to use. Valid
+ * options are Curl::CURL_SSLVERSION_TLSv1, Curl::CURL_SSLVERSION::SSLv2,
+ * Curl::CURL_SSLVERSION_SSLv3 and Curl::CURL_SSLVERSION_DEFAULT
+ */
+static VALUE ruby_curl_easy_ssl_version_set(VALUE self, VALUE ssl_version) {
+  CURB_IMMED_SETTER(ruby_curl_easy, ssl_version, -1);
+}
+
+/*
+ * call-seq:
+ *   easy.ssl_version                                 => fixnum
+ *
+ * Get the version of SSL/TLS that libcurl will attempt to use.
+ */
+static VALUE ruby_curl_easy_ssl_version_get(VALUE self, VALUE ssl_version) {
+  CURB_IMMED_GETTER(ruby_curl_easy, ssl_version, -1);
+}
+
+/*
+ * 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.
+ */
+static VALUE ruby_curl_easy_use_ssl_set(VALUE self, VALUE use_ssl) {
+  CURB_IMMED_SETTER(ruby_curl_easy, use_ssl, -1);
+}
+
+/*
+ * call-seq:
+ *   easy.use_ssl                                     => fixnum
+ *
+ * Get the desired level for using SSL on FTP connections.
+ */
+static VALUE ruby_curl_easy_use_ssl_get(VALUE self, VALUE use_ssl) {
+  CURB_IMMED_GETTER(ruby_curl_easy, use_ssl, -1);
+}
+
+/*
+ * call-seq:
+ *   easy.ftp_filemethod = value                      => fixnum or nil
+ *
+ * Controls how libcurl reaches files on the server. Valid options are Curl::CURL_MULTICWD,
+ * Curl::CURL_NOCWD, and Curl::CURL_SINGLECWD (see libcurl docs for CURLOPT_FTP_METHOD).
+ */
+static VALUE ruby_curl_easy_ftp_filemethod_set(VALUE self, VALUE ftp_filemethod) {
+  CURB_IMMED_SETTER(ruby_curl_easy, ftp_filemethod, -1);
+}
+
+/*
+ * call-seq
+ *   easy.ftp_filemethod                              => fixnum
+ *
+ * Get the configuration for how libcurl will reach files on the server.
+ */
+static VALUE ruby_curl_easy_ftp_filemethod_get(VALUE self, VALUE ftp_filemethod) {
+  CURB_IMMED_GETTER(ruby_curl_easy, ftp_filemethod, -1);
+}
+
 /* ================== BOOL ATTRS ===================*/
 
 /*
  * call-seq:
- *   proxy_tunnel = boolean                           => boolean
+ *   easy.proxy_tunnel = boolean                      => boolean
  *
  * Configure whether this Curl instance will use proxy tunneling.
  */
@@ -1156,7 +1346,7 @@ static VALUE ruby_curl_easy_proxy_tunnel_set(VALUE self, VALUE proxy_tunnel) {
 
 /*
  * call-seq:
- *   proxy_tunnel?                                    => boolean
+ *   easy.proxy_tunnel?                               => boolean
  *
  * Determine whether this Curl instance will use proxy tunneling.
  */
@@ -1166,7 +1356,7 @@ static VALUE ruby_curl_easy_proxy_tunnel_q(VALUE self) {
 
 /*
  * call-seq:
- *   fetch_file_time = boolean                        => boolean
+ *   easy.fetch_file_time = boolean                   => boolean
  *
  * Configure whether this Curl instance will fetch remote file
  * times, if available.
@@ -1177,7 +1367,7 @@ static VALUE ruby_curl_easy_fetch_file_time_set(VALUE self, VALUE fetch_file_tim
 
 /*
  * call-seq:
- *   fetch_file_time?                                 => boolean
+ *   easy.fetch_file_time?                            => boolean
  *
  * Determine whether this Curl instance will fetch remote file
  * times, if available.
@@ -1188,7 +1378,7 @@ static VALUE ruby_curl_easy_fetch_file_time_q(VALUE self) {
 
 /*
  * call-seq:
- *   ssl_verify_peer = boolean                        => boolean
+ *   easy.ssl_verify_peer = boolean                   => boolean
  *
  * Configure whether this Curl instance will verify the SSL peer
  * certificate. When true (the default), and the verification fails to
@@ -1206,7 +1396,7 @@ static VALUE ruby_curl_easy_ssl_verify_peer_set(VALUE self, VALUE ssl_verify_pee
 
 /*
  * call-seq:
- *   ssl_verify_peer?                                 => boolean
+ *   easy.ssl_verify_peer?                            => boolean
  *
  * Determine whether this Curl instance will verify the SSL peer
  * certificate.
@@ -1217,7 +1407,7 @@ static VALUE ruby_curl_easy_ssl_verify_peer_q(VALUE self) {
 
 /*
  * call-seq:
- *   ssl_verify_host = boolean                        => boolean
+ *   easy.ssl_verify_host = [0, 1, 2]                   => [0, 1, 2]
  *
  * Configure whether this Curl instance will verify that the server cert
  * is for the server it is known as. When true (the default) the server
@@ -1229,23 +1419,23 @@ static VALUE ruby_curl_easy_ssl_verify_peer_q(VALUE self) {
  * The server could be lying. To control lying, see ssl_verify_peer? .
  */
 static VALUE ruby_curl_easy_ssl_verify_host_set(VALUE self, VALUE ssl_verify_host) {
-  CURB_BOOLEAN_SETTER(ruby_curl_easy, ssl_verify_host);
+  CURB_IMMED_SETTER(ruby_curl_easy, ssl_verify_host, 0);
 }
 
 /*
  * call-seq:
- *   ssl_verify_host?                                 => boolean
+ *   easy.ssl_verify_host                            => number
  *
  * Determine whether this Curl instance will verify that the server cert
  * is for the server it is known as.
  */
-static VALUE ruby_curl_easy_ssl_verify_host_q(VALUE self) {
-  CURB_BOOLEAN_GETTER(ruby_curl_easy, ssl_verify_host);
+static VALUE ruby_curl_easy_ssl_verify_host_get(VALUE self) {
+  CURB_IMMED_GETTER(ruby_curl_easy, ssl_verify_host, 0);
 }
 
 /*
  * call-seq:
- *   header_in_body = boolean                         => boolean
+ *   easy.header_in_body = boolean                    => boolean
  *
  * Configure whether this Curl instance will return HTTP headers
  * combined with body data. If this option is set true, both header
@@ -1257,10 +1447,10 @@ static VALUE ruby_curl_easy_header_in_body_set(VALUE self, VALUE header_in_body)
 
 /*
  * call-seq:
- *   header_in_body?                                  => boolean
+ *   easy.header_in_body?                             => boolean
  *
- * Determine whether this Curl instance will verify the SSL peer
- * certificate.
+ * Determine whether this Curl instance will return HTTP headers
+ * combined with body data.
  */
 static VALUE ruby_curl_easy_header_in_body_q(VALUE self) {
   CURB_BOOLEAN_GETTER(ruby_curl_easy, header_in_body);
@@ -1268,7 +1458,7 @@ static VALUE ruby_curl_easy_header_in_body_q(VALUE self) {
 
 /*
  * call-seq:
- *   use_netrc = boolean                              => boolean
+ *   easy.use_netrc = boolean                         => boolean
  *
  * Configure whether this Curl instance will use data from the user's
  * .netrc file for FTP connections.
@@ -1279,7 +1469,7 @@ static VALUE ruby_curl_easy_use_netrc_set(VALUE self, VALUE use_netrc) {
 
 /*
  * call-seq:
- *   use_netrc?                                       => boolean
+ *   easy.use_netrc?                                  => boolean
  *
  * Determine whether this Curl instance will use data from the user's
  * .netrc file for FTP connections.
@@ -1290,19 +1480,27 @@ static VALUE ruby_curl_easy_use_netrc_q(VALUE self) {
 
 /*
  * call-seq:
- *   follow_location = boolean                        => boolean
  *
- * Configure whether this Curl instance will follow Location: headers
- * in HTTP responses. Redirects will only be followed to the extent
- * specified by +max_redirects+.
+ * easy = Curl::Easy.new
+ * easy.autoreferer=true
  */
-static VALUE ruby_curl_easy_follow_location_set(VALUE self, VALUE follow_location) {
-  CURB_BOOLEAN_SETTER(ruby_curl_easy, follow_location);
+static VALUE ruby_curl_easy_autoreferer_set(VALUE self, VALUE autoreferer) {
+  ruby_curl_easy *rbce;
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+
+  if (Qtrue == autoreferer) {
+    curl_easy_setopt(rbce->curl, CURLOPT_AUTOREFERER, 1);
+  }
+  else {
+    curl_easy_setopt(rbce->curl, CURLOPT_AUTOREFERER, 0);
+  }
+
+  return autoreferer;
 }
 
 /*
  * call-seq:
- *   follow_location?                                 => boolean
+ *   easy.follow_location?                            => boolean
  *
  * Determine whether this Curl instance will follow Location: headers
  * in HTTP responses.
@@ -1313,7 +1511,7 @@ static VALUE ruby_curl_easy_follow_location_q(VALUE self) {
 
 /*
  * call-seq:
- *   unrestricted_auth = boolean                      => boolean
+ *   easy.unrestricted_auth = boolean                 => boolean
  *
  * Configure whether this Curl instance may use any HTTP authentication
  * method available when necessary.
@@ -1324,7 +1522,7 @@ static VALUE ruby_curl_easy_unrestricted_auth_set(VALUE self, VALUE unrestricted
 
 /*
  * call-seq:
- *   unrestricted_auth?                               => boolean
+ *   easy.unrestricted_auth?                          => boolean
  *
  * Determine whether this Curl instance may use any HTTP authentication
  * method available when necessary.
@@ -1398,7 +1596,7 @@ static VALUE ruby_curl_easy_enable_cookies_set(VALUE self, VALUE enable_cookies)
 
 /*
  * call-seq:
- *   easy.enable_cookies?                        => boolean
+ *   easy.enable_cookies?                             => boolean
  *
  * Determine whether the libcurl cookie engine is enabled for this
  * Curl::Easy instance.
@@ -1407,6 +1605,90 @@ static VALUE ruby_curl_easy_enable_cookies_q(VALUE self) {
   CURB_BOOLEAN_GETTER(ruby_curl_easy, enable_cookies);
 }
 
+/*
+ * call-seq:
+ *   easy.ignore_content_length = boolean
+ *
+ * Configure whether this Curl::Easy instance should ignore the content
+ * length header.
+ */
+static VALUE ruby_curl_easy_ignore_content_length_set(VALUE self, VALUE ignore_content_length)
+{
+  CURB_BOOLEAN_SETTER(ruby_curl_easy, ignore_content_length);
+}
+
+/*
+ * call-seq:
+ *   easy.ignore_content_length?                             => boolean
+ *
+ * Determine whether this Curl::Easy instance ignores the content
+ * length header.
+ */
+static VALUE ruby_curl_easy_ignore_content_length_q(VALUE self) {
+  CURB_BOOLEAN_GETTER(ruby_curl_easy, ignore_content_length);
+}
+
+/*
+ * call-seq:
+ *   easy.resolve_mode                                      => symbol
+ *
+ * Determines what type of IP address this Curl::Easy instance
+ * resolves DNS names to.
+ */
+static VALUE ruby_curl_easy_resolve_mode(VALUE self) {
+  ruby_curl_easy *rbce;
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+
+  unsigned short rm = rbce->resolve_mode;
+
+  switch(rm) {
+    case CURL_IPRESOLVE_V4:
+      return rb_easy_sym("ipv4");
+    case CURL_IPRESOLVE_V6:
+      return rb_easy_sym("ipv6");
+    default:
+      return rb_easy_sym("auto");
+  }
+}
+
+/*
+ * call-seq:
+ *   easy.resolve_mode = symbol                             => symbol
+ *
+ * Configures what type of IP address this Curl::Easy instance
+ * resolves DNS names to. Valid options are:
+ *
+ * [:auto]  resolves DNS names to all IP versions your system allows
+ * [:ipv4]  resolves DNS names to IPv4 only
+ * [:ipv6]  resolves DNS names to IPv6 only
+ */
+static VALUE ruby_curl_easy_resolve_mode_set(VALUE self, VALUE resolve_mode) {
+  if (TYPE(resolve_mode) != T_SYMBOL) {
+    rb_raise(rb_eTypeError, "Must pass a symbol");
+    return Qnil;
+  } else {
+    ruby_curl_easy *rbce;
+    Data_Get_Struct(self, ruby_curl_easy, rbce);
+
+    ID resolve_mode_id = rb_to_id(resolve_mode);
+
+    if (resolve_mode_id == rb_intern("auto")) {
+      rbce->resolve_mode = CURL_IPRESOLVE_WHATEVER;
+      return resolve_mode;
+    } else if (resolve_mode_id == rb_intern("ipv4")) {
+      rbce->resolve_mode = CURL_IPRESOLVE_V4;
+      return resolve_mode;
+    } else if (resolve_mode_id == rb_intern("ipv6")) {
+      rbce->resolve_mode = CURL_IPRESOLVE_V6;
+      return resolve_mode;
+    } else {
+      rb_raise(rb_eArgError, "Must set to one of :auto, :ipv4, :ipv6");
+      return Qnil;
+    }
+  }
+}
+
+
 /* ================= EVENT PROCS ================== */
 
 /*
@@ -1430,7 +1712,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| ... }                   => &lt;old handler&gt;
  *
  * Assign or remove the +on_success+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1445,7 +1727,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| ... }               => &lt;old handler&gt;
  *
  * Assign or remove the +on_failure+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1460,7 +1742,37 @@ static VALUE ruby_curl_easy_on_failure_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_complete {|easy| ... }                 => &lt;old handler&gt;
+ *  easy.on_missing {|easy,code| ... }                => &lt;old handler;&gt;
+ *
+ *  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 
+ *  status of 40x
+ */
+static VALUE ruby_curl_easy_on_missing_set(int argc, VALUE *argv, VALUE self) {
+  CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, missing_proc);
+}
+
+/*
+ * call-seq:
+ *  easy.on_redirect {|easy,code| ... }                => &lt;old handler;&gt;
+ *
+ *  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 
+ *  status of 30x
+ */
+static VALUE ruby_curl_easy_on_redirect_set(int argc, VALUE *argv, VALUE self) {
+  CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, redirect_proc);
+}
+
+/*
+ * call-seq:
+ *   easy.on_complete {|easy| ... }                   => &lt;old handler&gt;
  *
  * Assign or remove the +on_complete+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1536,7 +1848,10 @@ static VALUE ruby_curl_easy_on_debug_set(int argc, VALUE *argv, VALUE self) {
 /***********************************************
  * This is an rb_iterate callback used to set up http headers.
  */
-static VALUE cb_each_http_header(VALUE header, struct curl_slist **list) {
+static VALUE cb_each_http_header(VALUE header, VALUE wrap) {
+  struct curl_slist **list;
+  Data_Get_Struct(wrap, struct curl_slist *, list);
+
   VALUE header_str = Qnil;
 
   //rb_p(header);
@@ -1562,16 +1877,31 @@ static VALUE cb_each_http_header(VALUE header, struct curl_slist **list) {
   return header_str;
 }
 
+/***********************************************
+ * This is an rb_iterate callback used to set up ftp commands.
+ */
+static VALUE cb_each_ftp_command(VALUE ftp_command, VALUE wrap) {
+  struct curl_slist **list;
+  Data_Get_Struct(wrap, struct curl_slist *, list);
+
+  VALUE ftp_command_string = rb_obj_as_string(ftp_command);
+  *list = curl_slist_append(*list, StringValuePtr(ftp_command));
+
+  return ftp_command_string;
+}
+
 /***********************************************
  *
  * Setup a connection
  *
  * Always returns Qtrue, rb_raise on error.
  */
-VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, struct curl_slist **hdrs ) {
+VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
   // TODO this could do with a bit of refactoring...
   CURL *curl;
   VALUE url, _url = rb_easy_get("url");
+  struct curl_slist **hdrs = &(rbce->curl_headers);
+  struct curl_slist **cmds = &(rbce->curl_ftp_commands);
 
   curl = rbce->curl;
 
@@ -1581,7 +1911,6 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, struct curl_slist **hdrs ) {
 
   url = rb_check_string_type(_url);
 
-  // Need to configure the handler as per settings in rbce
   curl_easy_setopt(curl, CURLOPT_URL, StringValuePtr(url));
 
   // network stuff and auth
@@ -1615,22 +1944,22 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, struct curl_slist **hdrs ) {
     curl_easy_setopt(curl, CURLOPT_USERPWD, NULL);
   }
 
-  if (!rb_easy_nil("proxy_url")) {
-    curl_easy_setopt(curl, CURLOPT_PROXY, rb_easy_get_str("proxy_url"));
-  } else {
+  if (rb_easy_nil("proxy_url")) {
     curl_easy_setopt(curl, CURLOPT_PROXY, NULL);
+  } else {
+    curl_easy_setopt(curl, CURLOPT_PROXY, rb_easy_get_str("proxy_url"));
   }
 
-  if (!rb_easy_nil("proxypwd")) {
-    curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, rb_easy_get_str("proxy_pwd"));
-  } else {
+  if (rb_easy_nil("proxypwd")) {
     curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, NULL);
+  } else {
+    curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, rb_easy_get_str("proxypwd"));
   }
 
   // body/header procs
   if (!rb_easy_nil("body_proc")) {
-    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)&proc_data_handler);
-    curl_easy_setopt(curl, CURLOPT_WRITEDATA, rb_easy_get("body_proc"));//rbce->body_proc);
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)&proc_data_handler_body);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, rbce);
     /* clear out the body_data if it was set */
     rb_easy_del("body_data");
   } else {
@@ -1640,8 +1969,8 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, struct curl_slist **hdrs ) {
   }
 
   if (!rb_easy_nil("header_proc")) {
-    curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, (curl_write_callback)&proc_data_handler);
-    curl_easy_setopt(curl, CURLOPT_HEADERDATA, rb_easy_get("header_proc"));
+    curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, (curl_write_callback)&proc_data_handler_header);
+    curl_easy_setopt(curl, CURLOPT_HEADERDATA, rbce);
     /* clear out the header_data if it was set */
     rb_easy_del("header_data");
   } else {
@@ -1678,19 +2007,18 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, struct curl_slist **hdrs ) {
   /* general opts */
 
   curl_easy_setopt(curl, CURLOPT_HEADER, rbce->header_in_body);
-
   curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, rbce->follow_location);
   curl_easy_setopt(curl, CURLOPT_MAXREDIRS, rbce->max_redirs);
 
   curl_easy_setopt(curl, CURLOPT_HTTPPROXYTUNNEL, rbce->proxy_tunnel);
   curl_easy_setopt(curl, CURLOPT_FILETIME, rbce->fetch_file_time);
   curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, rbce->ssl_verify_peer);
-  curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, rbce->ssl_verify_peer);
+  curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, rbce->ssl_verify_host);
 
   if ((rbce->use_netrc != Qnil) && (rbce->use_netrc != Qfalse)) {
-    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, CURL_NETRC_OPTIONAL);
+    curl_easy_setopt(curl, CURLOPT_NETRC, CURL_NETRC_OPTIONAL);
   } else {
-    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, CURL_NETRC_IGNORED);
+    curl_easy_setopt(curl, CURLOPT_NETRC, CURL_NETRC_IGNORED);
   }
 
   curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, rbce->unrestricted_auth);
@@ -1699,6 +2027,11 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, struct curl_slist **hdrs ) {
   curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, rbce->connect_timeout);
   curl_easy_setopt(curl, CURLOPT_DNS_CACHE_TIMEOUT, rbce->dns_cache_timeout);
 
+  curl_easy_setopt(curl, CURLOPT_IGNORE_CONTENT_LENGTH, rbce->ignore_content_length);
+
+  curl_easy_setopt(curl, CURLOPT_IPRESOLVE, rbce->resolve_mode);
+
+
 #if LIBCURL_VERSION_NUM >= 0x070a08
   curl_easy_setopt(curl, CURLOPT_FTP_RESPONSE_TIMEOUT, rbce->ftp_response_timeout);
 #else
@@ -1707,6 +2040,9 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, struct curl_slist **hdrs ) {
   }
 #endif
 
+  curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, rbce->low_speed_limit);
+  curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, rbce->low_speed_time);
+
   // Set up localport / proxy port
   // FIXME these won't get returned to default if they're unset Ruby
   if (rbce->proxy_port > 0) {
@@ -1780,20 +2116,45 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, struct curl_slist **hdrs ) {
 
   /* Set up HTTPS cert handling if necessary */
   if (!rb_easy_nil("cert")) {
-    curl_easy_setopt(curl, CURLOPT_SSLCERTTYPE, rb_easy_get_str("certtype"));
+    if (!rb_easy_nil("certtype")) {
+      curl_easy_setopt(curl, CURLOPT_SSLCERTTYPE, rb_easy_get_str("certtype"));
+    }
     curl_easy_setopt(curl, CURLOPT_SSLCERT, rb_easy_get_str("cert"));
     if (!rb_easy_nil("certpassword")) {
       curl_easy_setopt(curl, CURLOPT_SSLCERTPASSWD, rb_easy_get_str("certpassword"));
     }
+    if (!rb_easy_nil("cert_key")) {
+      curl_easy_setopt(curl, CURLOPT_SSLKEY, rb_easy_get_str("cert_key"));
+    }
   }
+
   if (!rb_easy_nil("cacert")) {
+    curl_easy_setopt(curl, CURLOPT_CAINFO, rb_easy_get_str("cacert"));
+  }
 #ifdef HAVE_CURL_CONFIG_CA
+  else {
     curl_easy_setopt(curl, CURLOPT_CAINFO, CURL_CONFIG_CA);
-#else
-    curl_easy_setopt(curl, CURLOPT_CAINFO, "/usr/local/share/curl/curl-ca-bundle.crt");
+  }
 #endif
+
+#ifdef CURL_VERSION_SSL
+  if (rbce->ssl_version > 0) {
+    curl_easy_setopt(curl, CURLOPT_SSLVERSION, rbce->ssl_version);
+  }
+
+  if (rbce->use_ssl > 0) {
+    curl_easy_setopt(curl, CURB_FTPSSL, rbce->use_ssl);
   }
+#else
+  if (rbce->ssl_version > 0 || rbce->use_ssl > 0) {
+    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);
+  }
+
   /* Set the user-agent string if specified */
   if (!rb_easy_nil("useragent")) {
     curl_easy_setopt(curl, CURLOPT_USERAGENT, rb_easy_get_str("useragent"));
@@ -1804,7 +2165,8 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, struct curl_slist **hdrs ) {
 
   if (!rb_easy_nil("headers")) {
     if (rb_easy_type_check("headers", T_ARRAY) || rb_easy_type_check("headers", T_HASH)) {
-      rb_iterate(rb_each, rb_easy_get("headers"), cb_each_http_header, (VALUE)hdrs);
+      VALUE wrap = Data_Wrap_Struct(rb_cObject, 0, 0, hdrs);
+      rb_iterate(rb_each, rb_easy_get("headers"), cb_each_http_header, wrap);
     } else {
       VALUE headers_str = rb_obj_as_string(rb_easy_get("headers"));
       *hdrs = curl_slist_append(*hdrs, StringValuePtr(headers_str));
@@ -1815,6 +2177,18 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, struct curl_slist **hdrs ) {
     }
   }
 
+  /* Setup FTP commands if necessary */
+  if (!rb_easy_nil("ftp_commands")) {
+    if (rb_easy_type_check("ftp_commands", T_ARRAY)) {
+      VALUE wrap = Data_Wrap_Struct(rb_cObject, 0, 0, cmds);
+      rb_iterate(rb_each, rb_easy_get("ftp_commands"), cb_each_ftp_command, wrap);
+    }
+
+    if (*cmds) {
+      curl_easy_setopt(curl, CURLOPT_QUOTE, *cmds);
+    }
+  }
+
   return Qnil;
 }
 /***********************************************
@@ -1823,17 +2197,24 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, struct curl_slist **hdrs ) {
  *
  * Always returns Qtrue.
  */
-VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce, struct curl_slist *headers ) {
+VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce ) {
 
   CURL *curl = rbce->curl;
-  
-  // Free everything up
-  if (headers) {
-    curl_slist_free_all(headers);
+  struct curl_slist *ftp_commands;
+
+  /* Free everything up */
+  if (rbce->curl_headers) {
+    curl_slist_free_all(rbce->curl_headers);
     rbce->curl_headers = NULL;
   }
 
-  // clean up a PUT request's curl options.
+  ftp_commands = rbce->curl_ftp_commands;
+  if (ftp_commands) {
+    curl_slist_free_all(ftp_commands);
+    rbce->curl_ftp_commands = 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
     curl_easy_setopt(curl, CURLOPT_UPLOAD, 0);
@@ -1845,61 +2226,10 @@ VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce, struct curl_slis
   return Qnil;
 }
 
-/***********************************************
- *
- * This is the main worker for the perform methods (get, post, head, put).
- * It's not surfaced as a Ruby method - instead, the individual request
- * methods are responsible for setting up stuff specific to that type,
- * then calling this to handle common stuff and do the perform.
- *
- * Always returns Qtrue, rb_raise on error.
- *
- */
-static VALUE handle_perform(VALUE self, ruby_curl_easy *rbce) {
-
-  VALUE ret;
-  VALUE multi = ruby_curl_multi_new(cCurlMulti);
-
-  rb_funcall(multi, rb_intern("add"), 1, self );
-  ret = rb_funcall(multi, rb_intern("perform"), 0);
-
-  /* check for errors in the easy response and raise exceptions if anything went wrong and their is no on_failure handler */
-  if (rbce->last_result != 0 && rb_easy_nil("failure_proc")) {
-    raise_curl_easy_error_exception(rbce->last_result);
-  }
-
-  return ret;
-}
-
-/*
- * call-seq:
- *   easy.http_get                                    => true
- *
- * GET the currently configured URL using the current options set for
- * this Curl::Easy instance. This method always returns true, or raises
- * an exception (defined under Curl::Err) on error.
- */
-static VALUE ruby_curl_easy_perform_get(VALUE self) {
-  ruby_curl_easy *rbce;
-  CURL *curl;
-
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
-  curl = rbce->curl;
-
-  curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);
-
-  return handle_perform(self,rbce);
-}
-
 /*
- * call-seq:
- *   easy.http_delete
- *
- * DELETE the currently configured URL using the current options set for
- * this Curl::Easy instance. This method always returns true, or raises
- * an exception (defined under Curl::Err) on error.
+ * Common implementation of easy.http(verb) and easy.http_delete
  */
-static VALUE ruby_curl_easy_perform_delete(VALUE self) {
+static VALUE ruby_curl_easy_perform_verb_str(VALUE self, const char *verb) {
   ruby_curl_easy *rbce;
   CURL *curl;
   VALUE retval;
@@ -1907,9 +2237,9 @@ static VALUE ruby_curl_easy_perform_delete(VALUE self) {
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl = rbce->curl;
 
-  curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
+  curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, verb);
 
-  retval = handle_perform(self,rbce);
+  retval = rb_funcall(self, rb_intern("perform"), 0);
 
   curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, NULL);
 
@@ -1918,18 +2248,23 @@ static VALUE ruby_curl_easy_perform_delete(VALUE self) {
 
 /*
  * call-seq:
- *   easy.perform                                     => true
+ *   easy.http(verb)
  *
- * Transfer the currently configured URL using the options set for this
- * Curl::Easy instance. If this is an HTTP URL, it will be transferred via
- * the GET or HEAD request method.
+ * Send an HTTP request with method set to verb, using the current options set for this Curl::Easy instance.
+ * This method always returns true or raises an exception (defined under Curl::Err) on error.
  */
-static VALUE ruby_curl_easy_perform(VALUE self) {
-  ruby_curl_easy *rbce;
-
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
-
-  return handle_perform(self,rbce);
+static VALUE ruby_curl_easy_perform_verb(VALUE self, VALUE verb) {
+  VALUE str_verb;
+  if (rb_type(verb) == T_STRING) {
+    return ruby_curl_easy_perform_verb_str(self, StringValueCStr(verb));
+  }
+  else if (rb_respond_to(verb,rb_intern("to_s"))) {
+    str_verb = rb_funcall(verb, rb_intern("to_s"), 0);
+    return ruby_curl_easy_perform_verb_str(self, StringValueCStr(str_verb));
+  }
+  else {
+    rb_raise(rb_eRuntimeError, "Invalid HTTP VERB, must response to 'to_s'");
+  }
 }
 
 /*
@@ -1967,6 +2302,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;
 
+  curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, NULL);
+
   if (rbce->multipart_form_post) {
     VALUE ret;
     struct curl_httppost *first = NULL, *last = NULL;
@@ -1975,6 +2312,17 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
     for (i = 0; i < argc; i++) {
       if (rb_obj_is_instance_of(argv[i], cCurlPostField)) {
         append_to_form(argv[i], &first, &last);
+      } else if (rb_type(argv[i]) == T_ARRAY) {
+        // see: https://github.com/rvanlieshout/curb/commit/8bcdefddc0162484681ebd1a92d52a642666a445
+        int c = 0, argv_len = (int)RARRAY_LEN(argv[i]);
+        for (; c < argv_len; ++c) {
+          if (rb_obj_is_instance_of(rb_ary_entry(argv[i],c), cCurlPostField)) {
+            append_to_form(rb_ary_entry(argv[i],c), &first, &last);
+          } else {
+            rb_raise(eCurlErrInvalidPostField, "You must use PostFields only with multipart form posts");
+            return Qnil;
+          }
+        }
       } else {
         rb_raise(eCurlErrInvalidPostField, "You must use PostFields only with multipart form posts");
         return Qnil;
@@ -1983,12 +2331,13 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
 
     curl_easy_setopt(curl, CURLOPT_POST, 0);
     curl_easy_setopt(curl, CURLOPT_HTTPPOST, first);
-    ret = handle_perform(self,rbce);
+    ret = rb_funcall(self, rb_intern("perform"), 0);
     curl_formfree(first);
 
     return ret;
   } else {
     VALUE post_body = Qnil;
+    /* TODO: check for PostField.file and raise error before to_s fails */
     if ((post_body = rb_funcall(args_ary, idJoin, 1, rbstrAmp)) == Qnil) {
       rb_raise(eCurlErrError, "Failed to join arguments");
       return Qnil;
@@ -1999,78 +2348,14 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
         ruby_curl_easy_post_body_set(self, post_body);
       }
 
-      return handle_perform(self,rbce);
-    }
-  }
-}
-
-/*
- * call-seq:
- *   easy.http_head                                   => true
- *
- * Request headers from the currently configured URL using the HEAD
- * method and current options set for this Curl::Easy instance. This
- * method always returns true, or raises an exception (defined under
- * Curl::Err) on error.
- *
- */
-static VALUE ruby_curl_easy_perform_head(VALUE self) {
-  ruby_curl_easy *rbce;
-  CURL *curl;
-  VALUE ret;
-
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
-  curl = rbce->curl;
-
-  curl_easy_setopt(curl, CURLOPT_NOBODY, 1);
-
-  ret = handle_perform(self,rbce);
-
-  curl_easy_setopt(curl, CURLOPT_NOBODY, 0);
-  return ret;
-}
-
-/*
- *call-seq:
- * easy = Curl::Easy.new("url") do|c|
- *  c.head = true
- * end
- * easy.perform
- */
-static VALUE ruby_curl_easy_set_head_option(VALUE self, VALUE onoff) {
-  ruby_curl_easy *rbce;
-
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
-
-  if( onoff == Qtrue ) {
-    curl_easy_setopt(rbce->curl, CURLOPT_NOBODY, 1);
-  }
-  else {
-    curl_easy_setopt(rbce->curl, CURLOPT_NOBODY, 0);
-  }
-
-  return onoff;
-}
-/*
- *call-seq:
- * easy = Curl::Easy.new("url") do|c|
- *  c.delete = true
- * end
- * easy.perform
- */
-static VALUE ruby_curl_easy_set_delete_option(VALUE self, VALUE onoff) {
-  ruby_curl_easy *rbce;
-
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+      /* if post body is not defined, set it so we enable POST header, even though the request body is empty */
+      if( rb_easy_nil("postdata_buffer") ) {
+        ruby_curl_easy_post_body_set(self, post_body);
+      }
 
-  if( onoff == Qtrue ) {
-    curl_easy_setopt(rbce->curl, CURLOPT_CUSTOMREQUEST, "DELETE");
-  }
-  else {
-    curl_easy_setopt(rbce->curl, CURLOPT_CUSTOMREQUEST, NULL);
+      return rb_funcall(self, rb_intern("perform"), 0);
+    }
   }
-
-  return onoff;
 }
 
 /*
@@ -2084,27 +2369,17 @@ static VALUE ruby_curl_easy_set_delete_option(VALUE self, VALUE onoff) {
 static VALUE ruby_curl_easy_perform_put(VALUE self, VALUE data) {
   ruby_curl_easy *rbce;
   CURL *curl;
-  
+
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl = rbce->curl;
-  
+
+  curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, NULL);
   ruby_curl_easy_put_data_set(self, data);
-  
-  return handle_perform(self, rbce);
-}
 
-/*
- * call-seq:
- *   Curl::Easy.http_put(url, data) {|c| ... }
- *
- * see easy.http_put
- */
-static VALUE ruby_curl_easy_class_perform_put(VALUE klass, VALUE url, VALUE data) {
-  VALUE c = ruby_curl_easy_new(1, &url, klass);
-  ruby_curl_easy_perform_put(c, data);
-  return c;
+  return rb_funcall(self, rb_intern("perform"), 0);
 }
 
+
 /* =================== DATA FUNCS =============== */
 
 /*
@@ -2180,6 +2455,30 @@ static VALUE ruby_curl_easy_response_code_get(VALUE self) {
   return LONG2NUM(code);
 }
 
+#if defined(HAVE_CURLINFO_PRIMARY_IP)
+/*
+ * call-seq:
+ *   easy.primary_ip                                  => "xx.xx.xx.xx" or nil
+ *
+ *   Retrieve the resolved IP of the most recent connection
+ *   done with this curl handle. This string may be  IPv6 if
+ *   that's enabled. This feature requires curl 7.19.x and above
+ */
+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);
+
+  if (ip && ip[0]) {    // curl returns empty string if none
+    return rb_str_new2(ip);
+  } else {
+    return Qnil;
+  }
+}
+#endif
+
 /*
  * call-seq:
  *   easy.http_connect_code                           => fixnum
@@ -2344,7 +2643,7 @@ static VALUE ruby_curl_easy_redirect_time_get(VALUE self) {
 
 /*
  * call-seq:
- *   easy.redirect_count                           => integer
+ *   easy.redirect_count                            => integer
  *
  * Retrieve the total number of redirections that were actually followed.
  *
@@ -2366,6 +2665,36 @@ 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 
+ * would enable CURLOPT_FOLLOWLOCATION.
+ *
+ * Requires libcurl 7.18.2 or higher, otherwise -1 is always returned.
+ */
+static VALUE ruby_curl_easy_redirect_url_get(VALUE self) {
+#ifdef HAVE_CURLINFO_REDIRECT_URL
+  ruby_curl_easy *rbce;
+  char* url;
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  curl_easy_getinfo(rbce->curl, CURLINFO_REDIRECT_URL, &url);
+
+  if (url && url[0]) {    // curl returns empty string if none
+    return rb_str_new2(url);
+  } else {
+    return Qnil;
+  }
+#else
+  rb_warn("Installed libcurl is too old to support redirect_url");
+  return INT2FIX(-1);
+#endif
+}
+
+
+
 /*
  * call-seq:
  *   easy.uploaded_bytes                              => float
@@ -2488,7 +2817,10 @@ static VALUE ruby_curl_easy_ssl_verify_result_get(VALUE self) {
 
 /* TODO CURLINFO_SSL_ENGINES
 
-Pass the address of a 'struct curl_slist *' to receive a linked-list of OpenSSL crypto-engines supported. Note that engines are normally implemented in separate dynamic libraries. Hence not all the returned engines may be available at run-time. NOTE: you must call curl_slist_free_all(3) on the list pointer once you're done with it, as libcurl will not free the data for you. (Added in 7.12.3)
+Pass the address of a 'struct curl_slist *' to receive a linked-list of OpenSSL crypto-engines supported.
+Note that engines are normally implemented in separate dynamic libraries.
+Hence not all the returned engines may be available at run-time.
+NOTE: you must call curl_slist_free_all(3) on the list pointer once you're done with it, as libcurl will not free the data for you. (Added in 7.12.3)
 */
 
 /*
@@ -2592,7 +2924,7 @@ static VALUE ruby_curl_easy_os_errno_get(VALUE self) {
 
 /*
  * call-seq:
- *   easy.num_connects                                    => integer
+ *   easy.num_connects                                => integer
  *
  * Retrieve the number of new connections libcurl had to create to achieve
  * the previous transfer (only the successful connects are counted).
@@ -2637,7 +2969,7 @@ Pass a pointer to a long to receive the last socket used by this curl session. I
 
 /*
  * call-seq:
- *   easy.content_type                                => "content/type" or nil
+ *   easy.ftp_entry_path                                => "C:\ftp\root\" or nil
  *
  * Retrieve the path of the entry path. That is the initial path libcurl ended
  * up in when logging on to the remote FTP server. This returns +nil+ if
@@ -2666,7 +2998,140 @@ static VALUE ruby_curl_easy_ftp_entry_path_get(VALUE self) {
 
 /*
  * call-seq:
- *   easy.inspect                                => "#<Curl::Easy http://google.com/>"
+ *   easy.multi                                     => "#<Curl::Multi>"
+ */
+static VALUE ruby_curl_easy_multi_get(VALUE self) {
+  ruby_curl_easy *rbce;
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  return rbce->multi;
+}
+
+/*
+ * call-seq:
+ *   easy.multi=multi                                    => "#<Curl::Multi>"
+ */
+static VALUE ruby_curl_easy_multi_set(VALUE self, VALUE multi) {
+  ruby_curl_easy *rbce;
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  rbce->multi = multi;
+  return rbce->multi;
+}
+
+/*
+ * call-seq:
+ *   easy.last_result                                    => 0
+ */
+static VALUE ruby_curl_easy_last_result(VALUE self) {
+  ruby_curl_easy *rbce;
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  return INT2FIX(rbce->last_result);
+}
+
+/*
+ * call-seq:
+ *   easy.setopt Fixnum, value  => value
+ *
+ * Iniital access to libcurl curl_easy_setopt
+ */
+static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
+  ruby_curl_easy *rbce;
+  long option = FIX2LONG(opt);
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+
+  switch (option) {
+  /* BEHAVIOR OPTIONS */
+  case CURLOPT_VERBOSE: {
+    VALUE verbose = val;
+    CURB_BOOLEAN_SETTER(ruby_curl_easy, verbose);
+    } break;
+  case CURLOPT_FOLLOWLOCATION: {
+    VALUE follow_location = val;
+    CURB_BOOLEAN_SETTER(ruby_curl_easy, follow_location);
+    } break;
+  /* TODO: CALLBACK OPTIONS */
+  /* TODO: ERROR OPTIONS */
+  /* NETWORK OPTIONS */
+  case CURLOPT_URL: {
+    VALUE url = val;
+    CURB_OBJECT_HSETTER(ruby_curl_easy, url);
+    } break;
+  case CURLOPT_CUSTOMREQUEST:
+    curl_easy_setopt(rbce->curl, CURLOPT_CUSTOMREQUEST, NIL_P(val) ? NULL : StringValueCStr(val));
+    break;
+  case CURLOPT_HTTP_VERSION:
+    curl_easy_setopt(rbce->curl, CURLOPT_HTTP_VERSION, FIX2INT(val));
+    break;
+  case CURLOPT_PROXY: {
+    VALUE proxy_url = val;
+    CURB_OBJECT_HSETTER(ruby_curl_easy, proxy_url);
+    } break;
+  case CURLOPT_INTERFACE: {
+    VALUE interface_hm = val;
+    CURB_OBJECT_HSETTER(ruby_curl_easy, interface_hm);
+    } break;
+  case CURLOPT_HEADER:
+  case CURLOPT_NOPROGRESS:
+  case CURLOPT_NOSIGNAL:
+  case CURLOPT_HTTPGET:
+  case CURLOPT_NOBODY: {
+    int type = rb_type(val);
+    VALUE value;
+    if (type == T_TRUE) {
+      value = rb_int_new(1);
+    } else if (type == T_FALSE) {
+      value = rb_int_new(0);
+    } else {
+      value = rb_funcall(val, rb_intern("to_i"), 0);
+    }
+    curl_easy_setopt(rbce->curl, option, FIX2INT(value));
+    } break;
+  case CURLOPT_USERPWD: {
+    VALUE userpwd = val;
+    CURB_OBJECT_HSETTER(ruby_curl_easy, userpwd);
+    } break;
+  case CURLOPT_PROXYUSERPWD: {
+    VALUE proxypwd = val;
+    CURB_OBJECT_HSETTER(ruby_curl_easy, proxypwd);
+    } break;
+  case CURLOPT_COOKIE: {
+    VALUE cookies = val;
+    CURB_OBJECT_HSETTER(ruby_curl_easy, cookies);
+    } break;
+  case CURLOPT_COOKIEFILE: {
+    VALUE cookiefile = val;
+    CURB_OBJECT_HSETTER(ruby_curl_easy, cookiefile);
+    } break;
+  case CURLOPT_COOKIEJAR: {
+    VALUE cookiejar = val;
+    CURB_OBJECT_HSETTER(ruby_curl_easy, cookiejar);
+    } break;
+  case CURLOPT_RESUME_FROM: {
+    curl_easy_setopt(rbce->curl, CURLOPT_RESUME_FROM, FIX2LONG(val));
+    } break;
+  case CURLOPT_FAILONERROR: {
+    curl_easy_setopt(rbce->curl, CURLOPT_FAILONERROR, FIX2LONG(val));
+    } break;
+  default:
+    break;
+  }
+
+  return val;
+}
+
+/*
+ * call-seq:
+ *   easy.getinfo Fixnum => value
+ *
+ * Iniital access to libcurl curl_easy_getinfo, remember getinfo doesn't return the same values as setopt
+ */
+static VALUE ruby_curl_easy_get_opt(VALUE self, VALUE opt) {
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   easy.inspect                                     => "#<Curl::Easy http://google.com/>"
  */
 static VALUE ruby_curl_easy_inspect(VALUE self) {
   char buf[64];
@@ -2678,11 +3143,11 @@ static VALUE ruby_curl_easy_inspect(VALUE self) {
     size_t len = 13+((RSTRING_LEN(url) > 50) ? 50 : RSTRING_LEN(url));
     /* "#<Net::HTTP http://www.google.com/:80 open=false>" */
     memcpy(buf,"#<Curl::Easy ", 13);
-    memcpy(buf+13,RSTRING_PTR(url), (len - 13));
-    buf[len-1] = '>';
+    memcpy(buf+13,StringValueCStr(url), (len - 13));
+    buf[len++] = '>';
     return rb_str_new(buf,len);
   }
-  return rb_str_new2("#<Curl::Easy");
+  return rb_str_new2("#<Curl::Easy>");
 }
 
 
@@ -2709,9 +3174,9 @@ static VALUE ruby_curl_easy_escape(VALUE self, VALUE svalue) {
   if( rb_type(str) != T_STRING ) { str = rb_funcall(str,rb_intern("to_s"),0); }
 
 #if (LIBCURL_VERSION_NUM >= 0x070f04)
-  result = (char*)curl_easy_escape(rbce->curl, StringValuePtr(str), RSTRING_LEN(str));
+  result = (char*)curl_easy_escape(rbce->curl, StringValuePtr(str), (int)RSTRING_LEN(str));
 #else
-  result = (char*)curl_escape(StringValuePtr(str), RSTRING_LEN(str));
+  result = (char*)curl_escape(StringValuePtr(str), (int)RSTRING_LEN(str));
 #endif
 
   rresult = rb_str_new2(result);
@@ -2722,7 +3187,7 @@ static VALUE ruby_curl_easy_escape(VALUE self, VALUE svalue) {
 
 /*
  * call-seq:
- *   easy.unescape("some%20text")                       => "some text"
+ *   easy.unescape("some%20text")                     => "some text"
  *
  * Convert the given URL encoded input string to a "plain string" and return
  * the result. All input characters that are URL encoded (%XX where XX is a
@@ -2737,7 +3202,7 @@ static VALUE ruby_curl_easy_unescape(VALUE self, VALUE str) {
   Data_Get_Struct(self, ruby_curl_easy, rbce);
 
 #if (LIBCURL_VERSION_NUM >= 0x070f04)
-  result = (char*)curl_easy_unescape(rbce->curl, StringValuePtr(str), RSTRING_LEN(str), &rlen);
+  result = (char*)curl_easy_unescape(rbce->curl, StringValuePtr(str), (int)RSTRING_LEN(str), &rlen);
 #else
   result = (char*)curl_unescape(StringValuePtr(str), RSTRING_LEN(str));
   rlen = strlen(result);
@@ -2754,114 +3219,14 @@ static VALUE ruby_curl_easy_unescape(VALUE self, VALUE str) {
 
 /*
  * call-seq:
- *   Curl::Easy.perform(url) { |easy| ... }           => #&lt;Curl::Easy...&gt;
- *
- * Convenience method that creates a new Curl::Easy instance with
- * the specified URL and calls the general +perform+ method, before returning
- * the new instance. For HTTP URLs, this is equivalent to calling +http_get+.
- *
- * If a block is supplied, the new instance will be yielded just prior to
- * the +http_get+ call.
- */
-static VALUE ruby_curl_easy_class_perform(int argc, VALUE *argv, VALUE klass) {
-  VALUE c = ruby_curl_easy_new(argc, argv, klass);
-
-  if (rb_block_given_p()) {
-    rb_yield(c);
-  }
-
-  ruby_curl_easy_perform(c);
-  return c;
-}
-
-/*
- * call-seq:
- *   Curl::Easy.http_get(url) { |easy| ... }          => #&lt;Curl::Easy...&gt;
- *
- * Convenience method that creates a new Curl::Easy instance with
- * the specified URL and calls +http_get+, before returning the new instance.
- *
- * If a block is supplied, the new instance will be yielded just prior to
- * the +http_get+ call.
- */
-static VALUE ruby_curl_easy_class_perform_get(int argc, VALUE *argv, VALUE klass) {
-  VALUE c = ruby_curl_easy_new(argc, argv, klass);
-
-  ruby_curl_easy_perform_get(c);
-  return c;
-}
-
-/*
- * call-seq:
- *   Curl::Easy.http_delete(url) { |easy| ... }          => #&lt;Curl::Easy...&gt;
- *
- * Convenience method that creates a new Curl::Easy instance with
- * the specified URL and calls +http_delete+, before returning the new instance.
- *
- * If a block is supplied, the new instance will be yielded just prior to
- * the +http_delete+ call.
- */
-static VALUE ruby_curl_easy_class_perform_delete(int argc, VALUE *argv, VALUE klass) {
-  VALUE c = ruby_curl_easy_new(argc, argv, klass);
-
-  ruby_curl_easy_perform_delete(c);
-  return c;
-}
-
-/*
- * call-seq:
- *   Curl::Easy.http_head(url) { |easy| ... }          => #&lt;Curl::Easy...&gt;
- *
- * Convenience method that creates a new Curl::Easy instance with
- * the specified URL and calls +http_head+, before returning the new instance.
- *
- * If a block is supplied, the new instance will be yielded just prior to
- * the +http_head+ call.
- */
-static VALUE ruby_curl_easy_class_perform_head(int argc, VALUE *argv, VALUE klass) {
-  VALUE c = ruby_curl_easy_new(argc, argv, klass);
-
-  ruby_curl_easy_perform_head(c);
-
-  return c;
-}
-
-// TODO: add convenience method for http_post
-
-/*
- * call-seq:
- *   Curl::Easy.http_post(url, "some=urlencoded%20form%20data&and=so%20on") => true
- *   Curl::Easy.http_post(url, "some=urlencoded%20form%20data", "and=so%20on", ...) => true
- *   Curl::Easy.http_post(url, "some=urlencoded%20form%20data", Curl::PostField, "and=so%20on", ...) => true
- *   Curl::Easy.http_post(url, Curl::PostField, Curl::PostField ..., Curl::PostField) => true
- *
- * POST the specified formdata to the currently configured URL using
- * the current options set for this Curl::Easy instance. This method
- * always returns true, or raises an exception (defined under
- * Curl::Err) on error.
+ *   Curl::Easy.error(code)    => String
  *
- * If you wish to use multipart form encoding, you'll need to supply a block
- * in order to set multipart_form_post true. See #http_post for more
- * information.
+ * translate an internal libcurl error to ruby error class
  */
-static VALUE ruby_curl_easy_class_perform_post(int argc, VALUE *argv, VALUE klass) {
-  VALUE url, fields;
-  VALUE c;
-
-  rb_scan_args(argc, argv, "1*", &url, &fields);
-
-  c = ruby_curl_easy_new(1, &url, klass);
-
-  if (argc > 1) {
-    ruby_curl_easy_perform_post(argc - 1, &argv[1], c);
-  } else {
-    ruby_curl_easy_perform_post(0, NULL, c);
-  }
-
-  return c;
+static VALUE ruby_curl_easy_error_message(VALUE klass, VALUE code) {
+  return rb_curl_easy_error(FIX2INT(code));
 }
 
-
 /* =================== INIT LIB =====================*/
 void init_curb_easy() {
   idCall = rb_intern("call");
@@ -2874,34 +3239,23 @@ void init_curb_easy() {
 
   /* Class methods */
   rb_define_singleton_method(cCurlEasy, "new", ruby_curl_easy_new, -1);
-  rb_define_singleton_method(cCurlEasy, "perform", ruby_curl_easy_class_perform, -1);
-  rb_define_singleton_method(cCurlEasy, "http_delete", ruby_curl_easy_class_perform_delete, -1);
-  rb_define_singleton_method(cCurlEasy, "http_get", ruby_curl_easy_class_perform_get, -1);
-  rb_define_singleton_method(cCurlEasy, "http_post", ruby_curl_easy_class_perform_post, -1);
-  rb_define_singleton_method(cCurlEasy, "http_head", ruby_curl_easy_class_perform_head, -1);
-  rb_define_singleton_method(cCurlEasy, "http_put", ruby_curl_easy_class_perform_put, 2);
+  rb_define_singleton_method(cCurlEasy, "error", ruby_curl_easy_error_message, 1);
 
   /* Attributes for config next perform */
-  rb_define_method(cCurlEasy, "url=", ruby_curl_easy_url_set, 1);
   rb_define_method(cCurlEasy, "url", ruby_curl_easy_url_get, 0);
-  rb_define_method(cCurlEasy, "proxy_url=", ruby_curl_easy_proxy_url_set, 1);
   rb_define_method(cCurlEasy, "proxy_url", ruby_curl_easy_proxy_url_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_set, 1);
   rb_define_method(cCurlEasy, "interface", ruby_curl_easy_interface_get, 0);
-  rb_define_method(cCurlEasy, "userpwd=", ruby_curl_easy_userpwd_set, 1);
   rb_define_method(cCurlEasy, "userpwd", ruby_curl_easy_userpwd_get, 0);
-  rb_define_method(cCurlEasy, "proxypwd=", ruby_curl_easy_proxypwd_set, 1);
   rb_define_method(cCurlEasy, "proxypwd", ruby_curl_easy_proxypwd_get, 0);
-  rb_define_method(cCurlEasy, "cookies=", ruby_curl_easy_cookies_set, 1);
   rb_define_method(cCurlEasy, "cookies", ruby_curl_easy_cookies_get, 0);
-  rb_define_method(cCurlEasy, "cookiefile=", ruby_curl_easy_cookiefile_set, 1);
   rb_define_method(cCurlEasy, "cookiefile", ruby_curl_easy_cookiefile_get, 0);
-  rb_define_method(cCurlEasy, "cookiejar=", ruby_curl_easy_cookiejar_set, 1);
   rb_define_method(cCurlEasy, "cookiejar", ruby_curl_easy_cookiejar_get, 0);
   rb_define_method(cCurlEasy, "cert=", ruby_curl_easy_cert_set, 1);
   rb_define_method(cCurlEasy, "cert", ruby_curl_easy_cert_get, 0);
+  rb_define_method(cCurlEasy, "cert_key=", ruby_curl_easy_cert_key_set, 1);
+  rb_define_method(cCurlEasy, "cert_key", ruby_curl_easy_cert_key_get, 0);
   rb_define_method(cCurlEasy, "cacert=", ruby_curl_easy_cacert_set, 1);
   rb_define_method(cCurlEasy, "cacert", ruby_curl_easy_cacert_get, 0);
   rb_define_method(cCurlEasy, "certpassword=", ruby_curl_easy_certpassword_set, 1);
@@ -2914,6 +3268,8 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "post_body=", ruby_curl_easy_post_body_set, 1);
   rb_define_method(cCurlEasy, "post_body", ruby_curl_easy_post_body_get, 0);
   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, "local_port=", ruby_curl_easy_local_port_set, 1);
   rb_define_method(cCurlEasy, "local_port", ruby_curl_easy_local_port_get, 0);
@@ -2937,6 +3293,16 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "dns_cache_timeout", ruby_curl_easy_dns_cache_timeout_get, 0);
   rb_define_method(cCurlEasy, "ftp_response_timeout=", ruby_curl_easy_ftp_response_timeout_set, 1);
   rb_define_method(cCurlEasy, "ftp_response_timeout", ruby_curl_easy_ftp_response_timeout_get, 0);
+  rb_define_method(cCurlEasy, "low_speed_limit=", ruby_curl_easy_low_speed_limit_set, 1);
+  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, "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);
+  rb_define_method(cCurlEasy, "use_ssl", ruby_curl_easy_use_ssl_get, 0);
+  rb_define_method(cCurlEasy, "ftp_filemethod=", ruby_curl_easy_ftp_filemethod_set, 1);
+  rb_define_method(cCurlEasy, "ftp_filemethod", ruby_curl_easy_ftp_filemethod_get, 0);
 
   rb_define_method(cCurlEasy, "username=", ruby_curl_easy_username_set, 1);
   rb_define_method(cCurlEasy, "username", ruby_curl_easy_username_get, 0);
@@ -2949,14 +3315,14 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "fetch_file_time?", ruby_curl_easy_fetch_file_time_q, 0);
   rb_define_method(cCurlEasy, "ssl_verify_peer=", ruby_curl_easy_ssl_verify_peer_set, 1);
   rb_define_method(cCurlEasy, "ssl_verify_peer?", ruby_curl_easy_ssl_verify_peer_q, 0);
-  rb_define_method(cCurlEasy, "ssl_verify_host=", ruby_curl_easy_ssl_verify_host_set, 1);
-  rb_define_method(cCurlEasy, "ssl_verify_host?", ruby_curl_easy_ssl_verify_host_q, 0);
+  rb_define_method(cCurlEasy, "ssl_verify_host_integer=", ruby_curl_easy_ssl_verify_host_set, 1);
+  rb_define_method(cCurlEasy, "ssl_verify_host", ruby_curl_easy_ssl_verify_host_get, 0);
   rb_define_method(cCurlEasy, "header_in_body=", ruby_curl_easy_header_in_body_set, 1);
   rb_define_method(cCurlEasy, "header_in_body?", ruby_curl_easy_header_in_body_q, 0);
   rb_define_method(cCurlEasy, "use_netrc=", ruby_curl_easy_use_netrc_set, 1);
   rb_define_method(cCurlEasy, "use_netrc?", ruby_curl_easy_use_netrc_q, 0);
-  rb_define_method(cCurlEasy, "follow_location=", ruby_curl_easy_follow_location_set, 1);
   rb_define_method(cCurlEasy, "follow_location?", ruby_curl_easy_follow_location_q, 0);
+  rb_define_method(cCurlEasy, "autoreferer=", ruby_curl_easy_autoreferer_set, 1);
   rb_define_method(cCurlEasy, "unrestricted_auth=", ruby_curl_easy_unrestricted_auth_set, 1);
   rb_define_method(cCurlEasy, "unrestricted_auth?", ruby_curl_easy_unrestricted_auth_q, 0);
   rb_define_method(cCurlEasy, "verbose=", ruby_curl_easy_verbose_set, 1);
@@ -2965,6 +3331,10 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "multipart_form_post?", ruby_curl_easy_multipart_form_post_q, 0);
   rb_define_method(cCurlEasy, "enable_cookies=", ruby_curl_easy_enable_cookies_set, 1);
   rb_define_method(cCurlEasy, "enable_cookies?", ruby_curl_easy_enable_cookies_q, 0);
+  rb_define_method(cCurlEasy, "ignore_content_length=", ruby_curl_easy_ignore_content_length_set, 1);
+  rb_define_method(cCurlEasy, "ignore_content_length?", ruby_curl_easy_ignore_content_length_q, 0);
+  rb_define_method(cCurlEasy, "resolve_mode", ruby_curl_easy_resolve_mode, 0);
+  rb_define_method(cCurlEasy, "resolve_mode=", ruby_curl_easy_resolve_mode_set, 1);
 
   rb_define_method(cCurlEasy, "on_body", ruby_curl_easy_on_body_set, -1);
   rb_define_method(cCurlEasy, "on_header", ruby_curl_easy_on_header_set, -1);
@@ -2972,16 +3342,13 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "on_debug", ruby_curl_easy_on_debug_set, -1);
   rb_define_method(cCurlEasy, "on_success", ruby_curl_easy_on_success_set, -1);
   rb_define_method(cCurlEasy, "on_failure", ruby_curl_easy_on_failure_set, -1);
+  rb_define_method(cCurlEasy, "on_missing", ruby_curl_easy_on_missing_set, -1);
+  rb_define_method(cCurlEasy, "on_redirect", ruby_curl_easy_on_redirect_set, -1);
   rb_define_method(cCurlEasy, "on_complete", ruby_curl_easy_on_complete_set, -1);
 
-  rb_define_method(cCurlEasy, "perform", ruby_curl_easy_perform, 0);
-  rb_define_method(cCurlEasy, "http_delete", ruby_curl_easy_perform_delete, 0);
-  rb_define_method(cCurlEasy, "http_get", ruby_curl_easy_perform_get, 0);
+  rb_define_method(cCurlEasy, "http", ruby_curl_easy_perform_verb, 1);
   rb_define_method(cCurlEasy, "http_post", ruby_curl_easy_perform_post, -1);
-  rb_define_method(cCurlEasy, "http_head", ruby_curl_easy_perform_head, 0);
   rb_define_method(cCurlEasy, "http_put", ruby_curl_easy_perform_put, 1);
-  rb_define_method(cCurlEasy, "head=", ruby_curl_easy_set_head_option, 1);
-  rb_define_method(cCurlEasy, "delete=", ruby_curl_easy_set_delete_option, 1);
 
   /* Post-perform info methods */
   rb_define_method(cCurlEasy, "body_str", ruby_curl_easy_body_str_get, 0);
@@ -2989,6 +3356,9 @@ void init_curb_easy() {
 
   rb_define_method(cCurlEasy, "last_effective_url", ruby_curl_easy_last_effective_url_get, 0);
   rb_define_method(cCurlEasy, "response_code", ruby_curl_easy_response_code_get, 0);
+#if defined(HAVE_CURLINFO_PRIMARY_IP)
+  rb_define_method(cCurlEasy, "primary_ip", ruby_curl_easy_primary_ip_get, 0);
+#endif
   rb_define_method(cCurlEasy, "http_connect_code", ruby_curl_easy_http_connect_code_get, 0);
   rb_define_method(cCurlEasy, "file_time", ruby_curl_easy_file_time_get, 0);
   rb_define_method(cCurlEasy, "total_time", ruby_curl_easy_total_time_get, 0);
@@ -2998,6 +3368,7 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "start_transfer_time", ruby_curl_easy_start_transfer_time_get, 0);
   rb_define_method(cCurlEasy, "redirect_time", ruby_curl_easy_redirect_time_get, 0);
   rb_define_method(cCurlEasy, "redirect_count", ruby_curl_easy_redirect_count_get, 0);
+  rb_define_method(cCurlEasy, "redirect_url", ruby_curl_easy_redirect_url_get, 0);
   rb_define_method(cCurlEasy, "downloaded_bytes", ruby_curl_easy_downloaded_bytes_get, 0);
   rb_define_method(cCurlEasy, "uploaded_bytes", ruby_curl_easy_uploaded_bytes_get, 0);
   rb_define_method(cCurlEasy, "download_speed", ruby_curl_easy_download_speed_get, 0);
@@ -3011,7 +3382,9 @@ void init_curb_easy() {
   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, "ftp_entry_path", ruby_curl_easy_ftp_entry_path_get, 0);
-  rb_define_method(cCurlEasy, "inspect", ruby_curl_easy_inspect, 0);
+
+  rb_define_method(cCurlEasy, "close", ruby_curl_easy_close, 0);
+  rb_define_method(cCurlEasy, "reset", ruby_curl_easy_reset, 0);
 
   /* Curl utils */
   rb_define_method(cCurlEasy, "escape", ruby_curl_easy_escape, 1);
@@ -3020,4 +3393,12 @@ void init_curb_easy() {
   /* Runtime support */
   rb_define_method(cCurlEasy, "clone", ruby_curl_easy_clone, 0);
   rb_define_alias(cCurlEasy, "dup", "clone");
+  rb_define_method(cCurlEasy, "inspect", ruby_curl_easy_inspect, 0);
+
+  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, "setopt", ruby_curl_easy_set_opt, 2);
+  rb_define_method(cCurlEasy, "getinfo", ruby_curl_easy_get_opt, 1);
 }