curb 0.5.8.0-x86-linux → 0.7.7-x86-linux

data/README

@@ -144,12 +144,13 @@ documentation with:
       c = Curl::Easy.new(url) do|curl|
         curl.follow_location = true
         curl.on_body{|data| responses[url] << data; data.size }
+        curl.on_success {|easy| puts "success, add more easy handles" }
       end
       m.add(c)
     end
    
     m.perform do
-      puts "idling... can do some work here, including add new requests"
+      puts "idling... can do some work here"
     end
    
     requests.each do|url|

data/Rakefile

@@ -100,7 +100,7 @@ Rake::TestTask.new(:bugtests) do |t|
   t.test_files = FileList['tests/bug_*.rb']
   t.verbose = false
 end
-                          
+ 
 #Rake::TestTask.new(:funtests) do |t|
   #  t.test_files = FileList['test/func_*.rb']
   #t.warning = true
@@ -110,6 +110,25 @@ end
 task :unittests => :compile
 task :bugtests => :compile
 
+def has_gem?(file,name)
+  begin
+    require file
+    has_http_persistent = true
+  rescue LoadError => e
+    puts "Skipping #{name}"
+  end
+end
+
+desc "Benchmark curl against http://127.0.0.1/zeros-2k - will fail if /zeros-2k or 127.0.0.1 are missing"
+task :bench do
+  sh "ruby bench/curb_easy.rb"
+  sh "ruby bench/curb_multi.rb"
+  sh "ruby bench/nethttp_test.rb" if has_gem?("net/http/persistent","net-http-persistent")
+  sh "ruby bench/patron_test.rb" if has_gem?("patron","patron")
+  sh "ruby bench/typhoeus_test.rb" if has_gem?("typhoeus","typhoeus")
+  sh "ruby bench/typhoeus_hydra_test.rb" if has_gem?("typhoeus","typhoeus")
+end
+
 # RDoc Tasks ---------------------------------------------------------
 desc "Create the RDOC documentation"
 task :doc do

data/ext/curb.c

@@ -255,6 +255,10 @@ void Init_curb_core() {
   /* Passed to on_debug handler to indicate that the data is protocol data sent to the peer. */
   rb_define_const(mCurl, "CURLINFO_DATA_OUT", INT2FIX(CURLINFO_DATA_OUT));
 
+  rb_define_const(mCurl, "CURL_MULTICWD",  INT2FIX(CURLFTPMETHOD_MULTICWD));
+  rb_define_const(mCurl, "CURL_NOCWD",     INT2FIX(CURLFTPMETHOD_NOCWD));
+  rb_define_const(mCurl, "CURL_SINGLECWD", INT2FIX(CURLFTPMETHOD_SINGLECWD));
+
   /* When passed to Curl::Easy#proxy_type , indicates that the proxy is an HTTP proxy. (libcurl >= 7.10) */
 #ifdef HAVE_CURLPROXY_HTTP
   rb_define_const(mCurl, "CURLPROXY_HTTP", INT2FIX(CURLPROXY_HTTP));
@@ -262,6 +266,28 @@ void Init_curb_core() {
   rb_define_const(mCurl, "CURLPROXY_HTTP", INT2FIX(-1));
 #endif
 
+#ifdef CURL_VERSION_SSL
+  rb_define_const(mCurl, "CURL_SSLVERSION_DEFAULT", INT2FIX(CURL_SSLVERSION_DEFAULT));
+  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1",   INT2FIX(CURL_SSLVERSION_TLSv1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_SSLv2",   INT2FIX(CURL_SSLVERSION_SSLv2));
+  rb_define_const(mCurl, "CURL_SSLVERSION_SSLv3",   INT2FIX(CURL_SSLVERSION_SSLv3));
+
+  rb_define_const(mCurl, "CURL_USESSL_CONTROL", INT2FIX(CURB_FTPSSL_CONTROL));
+  rb_define_const(mCurl, "CURL_USESSL_NONE", INT2FIX(CURB_FTPSSL_NONE));
+  rb_define_const(mCurl, "CURL_USESSL_TRY", INT2FIX(CURB_FTPSSL_TRY));
+  rb_define_const(mCurl, "CURL_USESSL_ALL", INT2FIX(CURB_FTPSSL_ALL));
+#else
+  rb_define_const(mCurl, "CURL_SSLVERSION_DEFAULT", INT2FIX(-1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1",   INT2FIX(-1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_SSLv2",   INT2FIX(-1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_SSLv3",   INT2FIX(-1));
+
+  rb_define_const(mCurl, "CURL_USESSL_CONTROL", INT2FIX(-1));
+  rb_define_const(mCurl, "CURL_USESSL_NONE", INT2FIX(-1));
+  rb_define_const(mCurl, "CURL_USESSL_TRY", INT2FIX(-1));
+  rb_define_const(mCurl, "CURL_USESSL_ALL", INT2FIX(-1));
+#endif
+
   /* When passed to Curl::Easy#proxy_type , indicates that the proxy is a SOCKS4 proxy. (libcurl >= 7.15.2) */
 #ifdef HAVE_CURLPROXY_SOCKS4
   rb_define_const(mCurl, "CURLPROXY_SOCKS4", INT2FIX(CURLPROXY_SOCKS4));

data/ext/curb.h

@@ -20,11 +20,11 @@
 #include "curb_macros.h"
 
 // These should be managed from the Rake 'release' task.
-#define CURB_VERSION   "0.5.8.0"
-#define CURB_VER_NUM   580
+#define CURB_VERSION   "0.7.7"
+#define CURB_VER_NUM   707
 #define CURB_VER_MAJ   0
-#define CURB_VER_MIN   5
-#define CURB_VER_MIC   8
+#define CURB_VER_MIN   7
+#define CURB_VER_MIC   7
 #define CURB_VER_PATCH 0
 
 
@@ -37,11 +37,13 @@
   #define RSTRING_PTR(x) RSTRING(x)->ptr
 #endif
 
+#ifndef RHASH_LEN
 #ifdef HAVE_RUBY19_HASH
   #define RHASH_LEN(hash) RHASH(hash)->ntbl->num_entries
 #else
   #define RHASH_LEN(hash) RHASH(hash)->tbl->num_entries
 #endif
+#endif
 
 extern VALUE mCurl;
 

data/ext/curb_easy.c

@@ -42,8 +42,9 @@ static size_t read_data_handler(void *ptr,
                                 size_t size,
                                 size_t nmemb,
                                 ruby_curl_easy *rbce) {
+  VALUE upload = rb_easy_get("upload");
   size_t read_bytes = (size*nmemb);
-  VALUE stream = ruby_curl_upload_stream_get(rbce->upload);
+  VALUE stream = ruby_curl_upload_stream_get(upload);
 
   if (rb_respond_to(stream, rb_intern("read"))) {//if (rb_respond_to(stream, rb_intern("to_s"))) {
     /* copy read_bytes from stream into ptr */
@@ -62,7 +63,7 @@ static size_t read_data_handler(void *ptr,
     size_t len;
     size_t remaining;
     char *str_ptr;
-    Data_Get_Struct(rbce->upload, ruby_curl_upload, rbcu);
+    Data_Get_Struct(upload, ruby_curl_upload, rbcu);
     str = rb_funcall(stream, rb_intern("to_s"), 0);
     len = RSTRING_LEN(str);
     remaining = len - rbcu->offset;
@@ -133,103 +134,37 @@ static int proc_debug_handler(CURL *curl,
 
 /* ================== MARK/FREE FUNC ==================*/
 void curl_easy_mark(ruby_curl_easy *rbce) {
-  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);
-  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->self != Qnil ) {
-    rb_gc_mark(rbce->self);
-  }
-
-  if( rbce->upload != Qnil ) {
-    rb_gc_mark(rbce->upload);
-  }
+  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);
-}
 
+  if (rbce->curl_ftp_commands) {
+    curl_slist_free_all(rbce->curl_ftp_commands);
+  }
 
-/* ================= ALLOC METHODS ====================*/
+  if (rbce->curl) {
+    curl_easy_cleanup(rbce->curl);
+  }
+}
 
-/*
- * 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.
- * 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;
+void curl_easy_free(ruby_curl_easy *rbce) {
+  ruby_curl_easy_free(rbce);
+  free(rbce);
+}
 
-  rb_scan_args(argc, argv, "01&", &url, &blk);
 
-  rbce = ALLOC(ruby_curl_easy);
+/* ================= ALLOC METHODS ====================*/
 
-  /* handler */
-  rbce->curl = curl_easy_init();
+static void ruby_curl_easy_zero(ruby_curl_easy *rbce) {
+  rbce->opts = rb_hash_new();
 
-  /* assoc objects */
-  rbce->url = url;
-  rbce->proxy_url = Qnil;
-  rbce->body_data = Qnil;
-  rbce->body_proc = Qnil;
-  rbce->header_data = Qnil;
-  rbce->header_proc = Qnil;
-  rbce->progress_proc = Qnil;
-  rbce->debug_proc = Qnil;
-  rbce->interface_hm = Qnil;
-  rbce->userpwd = Qnil;
-  rbce->proxypwd = Qnil;
-  rbce->headers = rb_hash_new();
-  rbce->cookies = Qnil;
-  rbce->cookiefile = Qnil;
-  rbce->cookiejar = Qnil;
-  rbce->cert = Qnil;
-  rbce->cacert = Qnil;
-  rbce->certpassword = Qnil;
-  rbce->certtype = rb_str_new2("PEM");
-  rbce->encoding = Qnil;
-  rbce->useragent = Qnil;
-  rbce->success_proc = Qnil;
-  rbce->failure_proc = Qnil;
-  rbce->complete_proc = Qnil;
+  rbce->curl_headers = NULL;
+  rbce->curl_ftp_commands = NULL;
 
   /* various-typed opts */
   rbce->local_port = 0;
@@ -243,6 +178,9 @@ 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->ssl_version = -1;
+  rbce->use_ssl = -1;
+  rbce->ftp_filemethod = -1;
 
   /* bool opts */
   rbce->proxy_tunnel = 0;
@@ -256,20 +194,44 @@ static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
   rbce->verbose = 0;
   rbce->multipart_form_post = 0;
   rbce->enable_cookies = 0;
+}
 
-  /* buffers */
-  rbce->postdata_buffer = Qnil;
-  rbce->bodybuf = Qnil;
-  rbce->headerbuf = Qnil;
-  rbce->curl_headers = NULL;
+/*
+ * 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.
+ * 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;
 
-  rbce->self = Qnil;
-  rbce->upload = Qnil;
+  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");
+  }
+
+  rbce->multi = Qnil;
+
+  ruby_curl_easy_zero(rbce);
+
+  rb_easy_set("url", url);
 
   new_curl = Data_Wrap_Struct(klass, curl_easy_mark, curl_easy_free, rbce);
 
-  /* set the rbce pointer to the curl handle */
-  ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)rbce);
+  /* set the new_curl pointer to the curl handle */
+  ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)new_curl);
   if (ecode != CURLE_OK) {
     raise_curl_easy_error_exception(ecode);
   }
@@ -298,10 +260,77 @@ 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);
 }
 
+/*
+ * call-seq:
+ *   easy.close                                      => nil
+ *
+ * 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_close(VALUE self) {
+  CURLcode ecode;
+  ruby_curl_easy *rbce;
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+
+  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.reset                                      => Hash
+ *
+ * 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_reset(VALUE self) {
+  CURLcode ecode;
+  ruby_curl_easy *rbce;
+  VALUE opts_dup;
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  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);
+  }
+
+  return opts_dup;
+}
+
 
 /* ================ OBJ ATTRIBUTES ==================*/
 
@@ -314,22 +343,22 @@ static VALUE ruby_curl_easy_clone(VALUE self) {
  * the URL between calls to +perform+.
  */
 static VALUE ruby_curl_easy_url_set(VALUE self, VALUE url) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, url);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, url);
 }
 
 /*
  * call-seq:
- *   easy.url                                         => "http://some.url/"
+ *   easy.url                                         => string
  *
  * Obtain the URL that will be used by subsequent calls to +perform+.
  */
 static VALUE ruby_curl_easy_url_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, url);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, url);
 }
 
 /*
  * call-seq:
- *   easy.proxy_url = "some.url"                      => "some.url"
+ *   easy.proxy_url = string                          => string
  *
  * 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
@@ -353,23 +382,23 @@ static VALUE ruby_curl_easy_url_get(VALUE self) {
  * 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_SETTER(ruby_curl_easy, proxy_url);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, proxy_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+.
  */
 static VALUE ruby_curl_easy_proxy_url_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, proxy_url);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, proxy_url);
 }
 
 /*
  * 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
@@ -389,113 +418,118 @@ static VALUE ruby_curl_easy_proxy_url_get(VALUE self) {
  * the perform step.
  */
 static VALUE ruby_curl_easy_headers_set(VALUE self, VALUE headers) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, headers);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, headers);
 }
 
 /*
  * call-seq:
- *   easy.headers                                              => Hash, Array or Str
+ *   easy.headers                                     => Hash, Array or Str
  *
  * Obtain the custom HTTP headers for following requests.
  */
 static VALUE ruby_curl_easy_headers_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, headers);
+  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")); 
+  if (headers == Qnil) { headers = rb_easy_set("headers", rb_hash_new()); }
+  return headers;
 }
 
 /*
  * call-seq:
- *   easy.interface = "interface"                     => "interface"
+ *   easy.interface = string                          => string
  *
  * 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_SETTER(ruby_curl_easy, 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.
  */
 static VALUE ruby_curl_easy_interface_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, interface_hm);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, interface_hm);
 }
 
 /*
  * call-seq:
- *   easy.userpwd = "pwd string"                      => "pwd string"
+ *   easy.userpwd = string                            => 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_SETTER(ruby_curl_easy, 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+.
  */
 static VALUE ruby_curl_easy_userpwd_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, userpwd);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, userpwd);
 }
 
 /*
  * call-seq:
- *   easy.proxypwd = "pwd string"                     => "pwd string"
+ *   easy.proxypwd = string                           => 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_SETTER(ruby_curl_easy, 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
  * should have the form "username:password"
  */
 static VALUE ruby_curl_easy_proxypwd_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, proxypwd);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, proxypwd);
 }
 
 
 /*
  * call-seq:
- *   easy.cookies = "name1=content1; name2=content2;"                => "pwd string"
+ *   easy.cookies = "name1=content1; name2=content2;" => 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_SETTER(ruby_curl_easy, 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.
  */
 static VALUE ruby_curl_easy_cookies_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, cookies);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, cookies);
 }
 
 /*
  * call-seq:
- *   easy.cookiefile = "cookies.txt"                => "pwd string"
+ *   easy.cookiefile = string                         => string
  *
  * Set a file that contains cookies to be sent in subsequent requests by this Curl::Easy instance.
  *
@@ -503,22 +537,22 @@ static VALUE ruby_curl_easy_cookies_get(VALUE self) {
  * engine, or this option will be ignored.
  */
 static VALUE ruby_curl_easy_cookiefile_set(VALUE self, VALUE cookiefile) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, 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.
  */
 static VALUE ruby_curl_easy_cookiefile_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, cookiefile);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, cookiefile);
 }
 
 /*
  * call-seq:
- *   easy.cookiejar = "cookiejar.file"                => "pwd string"
+ *   easy.cookiejar = string                          => string
  *
  * Set a cookiejar file to use for this Curl::Easy instance.
  * Cookies from the response will be written into this file.
@@ -527,71 +561,93 @@ static VALUE ruby_curl_easy_cookiefile_get(VALUE self) {
  * engine, or this option will be ignored.
  */
 static VALUE ruby_curl_easy_cookiejar_set(VALUE self, VALUE cookiejar) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, 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.
  */
 static VALUE ruby_curl_easy_cookiejar_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, cookiejar);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, cookiejar);
 }
 
 /*
  * 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.
  *
  */
 static VALUE ruby_curl_easy_cert_set(VALUE self, VALUE cert) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, cert);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, cert);
 }
 
 /*
  * call-seq:
- *   easy.cert                                        => "cert.file"
+ *   easy.cert                                        => string
  *
  * Obtain the cert file to use for this Curl::Easy instance.
  */
 static VALUE ruby_curl_easy_cert_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, cert);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, cert);
 }
 
 /*
  * 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.
  *
  */
 static VALUE ruby_curl_easy_cacert_set(VALUE self, VALUE cacert) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, cacert);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, cacert);
 }
 
 /*
  * call-seq:
- *   easy.cacert                                      => "cacert.file"
+ *   easy.cacert                                      => string
  *
  * Obtain the cacert file to use for this Curl::Easy instance.
  */
 static VALUE ruby_curl_easy_cacert_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, cacert);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, cacert);
 }
 
 /*
  * call-seq:
- *   easy.certpassword = "cert password"                   => ""
+ *   easy.certpassword = string                       => ""
  *
  * Set a password used to open the specified cert
  */
 static VALUE ruby_curl_easy_certpassword_set(VALUE self, VALUE certpassword) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, certpassword);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, certpassword);
 }
 
 /*
@@ -603,49 +659,49 @@ static VALUE ruby_curl_easy_certpassword_set(VALUE self, VALUE certpassword) {
  *
  */
 static VALUE ruby_curl_easy_certtype_set(VALUE self, VALUE certtype) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, certtype);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, certtype);
 }
 
 /*
  * call-seq:
- *   easy.certtype                                  => "cert.type"
+ *   easy.certtype                                    => string
  *
  * Obtain the cert type used for this Curl::Easy instance
  */
 static VALUE ruby_curl_easy_certtype_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, certtype);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, certtype);
 }
 
 /*
  * call-seq:
- *   easy.encoding=                                     => "string"
+ *   easy.encoding = string                           => string
  *
  * Set the accepted encoding types, curl will handle all of the decompression
  *
  */
 static VALUE ruby_curl_easy_encoding_set(VALUE self, VALUE encoding) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, encoding);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, encoding);
 }
 /*
  * call-seq:
- *   easy.encoding                                     => "string"
+ *   easy.encoding                                    => string
  *
  * Get the set encoding types
  *
 */
 static VALUE ruby_curl_easy_encoding_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, encoding);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, encoding);
 }
 
 /*
  * call-seq:
- *   easy.useragent = "Ruby/Curb"                      => ""
+ *   easy.useragent = "Ruby/Curb"                     => ""
  *
  * Set the user agent string for this Curl::Easy instance
  *
  */
 static VALUE ruby_curl_easy_useragent_set(VALUE self, VALUE useragent) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, useragent);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, useragent);
 }
 
 /*
@@ -655,12 +711,12 @@ static VALUE ruby_curl_easy_useragent_set(VALUE self, VALUE useragent) {
  * Obtain the user agent string used for this Curl::Easy instance
  */
 static VALUE ruby_curl_easy_useragent_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, useragent);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, useragent);
 }
 
 /*
  * 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.
@@ -674,13 +730,14 @@ static VALUE ruby_curl_easy_post_body_set(VALUE self, VALUE post_body) {
   
   char *data;
   long len;
-  
+
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   
   curl = rbce->curl;
   
   if ( post_body == Qnil ) {
-    rbce->postdata_buffer = Qnil;
+    //rbce->postdata_buffer = Qnil;
+    rb_easy_del("postdata_buffer");
     
   } else {  
     data = StringValuePtr(post_body);
@@ -688,7 +745,8 @@ static VALUE ruby_curl_easy_post_body_set(VALUE self, VALUE post_body) {
   
     // 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;
+    //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);
@@ -702,12 +760,12 @@ 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.
  */
 static VALUE ruby_curl_easy_post_body_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, postdata_buffer);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, postdata_buffer);
 }
 
 /*
@@ -722,6 +780,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);
 
@@ -729,9 +788,9 @@ static VALUE ruby_curl_easy_put_data_set(VALUE self, VALUE data) {
   ruby_curl_upload_stream_set(upload,data);
 
   curl = rbce->curl;
-  rbce->upload = upload; /* keep the upload object alive as long as
-                            the easy handle is active or until the upload
-                            is complete or terminated... */
+  rb_easy_set("upload", upload); /* keep the upload object alive as long as
+                                    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_UPLOAD, 1);
@@ -742,40 +801,63 @@ static VALUE ruby_curl_easy_put_data_set(VALUE self, VALUE data) {
    * we need to set specific headers for the PUT to work... so
    * convert the internal headers structure to a HASH if one is set
    */
-  if (rbce->headers != Qnil) {
-    if (rb_type(rbce->headers) == T_ARRAY || rb_type(rbce->headers) == T_STRING) {
+  if (!rb_easy_nil("headers")) {
+    if (rb_easy_type_check("headers", T_ARRAY) || rb_easy_type_check("headers", T_STRING)) {
       rb_raise(rb_eRuntimeError, "Must set headers as a HASH to modify the headers in an PUT request");
     }
   }
 
+  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 ) {
       VALUE size;
-      if( rb_hash_aref(rbce->headers, rb_str_new2("Expect")) == Qnil ) {
-        rb_hash_aset(rbce->headers, rb_str_new2("Expect"), rb_str_new2(""));
+      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));
     }
-    else if( rb_hash_aref(rbce->headers, rb_str_new2("Transfer-Encoding")) == Qnil ) {
-      rb_hash_aset(rbce->headers, rb_str_new2("Transfer-Encoding"), rb_str_new2("chunked"));
+    else if( 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_respond_to(data, rb_intern("to_s"))) {
     curl_easy_setopt(curl, CURLOPT_INFILESIZE, RSTRING_LEN(data));
-    if( rb_hash_aref(rbce->headers, rb_str_new2("Expect")) == Qnil ) {
-      rb_hash_aset(rbce->headers, rb_str_new2("Expect"), rb_str_new2(""));
+    if( rb_hash_aref(headers, rb_str_new2("Expect")) == Qnil ) {
+      rb_hash_aset(headers, rb_str_new2("Expect"), rb_str_new2(""));
     }
   }
   else {
     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 ==================*/
 
 /*
@@ -877,16 +959,63 @@ static VALUE ruby_curl_easy_proxy_type_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, proxy_type, -1);
 }
 
+#if defined(HAVE_CURLAUTH_DIGEST_IE)
+#define CURL_HTTPAUTH_STR_TO_NUM(node) \
+  (!strncmp("basic",node,5)) ? CURLAUTH_BASIC : \
+  (!strncmp("digest_ie",node,9)) ? CURLAUTH_DIGEST_IE : \
+  (!strncmp("digest",node,6)) ? CURLAUTH_DIGEST : \
+  (!strncmp("gssnegotiate",node,12)) ? CURLAUTH_GSSNEGOTIATE : \
+  (!strncmp("ntlm",node,4)) ? CURLAUTH_NTLM : \
+  (!strncmp("any",node,3)) ? CURLAUTH_ANY : \
+  (!strncmp("anysafe",node,7)) ? CURLAUTH_ANYSAFE : 0
+#else 
+#define CURL_HTTPAUTH_STR_TO_NUM(node) \
+  (!strncmp("basic",node,5)) ? CURLAUTH_BASIC : \
+  (!strncmp("digest",node,6)) ? CURLAUTH_DIGEST : \
+  (!strncmp("gssnegotiate",node,12)) ? CURLAUTH_GSSNEGOTIATE : \
+  (!strncmp("ntlm",node,4)) ? CURLAUTH_NTLM : \
+  (!strncmp("any",node,3)) ? CURLAUTH_ANY : \
+  (!strncmp("anysafe",node,7)) ? CURLAUTH_ANYSAFE : 0
+#endif
 /*
  * call-seq:
  *   easy.http_auth_types = fixnum or nil             => fixnum or nil
+ *   easy.http_auth_types = [:basic,:digest,:digest_ie,:gssnegotiate, :ntlm, :any, :anysafe]
  *
  * Set the HTTP authentication types that may be used for the following
  * +perform+ calls. This is a bitmap made by ORing together the
  * Curl::CURLAUTH constants.
  */
-static VALUE ruby_curl_easy_http_auth_types_set(VALUE self, VALUE http_auth_types) {
-  CURB_IMMED_SETTER(ruby_curl_easy, http_auth_types, 0);
+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;
+  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 = 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;
+    }
+    else {
+      rbce->http_auth_types = NUM2INT(rb_ary_entry(args_ary,0));
+    }
+  }
+  else {
+    // we could have multiple values, but they should be symbols
+    node = RSTRING_PTR(rb_funcall(rb_ary_entry(args_ary,0),rb_intern("to_s"),0));
+    mask = CURL_HTTPAUTH_STR_TO_NUM(node);
+    for( i = 1; i < len; ++i ) {
+      node = RSTRING_PTR(rb_funcall(rb_ary_entry(args_ary,i),rb_intern("to_s"),0));
+      mask |= CURL_HTTPAUTH_STR_TO_NUM(node);
+    }
+    rbce->http_auth_types = mask;
+  }
+  return INT2NUM(rbce->http_auth_types);
 }
 
 /*
@@ -1052,11 +1181,131 @@ static VALUE ruby_curl_easy_ftp_response_timeout_get(VALUE self, VALUE ftp_respo
   CURB_IMMED_GETTER(ruby_curl_easy, ftp_response_timeout, 0);
 }
 
+/*
+ * call-seq:
+ *   easy.username = string                           => string
+ *
+ * Set the HTTP Authentication username.
+ */
+static VALUE ruby_curl_easy_username_set(VALUE self, VALUE username) {
+#if HAVE_CURLOPT_USERNAME
+  CURB_OBJECT_HSETTER(ruby_curl_easy, username);
+#else
+  return Qnil;
+#endif
+}
+
+/*
+ * call-seq:
+ *   easy.username                                    => string
+ * 
+ * Get the current username
+ */
+static VALUE ruby_curl_easy_username_get(VALUE self, VALUE username) {
+#if HAVE_CURLOPT_USERNAME
+  CURB_OBJECT_HGETTER(ruby_curl_easy, username);
+#else
+  return Qnil;
+#endif
+}
+
+/*
+ * call-seq:
+ *   easy.password = string                           => string
+ *
+ * Set the HTTP Authentication password.
+ */
+static VALUE ruby_curl_easy_password_set(VALUE self, VALUE password) {
+#if HAVE_CURLOPT_PASSWORD
+  CURB_OBJECT_HSETTER(ruby_curl_easy, password);
+#else
+  return Qnil;
+#endif
+}
+
+/*
+ * call-seq:
+ *   easy.password                                    => string
+ * 
+ * Get the current password
+ */
+static VALUE ruby_curl_easy_password_get(VALUE self, VALUE password) {
+#if HAVE_CURLOPT_PASSWORD
+  CURB_OBJECT_HGETTER(ruby_curl_easy, password);
+#else
+  return Qnil;
+#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.
  */
@@ -1066,7 +1315,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.
  */
@@ -1076,7 +1325,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.
@@ -1087,7 +1336,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.
@@ -1098,7 +1347,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
@@ -1116,7 +1365,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.
@@ -1127,7 +1376,7 @@ static VALUE ruby_curl_easy_ssl_verify_peer_q(VALUE self) {
 
 /*
  * call-seq:
- *   ssl_verify_host = boolean                        => boolean
+ *   easy.ssl_verify_host = boolean                   => boolean
  *
  * 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
@@ -1144,7 +1393,7 @@ static VALUE ruby_curl_easy_ssl_verify_host_set(VALUE self, VALUE ssl_verify_hos
 
 /*
  * call-seq:
- *   ssl_verify_host?                                 => boolean
+ *   easy.ssl_verify_host?                            => boolean
  *
  * Determine whether this Curl instance will verify that the server cert
  * is for the server it is known as.
@@ -1155,7 +1404,7 @@ static VALUE ruby_curl_easy_ssl_verify_host_q(VALUE self) {
 
 /*
  * 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
@@ -1167,7 +1416,7 @@ 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.
@@ -1178,7 +1427,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.
@@ -1189,7 +1438,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.
@@ -1200,7 +1449,7 @@ static VALUE ruby_curl_easy_use_netrc_q(VALUE self) {
 
 /*
  * call-seq:
- *   follow_location = boolean                        => boolean
+ *   easy.follow_location = boolean                   => boolean
  *
  * Configure whether this Curl instance will follow Location: headers
  * in HTTP responses. Redirects will only be followed to the extent
@@ -1209,10 +1458,29 @@ static VALUE ruby_curl_easy_use_netrc_q(VALUE self) {
 static VALUE ruby_curl_easy_follow_location_set(VALUE self, VALUE follow_location) {
   CURB_BOOLEAN_SETTER(ruby_curl_easy, follow_location);
 }
+/*
+ * call-seq:
+ *
+ * easy = Curl::Easy.new
+ * easy.autoreferer=true
+ */
+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.
@@ -1223,7 +1491,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.
@@ -1234,7 +1502,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.
@@ -1308,7 +1576,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.
@@ -1335,12 +1603,12 @@ static VALUE ruby_curl_easy_enable_cookies_q(VALUE self) {
  * the processing with a Curl::Err::AbortedByCallbackError.
  */
 static VALUE ruby_curl_easy_on_body_set(int argc, VALUE *argv, VALUE self) {
-  CURB_HANDLER_PROC_SETTER(ruby_curl_easy, body_proc);
+  CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, body_proc);
 }
 
 /*
  * call-seq:
- *   easy.on_success { ... }                 => &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
@@ -1350,12 +1618,12 @@ static VALUE ruby_curl_easy_on_body_set(int argc, VALUE *argv, VALUE self) {
  * status of 20x
  */
 static VALUE ruby_curl_easy_on_success_set(int argc, VALUE *argv, VALUE self) {
-  CURB_HANDLER_PROC_SETTER(ruby_curl_easy, success_proc);
+  CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, success_proc);
 }
 
 /*
  * call-seq:
- *   easy.on_failure { ... }                 => &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
@@ -1365,12 +1633,12 @@ static VALUE ruby_curl_easy_on_success_set(int argc, VALUE *argv, VALUE self) {
  * status of 50x
  */
 static VALUE ruby_curl_easy_on_failure_set(int argc, VALUE *argv, VALUE self) {
-  CURB_HANDLER_PROC_SETTER(ruby_curl_easy, failure_proc);
+  CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, failure_proc);
 }
 
 /*
  * call-seq:
- *   easy.on_complete { ... }                 => &lt;old handler&gt;
+ *   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
@@ -1379,7 +1647,7 @@ static VALUE ruby_curl_easy_on_failure_set(int argc, VALUE *argv, VALUE self) {
  * The +on_complete+ handler is called when the request is finished.
  */
 static VALUE ruby_curl_easy_on_complete_set(int argc, VALUE *argv, VALUE self) {
-  CURB_HANDLER_PROC_SETTER(ruby_curl_easy, complete_proc);
+  CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, complete_proc);
 }
 
 /*
@@ -1395,7 +1663,7 @@ static VALUE ruby_curl_easy_on_complete_set(int argc, VALUE *argv, VALUE self) {
  * block supplied to +on_body+.
  */
 static VALUE ruby_curl_easy_on_header_set(int argc, VALUE *argv, VALUE self) {
-  CURB_HANDLER_PROC_SETTER(ruby_curl_easy, header_proc);
+  CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, header_proc);
 }
 
 /*
@@ -1416,7 +1684,7 @@ static VALUE ruby_curl_easy_on_header_set(int argc, VALUE *argv, VALUE self) {
  * throwing a Curl::Err::AbortedByCallbackError.
  */
 static VALUE ruby_curl_easy_on_progress_set(int argc, VALUE *argv, VALUE self) {
-  CURB_HANDLER_PROC_SETTER(ruby_curl_easy, progress_proc);
+  CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, progress_proc);
 }
 
 /*
@@ -1437,7 +1705,7 @@ static VALUE ruby_curl_easy_on_progress_set(int argc, VALUE *argv, VALUE self) {
  * data. The data is passed as a String.
  */
 static VALUE ruby_curl_easy_on_debug_set(int argc, VALUE *argv, VALUE self) {
-  CURB_HANDLER_PROC_SETTER(ruby_curl_easy, debug_proc);
+  CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, debug_proc);
 }
 
 
@@ -1472,91 +1740,123 @@ 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, 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, VALUE *body_buffer, VALUE *header_buffer, 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;
+  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;
 
-  if (rbce->url == Qnil) {
+  if (_url == Qnil) {
     rb_raise(eCurlErrError, "No URL supplied");
   }
 
-  url = rb_check_string_type(rbce->url);
+  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
-  if (rbce->interface_hm != Qnil) {
-    curl_easy_setopt(curl, CURLOPT_INTERFACE, StringValuePtr(rbce->interface_hm));
+  if (!rb_easy_nil("interface_hm")) {
+    curl_easy_setopt(curl, CURLOPT_INTERFACE, rb_easy_get_str("interface_hm"));
   } else {
     curl_easy_setopt(curl, CURLOPT_INTERFACE, NULL);
   }
 
-  if (rbce->userpwd != Qnil) {
-    curl_easy_setopt(curl, CURLOPT_USERPWD, StringValuePtr(rbce->userpwd));
+#if HAVE_CURLOPT_USERNAME == 1 && HAVE_CURLOPT_PASSWORD == 1
+  if (!rb_easy_nil("username")) {
+    curl_easy_setopt(curl, CURLOPT_USERNAME, rb_easy_get_str("username"));
+  } else {
+    curl_easy_setopt(curl, CURLOPT_USERNAME, NULL);
+  }
+  if (!rb_easy_nil("password")) {
+    curl_easy_setopt(curl, CURLOPT_PASSWORD, rb_easy_get_str("password"));
+  }
+  else {
+    curl_easy_setopt(curl, CURLOPT_PASSWORD, NULL);
+  }
+#endif
+
+  if (!rb_easy_nil("userpwd")) {
+    curl_easy_setopt(curl, CURLOPT_USERPWD, rb_easy_get_str("userpwd"));
+#if HAVE_CURLOPT_USERNAME == 1
+  } else if (rb_easy_nil("username") && rb_easy_nil("password")) { /* don't set this even to NULL if we have set username and password */
+#else
   } else {
+#endif
     curl_easy_setopt(curl, CURLOPT_USERPWD, NULL);
   }
 
-  if (rbce->proxy_url != Qnil) {
-    curl_easy_setopt(curl, CURLOPT_PROXY, StringValuePtr(rbce->proxy_url));
+  if (!rb_easy_nil("proxy_url")) {
+    curl_easy_setopt(curl, CURLOPT_PROXY, rb_easy_get_str("proxy_url"));
   } else {
     curl_easy_setopt(curl, CURLOPT_PROXY, NULL);
   }
 
-  if (rbce->proxypwd != Qnil) {
-    curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, StringValuePtr(rbce->proxypwd));
+  if (!rb_easy_nil("proxypwd")) {
+    curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, rb_easy_get_str("proxy_pwd"));
   } else {
     curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, NULL);
   }
 
   // body/header procs
-  if (rbce->body_proc != Qnil) {
-    *body_buffer = Qnil;
+  if (!rb_easy_nil("body_proc")) {
     curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)&proc_data_handler);
-    curl_easy_setopt(curl, CURLOPT_WRITEDATA, rbce->body_proc);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, rb_easy_get("body_proc"));//rbce->body_proc);
+    /* clear out the body_data if it was set */
+    rb_easy_del("body_data");
   } else {
-    *body_buffer = rb_str_buf_new(32768);
+    VALUE body_buffer = rb_easy_set("body_data", rb_str_buf_new(32768));
     curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)&default_data_handler);
-    curl_easy_setopt(curl, CURLOPT_WRITEDATA, *body_buffer);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, body_buffer);
   }
 
-  if (rbce->header_proc != Qnil) {
-    *header_buffer = Qnil;
+  if (!rb_easy_nil("header_proc")) {
     curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, (curl_write_callback)&proc_data_handler);
-    curl_easy_setopt(curl, CURLOPT_HEADERDATA, rbce->header_proc);
+    curl_easy_setopt(curl, CURLOPT_HEADERDATA, rb_easy_get("header_proc"));
+    /* clear out the header_data if it was set */
+    rb_easy_del("header_data");
   } else {
-    *header_buffer = rb_str_buf_new(32768);
+    VALUE header_buffer = rb_easy_set("header_data", rb_str_buf_new(16384));
     curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, (curl_write_callback)&default_data_handler);
-    curl_easy_setopt(curl, CURLOPT_HEADERDATA, *header_buffer);
+    curl_easy_setopt(curl, CURLOPT_HEADERDATA, header_buffer);
   }
 
   /* encoding */
-  if (rbce->encoding != Qnil) {
-    curl_easy_setopt(curl, CURLOPT_ENCODING, StringValuePtr(rbce->encoding));
+  if (!rb_easy_nil("encoding")) {
+    curl_easy_setopt(curl, CURLOPT_ENCODING, rb_easy_get_str("encoding"));
   }
 
   // progress and debug procs
-  if (rbce->progress_proc != Qnil) {
+  if (!rb_easy_nil("progress_proc")) {
     curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, (curl_progress_callback)&proc_progress_handler);
-    curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, rbce->progress_proc);
+    curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, rb_easy_get("progress_proc"));
     curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
   } else {
     curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1);
   }
 
-  if (rbce->debug_proc != Qnil) {
+  if (!rb_easy_nil("debug_proc")) {
     curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, (curl_debug_callback)&proc_debug_handler);
-    curl_easy_setopt(curl, CURLOPT_DEBUGDATA, rbce->debug_proc);
+    curl_easy_setopt(curl, CURLOPT_DEBUGDATA, rb_easy_get("debug_proc"));
     curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
   } else {
     // have to remove handler to re-enable standard verbosity
@@ -1568,7 +1868,6 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
   /* 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);
 
@@ -1653,50 +1952,71 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
      FIXME this may not get disabled if it's enabled, the disabled again from ruby.
      */
   if (rbce->enable_cookies) {
-    if (rbce->cookiejar != Qnil) {
-      curl_easy_setopt(curl, CURLOPT_COOKIEJAR, StringValuePtr(rbce->cookiejar));
+    if (!rb_easy_nil("cookiejar")) {
+      curl_easy_setopt(curl, CURLOPT_COOKIEJAR, rb_easy_get_str("cookiejar"));
     }
 
-    if (rbce->cookiefile != Qnil) {
-      curl_easy_setopt(curl, CURLOPT_COOKIEFILE, StringValuePtr(rbce->cookiefile));
+    if (!rb_easy_nil("cookiefile")) {
+      curl_easy_setopt(curl, CURLOPT_COOKIEFILE, rb_easy_get_str("cookiefile"));
     } else {
       curl_easy_setopt(curl, CURLOPT_COOKIEFILE, ""); /* "" = magic to just enable */
     }
   }
 
-  if (rbce->cookies != Qnil) {
-    curl_easy_setopt(curl, CURLOPT_COOKIE, StringValuePtr(rbce->cookies));
+  if (!rb_easy_nil("cookies")) {
+    curl_easy_setopt(curl, CURLOPT_COOKIE, rb_easy_get_str("cookies"));
   }
 
   /* Set up HTTPS cert handling if necessary */
-  if (rbce->cert != Qnil) {
-    curl_easy_setopt(curl, CURLOPT_SSLCERTTYPE, StringValuePtr(rbce->certtype));
-    curl_easy_setopt(curl, CURLOPT_SSLCERT, StringValuePtr(rbce->cert));
-    if (rbce->certpassword != Qnil) {
-      curl_easy_setopt(curl, CURLOPT_SSLCERTPASSWD, StringValuePtr(rbce->certpassword));
+  if (!rb_easy_nil("cert")) {
+    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 (rbce->cacert != Qnil) {
+  if (!rb_easy_nil("cacert")) {
 #ifdef HAVE_CURL_CONFIG_CA
     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 (rbce->useragent != Qnil) {
-    curl_easy_setopt(curl, CURLOPT_USERAGENT, StringValuePtr(rbce->useragent));
+  if (!rb_easy_nil("useragent")) {
+    curl_easy_setopt(curl, CURLOPT_USERAGENT, rb_easy_get_str("useragent"));
   }
 
   /* Setup HTTP headers if necessary */
   curl_easy_setopt(curl, CURLOPT_HTTPHEADER, NULL);   // XXX: maybe we shouldn't be clearing this?
 
-  if (rbce->headers != Qnil) {
-    if ((rb_type(rbce->headers) == T_ARRAY) || (rb_type(rbce->headers) == T_HASH)) {
-      rb_iterate(rb_each, rbce->headers, cb_each_http_header, (VALUE)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);
     } else {
-      VALUE headers_str = rb_obj_as_string(rbce->headers);
+      VALUE headers_str = rb_obj_as_string(rb_easy_get("headers"));
       *hdrs = curl_slist_append(*hdrs, StringValuePtr(headers_str));
     }
 
@@ -1705,6 +2025,17 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
     }
   }
 
+  /* Setup FTP commands if necessary */
+  if (!rb_easy_nil("ftp_commands")) {
+    if (rb_easy_type_check("ftp_commands", T_ARRAY)) {
+      rb_iterate(rb_each, rb_easy_get("ftp_commands"), cb_each_ftp_command, (VALUE)cmds);
+    }
+
+    if (*cmds) {
+      curl_easy_setopt(curl, CURLOPT_QUOTE, *cmds);
+    }
+  }
+
   return Qnil;
 }
 /***********************************************
@@ -1713,48 +2044,25 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
  *
  * Always returns Qtrue.
  */
-VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce, VALUE bodybuf, VALUE headerbuf, struct curl_slist *headers ) {
+VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce ) {
 
   CURL *curl = rbce->curl;
-  
+  struct curl_slist *headers = rbce->curl_headers;
   // Free everything up
   if (headers) {
     curl_slist_free_all(headers);
     rbce->curl_headers = NULL;
   }
 
-  // Sort out the built-in body/header data.
-  if (bodybuf != Qnil) {
-    if (TYPE(bodybuf) == T_STRING) {
-      rbce->body_data = rb_str_to_str(bodybuf);
-    }
-    else if (rb_respond_to(bodybuf, rb_intern("to_s"))) {
-      rbce->body_data = rb_funcall(bodybuf, rb_intern("to_s"), 0);
-    }
-    else {
-      rbce->body_data = Qnil;
-    }
-  } else {
-    rbce->body_data = Qnil;
+  struct curl_slist *ftp_commands = rbce->curl_ftp_commands;
+  if (ftp_commands) {
+    curl_slist_free_all(ftp_commands);
+    rbce->curl_ftp_commands = NULL;
   }
 
-  if (headerbuf != Qnil) {
-    if (TYPE(headerbuf) == T_STRING) {
-      rbce->header_data = rb_str_to_str(headerbuf);
-    }
-    else if (rb_respond_to(headerbuf, rb_intern("to_s"))) {
-      rbce->header_data = rb_funcall(headerbuf, rb_intern("to_s"), 0);
-    }
-    else {
-      rbce->header_data = Qnil;
-    }
-  } else {
-    rbce->header_data = Qnil;
-  }
-  
   // clean up a PUT request's curl options.
-  if (rbce->upload != Qnil) {
-    rbce->upload = Qnil; // set the upload object to Qnil to let the GC clean up
+  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);
     curl_easy_setopt(curl, CURLOPT_READFUNCTION, NULL);
     curl_easy_setopt(curl, CURLOPT_READDATA, NULL);
@@ -1777,13 +2085,16 @@ VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce, VALUE bodybuf, V
 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);
+  /* reuse existing multi handle for this easy handle */
+  if (NIL_P(rbce->multi)) {
+    rbce->multi = ruby_curl_multi_new(cCurlMulti);
+  }
+  rb_funcall(rbce->multi, rb_intern("add"), 1, self );
+  ret = rb_funcall(rbce->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 && rbce->failure_proc == Qnil ) {
+  if (rbce->last_result != 0 && rb_easy_nil("failure_proc")) {
     raise_curl_easy_error_exception(rbce->last_result);
   }
 
@@ -1805,20 +2116,16 @@ static VALUE ruby_curl_easy_perform_get(VALUE self) {
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl = rbce->curl;
 
+  curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, NULL);
   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, char *verb) {
   ruby_curl_easy *rbce;
   CURL *curl;
   VALUE retval;
@@ -1826,7 +2133,7 @@ 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);
 
@@ -1835,6 +2142,29 @@ static VALUE ruby_curl_easy_perform_delete(VALUE self) {
   return retval;
 }
 
+/*
+ * 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.
+ */
+static VALUE ruby_curl_easy_perform_delete(VALUE self) {
+  return ruby_curl_easy_perform_verb_str(self, "DELETE");
+}
+
+/*
+ * call-seq:
+ *   easy.http(verb)
+ *
+ * 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_verb(VALUE self, VALUE verb) {
+  return ruby_curl_easy_perform_verb_str(self, RSTRING_PTR(verb));
+}
+
 /*
  * call-seq:
  *   easy.perform                                     => true
@@ -1886,6 +2216,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;
@@ -1907,12 +2239,22 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
 
     return ret;
   } else {
-    VALUE post_body;
+    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;
     } else {
-      ruby_curl_easy_post_body_set(self, post_body);
+      /* if the function call above returns an empty string because no additional arguments were passed this makes sure
+         a previously set easy.post_body = "arg=foo&bar=bin"  will be honored */
+      if( post_body != Qnil && rb_type(post_body) == T_STRING && RSTRING_LEN(post_body) > 0 ) {
+        ruby_curl_easy_post_body_set(self, post_body);
+      }
+
+      /* 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);
+      }
 
       return handle_perform(self,rbce);
     }
@@ -1966,6 +2308,40 @@ static VALUE ruby_curl_easy_set_head_option(VALUE self, VALUE onoff) {
 
   return onoff;
 }
+/*
+ *call-seq:
+ *
+ * easy = Curl::Easy.new("url")
+ * easy.version = Curl::HTTP_1_1
+ * easy.version = Curl::HTTP_1_0
+ * easy.version = Curl::HTTP_NONE
+ *
+ */
+static VALUE ruby_curl_easy_set_version(VALUE self, VALUE version) {
+  ruby_curl_easy *rbce;
+  //fprintf(stderr,"CURL_HTTP_VERSION_1_1: %d, CURL_HTTP_VERSION_1_0: %d, CURL_HTTP_VERSION_NONE: %d\n", CURL_HTTP_VERSION_1_1, CURL_HTTP_VERSION_1_0, CURL_HTTP_VERSION_NONE);
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+
+  curl_easy_setopt(rbce->curl, CURLOPT_HTTP_VERSION, FIX2INT(version));
+
+  return version;
+}
+/*
+ * call-seq:
+ *
+ * easy = Curl::Easy.new
+ * easy.nosignal = true
+ */
+static VALUE ruby_curl_easy_set_nosignal(VALUE self, VALUE onoff) {
+  ruby_curl_easy *rbce;
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+
+  curl_easy_setopt(rbce->curl, CURLOPT_NOSIGNAL, (Qtrue == onoff) ? 1 : 0);
+
+  return onoff;
+}
 /*
  *call-seq:
  * easy = Curl::Easy.new("url") do|c|
@@ -2003,6 +2379,7 @@ static VALUE ruby_curl_easy_perform_put(VALUE self, VALUE data) {
   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);
@@ -2031,7 +2408,7 @@ static VALUE ruby_curl_easy_class_perform_put(VALUE klass, VALUE url, VALUE data
  * your own body handler, this string will be empty.
  */
 static VALUE ruby_curl_easy_body_str_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, body_data);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, body_data);
 }
 
 /*
@@ -2043,7 +2420,7 @@ static VALUE ruby_curl_easy_body_str_get(VALUE self) {
  * your own header handler, this string will be empty.
  */
 static VALUE ruby_curl_easy_header_str_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, header_data);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, header_data);
 }
 
 
@@ -2095,6 +2472,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
@@ -2259,7 +2660,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.
  *
@@ -2507,7 +2908,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).
@@ -2552,7 +2953,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
@@ -2581,18 +2982,19 @@ static VALUE ruby_curl_easy_ftp_entry_path_get(VALUE self) {
 
 /*
  * call-seq:
- *   easy.inspect                                => "#<Curl::Easy http://google.com/>"
+ *   easy.inspect                                     => "#<Curl::Easy http://google.com/>"
  */
 static VALUE ruby_curl_easy_inspect(VALUE self) {
   char buf[64];
   ruby_curl_easy *rbce;
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   /* if we don't have a url set... we'll crash... */
-  if(rbce->url != Qnil && rb_type(rbce->url) == T_STRING) {
-    size_t len = 13+((RSTRING_LEN(rbce->url) > 50) ? 50 : RSTRING_LEN(rbce->url));
+  if( !rb_easy_nil("url") && rb_easy_type_check("url", T_STRING)) {
+    VALUE url = rb_easy_get("url");
+    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(rbce->url), (len - 13));
+    memcpy(buf+13,RSTRING_PTR(url), (len - 13));
     buf[len-1] = '>';
     return rb_str_new(buf,len);
   }
@@ -2636,7 +3038,7 @@ static VALUE ruby_curl_easy_escape(VALUE self, VALUE svalue) {
 
 /*
  * call-seq:
- *   easy.unescape("some text")                       => "some%20text"
+ *   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
@@ -2707,7 +3109,7 @@ static VALUE ruby_curl_easy_class_perform_get(int argc, VALUE *argv, VALUE klass
 
 /*
  * call-seq:
- *   Curl::Easy.http_delete(url) { |easy| ... }          => #&lt;Curl::Easy...&gt;
+ *   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.
@@ -2724,7 +3126,7 @@ static VALUE ruby_curl_easy_class_perform_delete(int argc, VALUE *argv, VALUE kl
 
 /*
  * call-seq:
- *   Curl::Easy.http_head(url) { |easy| ... }          => #&lt;Curl::Easy...&gt;
+ *   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.
@@ -2816,6 +3218,8 @@ void init_curb_easy() {
   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);
@@ -2828,6 +3232,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);
@@ -2837,7 +3243,7 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "proxy_port", ruby_curl_easy_proxy_port_get, 0);
   rb_define_method(cCurlEasy, "proxy_type=", ruby_curl_easy_proxy_type_set, 1);
   rb_define_method(cCurlEasy, "proxy_type", ruby_curl_easy_proxy_type_get, 0);
-  rb_define_method(cCurlEasy, "http_auth_types=", ruby_curl_easy_http_auth_types_set, 1);
+  rb_define_method(cCurlEasy, "http_auth_types=", ruby_curl_easy_http_auth_types_set, -1);
   rb_define_method(cCurlEasy, "http_auth_types", ruby_curl_easy_http_auth_types_get, 0);
   rb_define_method(cCurlEasy, "proxy_auth_types=", ruby_curl_easy_proxy_auth_types_set, 1);
   rb_define_method(cCurlEasy, "proxy_auth_types", ruby_curl_easy_proxy_auth_types_get, 0);
@@ -2851,6 +3257,17 @@ 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, "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);
+  rb_define_method(cCurlEasy, "password=", ruby_curl_easy_password_set, 1);
+  rb_define_method(cCurlEasy, "password", ruby_curl_easy_password_get, 0);
 
   rb_define_method(cCurlEasy, "proxy_tunnel=", ruby_curl_easy_proxy_tunnel_set, 1);
   rb_define_method(cCurlEasy, "proxy_tunnel?", ruby_curl_easy_proxy_tunnel_q, 0);
@@ -2866,6 +3283,7 @@ void init_curb_easy() {
   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);
@@ -2884,6 +3302,7 @@ void init_curb_easy() {
   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", ruby_curl_easy_perform_verb, 1);
   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_post", ruby_curl_easy_perform_post, -1);
@@ -2891,6 +3310,11 @@ void init_curb_easy() {
   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);
+  rb_define_method(cCurlEasy, "version=", ruby_curl_easy_set_version, 1);
+  rb_define_const(mCurl, "HTTP_1_1", LONG2NUM(CURL_HTTP_VERSION_1_1));
+  rb_define_const(mCurl, "HTTP_1_0", LONG2NUM(CURL_HTTP_VERSION_1_0));
+  rb_define_const(mCurl, "HTTP_NONE", LONG2NUM(CURL_HTTP_VERSION_NONE));
+  rb_define_method(cCurlEasy, "nosignal=", ruby_curl_easy_set_nosignal, 1);
 
   /* Post-perform info methods */
   rb_define_method(cCurlEasy, "body_str", ruby_curl_easy_body_str_get, 0);
@@ -2898,6 +3322,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);
@@ -2920,7 +3347,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);
@@ -2929,4 +3358,5 @@ 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);
 }