taf2-curb 0.4.0.0 → 0.4.1.0

data/ext/curb.c

@@ -1,10 +1,10 @@
 /* Curb - Libcurl(3) bindings for Ruby.
- * Copyright (c)2006 Ross Bamford. 
+ * Copyright (c)2006 Ross Bamford.
  * Licensed under the Ruby License. See LICENSE for details.
- * 
+ *
  * $Id: curb.c 35 2006-12-23 15:22:19Z roscopeco $
  */
- 
+
 #include "curb.h"
 
 VALUE mCurl;
@@ -14,36 +14,36 @@ VALUE mCurl;
 /*
  * call-seq:
  *   Curl.ipv6?                                       => true or false
- * 
- * Returns true if the installed libcurl supports IPv6. 
+ *
+ * Returns true if the installed libcurl supports IPv6.
  */
 static VALUE ruby_curl_ipv6_q(VALUE mod) {
-  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
+  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);
   return((ver->features & CURL_VERSION_IPV6) ? Qtrue : Qfalse);
 }
 
 /*
  * call-seq:
  *   Curl.kerberos4?                                  => true or false
- * 
+ *
  * Returns true if the installed libcurl supports Kerberos4 authentication
- * with FTP connections. 
+ * with FTP connections.
  */
 static VALUE ruby_curl_kerberos4_q(VALUE mod) {
-  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
+  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);
   return((ver->features & CURL_VERSION_KERBEROS4) ? Qtrue : Qfalse);
 }
 
 /*
  * call-seq:
  *   Curl.ssl?                                        => true or false
- * 
+ *
  * Returns true if the installed libcurl supports SSL connections.
  * For libcurl versions < 7.10, always returns false.
  */
 static VALUE ruby_curl_ssl_q(VALUE mod) {
 #ifdef HAVE_CURL_VERSION_SSL
-  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
+  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);
   return((ver->features & CURL_VERSION_SSL) ? Qtrue : Qfalse);
 #else
   return Qfalse;
@@ -53,13 +53,13 @@ static VALUE ruby_curl_ssl_q(VALUE mod) {
 /*
  * call-seq:
  *   Curl.libz?                                       => true or false
- * 
+ *
  * Returns true if the installed libcurl supports HTTP deflate
  * using libz. For libcurl versions < 7.10, always returns false.
  */
 static VALUE ruby_curl_libz_q(VALUE mod) {
 #ifdef HAVE_CURL_VERSION_LIBZ
-  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
+  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);
   return((ver->features & CURL_VERSION_LIBZ) ? Qtrue : Qfalse);
 #else
   return Qfalse;
@@ -69,13 +69,13 @@ static VALUE ruby_curl_libz_q(VALUE mod) {
 /*
  * call-seq:
  *   Curl.ntlm?                                       => true or false
- * 
+ *
  * Returns true if the installed libcurl supports HTTP NTLM.
  * For libcurl versions < 7.10.6, always returns false.
  */
 static VALUE ruby_curl_ntlm_q(VALUE mod) {
 #ifdef HAVE_CURL_VERSION_NTLM
-  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
+  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);
   return((ver->features & CURL_VERSION_NTLM) ? Qtrue : Qfalse);
 #else
   return Qfalse;
@@ -85,13 +85,13 @@ static VALUE ruby_curl_ntlm_q(VALUE mod) {
 /*
  * call-seq:
  *   Curl.gssnegotiate?                               => true or false
- * 
+ *
  * Returns true if the installed libcurl supports HTTP GSS-Negotiate.
  * For libcurl versions < 7.10.6, always returns false.
  */
 static VALUE ruby_curl_gssnegotiate_q(VALUE mod) {
 #ifdef HAVE_CURL_VERSION_GSSNEGOTIATE
-  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
+  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);
   return((ver->features & CURL_VERSION_GSSNEGOTIATE) ? Qtrue : Qfalse);
 #else
   return Qfalse;
@@ -101,14 +101,14 @@ static VALUE ruby_curl_gssnegotiate_q(VALUE mod) {
 /*
  * call-seq:
  *   Curl.debug?                                      => true or false
- * 
- * Returns true if the installed libcurl was built with extra debug 
+ *
+ * Returns true if the installed libcurl was built with extra debug
  * capabilities built-in. For libcurl versions < 7.10.6, always returns
  * false.
  */
 static VALUE ruby_curl_debug_q(VALUE mod) {
 #ifdef HAVE_CURL_VERSION_DEBUG
-  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
+  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);
   return((ver->features & CURL_VERSION_DEBUG) ? Qtrue : Qfalse);
 #else
   return Qfalse;
@@ -118,7 +118,7 @@ static VALUE ruby_curl_debug_q(VALUE mod) {
 /*
  * call-seq:
  *   Curl.asyncdns?                                   => true or false
- * 
+ *
  * Returns true if the installed libcurl was built with support for
  * asynchronous name lookups, which allows more exact timeouts (even
  * on Windows) and less blocking when using the multi interface.
@@ -126,7 +126,7 @@ static VALUE ruby_curl_debug_q(VALUE mod) {
  */
 static VALUE ruby_curl_asyncdns_q(VALUE mod) {
 #ifdef HAVE_CURL_VERSION_ASYNCHDNS
-  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
+  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);
   return((ver->features & CURL_VERSION_ASYNCHDNS) ? Qtrue : Qfalse);
 #else
   return Qfalse;
@@ -136,14 +136,14 @@ static VALUE ruby_curl_asyncdns_q(VALUE mod) {
 /*
  * call-seq:
  *   Curl.spnego?                                     => true or false
- * 
+ *
  * Returns true if the installed libcurl was built with support for SPNEGO
  * authentication (Simple and Protected GSS-API Negotiation Mechanism, defined
  * in RFC 2478). For libcurl versions < 7.10.8, always returns false.
  */
 static VALUE ruby_curl_spnego_q(VALUE mod) {
 #ifdef HAVE_CURL_VERSION_SPNEGO
-  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
+  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);
   return((ver->features & CURL_VERSION_SPNEGO) ? Qtrue : Qfalse);
 #else
   return Qfalse;
@@ -153,13 +153,13 @@ static VALUE ruby_curl_spnego_q(VALUE mod) {
 /*
  * call-seq:
  *   Curl.largefile?                                  => true or false
- * 
+ *
  * Returns true if the installed libcurl was built with support for large
  * files. For libcurl versions < 7.11.1, always returns false.
  */
 static VALUE ruby_curl_largefile_q(VALUE mod) {
 #ifdef HAVE_CURL_VERSION_LARGEFILE
-  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
+  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);
   return((ver->features & CURL_VERSION_LARGEFILE) ? Qtrue : Qfalse);
 #else
   return Qfalse;
@@ -169,14 +169,14 @@ static VALUE ruby_curl_largefile_q(VALUE mod) {
 /*
  * call-seq:
  *   Curl.idn?                                        => true or false
- * 
- * Returns true if the installed libcurl was built with support for IDNA, 
- * domain names with international letters. For libcurl versions < 7.12.0, 
+ *
+ * Returns true if the installed libcurl was built with support for IDNA,
+ * domain names with international letters. For libcurl versions < 7.12.0,
  * always returns false.
  */
 static VALUE ruby_curl_idn_q(VALUE mod) {
 #ifdef HAVE_CURL_VERSION_IDN
-  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
+  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);
   return((ver->features & CURL_VERSION_IDN) ? Qtrue : Qfalse);
 #else
   return Qfalse;
@@ -186,16 +186,16 @@ static VALUE ruby_curl_idn_q(VALUE mod) {
 /*
  * call-seq:
  *   Curl.sspi?                                       => true or false
- * 
+ *
  * Returns true if the installed libcurl was built with support for SSPI.
  * This is only available on Windows and makes libcurl use Windows-provided
  * functions for NTLM authentication. It also allows libcurl to use the current
- * user and the current user's password without the app having to pass them on. 
+ * user and the current user's password without the app having to pass them on.
  * For libcurl versions < 7.13.2, always returns false.
  */
 static VALUE ruby_curl_sspi_q(VALUE mod) {
 #ifdef HAVE_CURL_VERSION_SSPI
-  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
+  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);
   return((ver->features & CURL_VERSION_SSPI) ? Qtrue : Qfalse);
 #else
   return Qfalse;
@@ -205,13 +205,13 @@ static VALUE ruby_curl_sspi_q(VALUE mod) {
 /*
  * call-seq:
  *   Curl.conv?                                       => true or false
- * 
- * Returns true if the installed libcurl was built with support for character 
+ *
+ * Returns true if the installed libcurl was built with support for character
  * conversions. For libcurl versions < 7.15.4, always returns false.
  */
 static VALUE ruby_curl_conv_q(VALUE mod) {
 #ifdef HAVE_CURL_VERSION_CONV
-  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
+  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);
   return((ver->features & CURL_VERSION_CONV) ? Qtrue : Qfalse);
 #else
   return Qfalse;
@@ -224,32 +224,32 @@ void Init_curb_core() {
   curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);
   VALUE curlver, curllongver, curlvernum;
 
-  mCurl = rb_define_module("Curl");  
-  
+  mCurl = rb_define_module("Curl");
+
   curlver = rb_str_new2(ver->version);
   curllongver = rb_str_new2(curl_version());
   curlvernum = LONG2NUM(LIBCURL_VERSION_NUM);
-  
-  rb_define_const(mCurl, "CURB_VERSION", rb_str_new2(CURB_VERSION));    
+
+  rb_define_const(mCurl, "CURB_VERSION", rb_str_new2(CURB_VERSION));
   rb_define_const(mCurl, "VERSION", curlver);
   rb_define_const(mCurl, "CURL_VERSION", curlver);
   rb_define_const(mCurl, "VERNUM", curlvernum);
   rb_define_const(mCurl, "CURL_VERNUM", curlvernum);
-  rb_define_const(mCurl, "LONG_VERSION", curllongver);  
-  rb_define_const(mCurl, "CURL_LONG_VERSION", curllongver);  
+  rb_define_const(mCurl, "LONG_VERSION", curllongver);
+  rb_define_const(mCurl, "CURL_LONG_VERSION", curllongver);
 
   /* Passed to on_debug handler to indicate that the data is informational text. */
   rb_define_const(mCurl, "CURLINFO_TEXT", INT2FIX(CURLINFO_TEXT));
-  
+
   /* Passed to on_debug handler to indicate that the data is header (or header-like) data received from the peer. */
   rb_define_const(mCurl, "CURLINFO_HEADER_IN", INT2FIX(CURLINFO_HEADER_IN));
-  
+
   /* Passed to on_debug handler to indicate that the data is header (or header-like) data sent to the peer. */
   rb_define_const(mCurl, "CURLINFO_HEADER_OUT", INT2FIX(CURLINFO_HEADER_OUT));
-  
+
   /* Passed to on_debug handler to indicate that the data is protocol data received from the peer. */
   rb_define_const(mCurl, "CURLINFO_DATA_IN", INT2FIX(CURLINFO_DATA_IN));
-  
+
   /* 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));
 
@@ -261,14 +261,14 @@ void Init_curb_core() {
 #endif
 
   /* When passed to Curl::Easy#proxy_type , indicates that the proxy is a SOCKS4 proxy. (libcurl >= 7.15.2) */
-#ifdef HAVE_CURLPROXY_SOCKS4  
+#ifdef HAVE_CURLPROXY_SOCKS4
   rb_define_const(mCurl, "CURLPROXY_SOCKS4", INT2FIX(CURLPROXY_SOCKS4));
 #else
   rb_define_const(mCurl, "CURLPROXY_SOCKS4", INT2FIX(-2));
 #endif
 
   /* When passed to Curl::Easy#proxy_type , indicates that the proxy is a SOCKS5 proxy. (libcurl >= 7.10) */
-#ifdef HAVE_CURLPROXY_SOCKS5    
+#ifdef HAVE_CURLPROXY_SOCKS5
   rb_define_const(mCurl, "CURLPROXY_SOCKS5", INT2FIX(CURLPROXY_SOCKS5));
 #else
   rb_define_const(mCurl, "CURLPROXY_SOCKS5", INT2FIX(-2));
@@ -296,14 +296,14 @@ void Init_curb_core() {
 #endif
 
   /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, directs libcurl to use HTTP NTLM authentication. Requires MS Windows or OpenSSL support. */
-#ifdef HAVE_CURLAUTH_NTLM  
+#ifdef HAVE_CURLAUTH_NTLM
   rb_define_const(mCurl, "CURLAUTH_NTLM", INT2FIX(CURLAUTH_NTLM));
 #else
   rb_define_const(mCurl, "CURLAUTH_NTLM", INT2FIX(0));
 #endif
 
   /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, allows libcurl to select any suitable authentication method except basic. */
-#ifdef HAVE_CURLAUTH_ANYSAFE  
+#ifdef HAVE_CURLAUTH_ANYSAFE
   rb_define_const(mCurl, "CURLAUTH_ANYSAFE", INT2FIX(CURLAUTH_ANYSAFE));
 #else
   rb_define_const(mCurl, "CURLAUTH_ANYSAFE", INT2FIX(0));
@@ -315,7 +315,7 @@ void Init_curb_core() {
 #else
   rb_define_const(mCurl, "CURLAUTH_ANY", INT2FIX(0));
 #endif
-  
+
   rb_define_singleton_method(mCurl, "ipv6?", ruby_curl_ipv6_q, 0);
   rb_define_singleton_method(mCurl, "kerberos4?", ruby_curl_kerberos4_q, 0);
   rb_define_singleton_method(mCurl, "ssl?", ruby_curl_ssl_q, 0);

data/ext/curb.h

@@ -1,7 +1,7 @@
 /* Curb - Libcurl(3) bindings for Ruby.
- * Copyright (c)2006 Ross Bamford. 
+ * Copyright (c)2006 Ross Bamford.
  * Licensed under the Ruby License. See LICENSE for details.
- * 
+ *
  * $Id: curb.h 39 2006-12-23 15:28:45Z roscopeco $
  */
 
@@ -20,17 +20,17 @@
 #include "curb_macros.h"
 
 // These should be managed from the Rake 'release' task.
-#define CURB_VERSION   "0.4.0.0"
-#define CURB_VER_NUM   400
+#define CURB_VERSION   "0.4.1.0"
+#define CURB_VER_NUM   410
 #define CURB_VER_MAJ   0
 #define CURB_VER_MIN   4
-#define CURB_VER_MIC   0
+#define CURB_VER_MIC   1
 #define CURB_VER_PATCH 0
 
 
 // Maybe not yet defined in Ruby
-#ifndef RSTRING_LEN 
-#define RSTRING_LEN(x) RSTRING(x)->len 
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(x) RSTRING(x)->len
 #endif
 #ifndef RSTRING_PTR
 #define RSTRING_PTR(x) RSTRING(x)->ptr
@@ -47,4 +47,3 @@ extern VALUE mCurl;
 extern void Init_curb_core();
 
 #endif
-

data/ext/curb_easy.c

@@ -1,12 +1,13 @@
 /* curb_easy.c - Curl easy mode
- * Copyright (c)2006 Ross Bamford. 
+ * Copyright (c)2006 Ross Bamford.
  * Licensed under the Ruby License. See LICENSE for details.
- * 
+ *
  * $Id: curb_easy.c 30 2006-12-09 12:30:24Z roscopeco $
  */
 #include "curb_easy.h"
 #include "curb_errors.h"
 #include "curb_postfield.h"
+#include "curb_upload.h"
 
 #include <errno.h>
 #include <string.h>
@@ -27,27 +28,63 @@ VALUE cCurlEasy;
 /* ================== CURL HANDLER FUNCS ==============*/
 
 /* These handle both body and header data */
-static size_t default_data_handler(char *stream, 
-                                   size_t size, 
-                                   size_t nmemb, 
+static size_t default_data_handler(char *stream,
+                                   size_t size,
+                                   size_t nmemb,
                                    VALUE out) {
   rb_str_buf_cat(out, stream, size * nmemb);
   return size * nmemb;
 }
-typedef struct _PutStream {
-  char *buffer;
-  size_t offset, len;
-} PutStream;
 
 // size_t function( void *ptr, size_t size, size_t nmemb, void *stream);
 static size_t read_data_handler(void *ptr,
-                                size_t size, 
-                                size_t nmemb, 
-                                void *stream) {
+                                size_t size,
+                                size_t nmemb,
+                                ruby_curl_easy *rbce) {
+  size_t read_bytes = (size*nmemb);
+  VALUE stream = ruby_curl_upload_stream_get(rbce->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 */
+    VALUE str = rb_funcall(stream, rb_intern("read"), 1, rb_int_new(read_bytes) );
+    if( str != Qnil ) {
+      memcpy(ptr, RSTRING_PTR(str), RSTRING_LEN(str));
+      return RSTRING_LEN(str);
+    }
+    else {
+      return 0;
+    }
+  }
+  else {
+    ruby_curl_upload *rbcu;
+    Data_Get_Struct(rbce->upload, ruby_curl_upload, rbcu);
+    VALUE str = rb_funcall(stream, rb_intern("to_s"), 0);
+    size_t len = RSTRING_LEN(str);
+    size_t remaining = len - rbcu->offset;
+    char *str_ptr = RSTRING_PTR(str);
+    if( remaining < read_bytes ) {
+      if( remaining > 0 ) {
+        memcpy(ptr, str_ptr+rbcu->offset, remaining);
+        read_bytes = remaining;
+        rbcu->offset += remaining;
+      }
+      return remaining;
+    }
+    else if( remaining > read_bytes ) { // read_bytes <= remaining - send what we can fit in the buffer(ptr)
+      memcpy(ptr, str_ptr+rbcu->offset, read_bytes);
+      rbcu->offset += read_bytes;
+    }
+    else { // they're equal
+      memcpy(ptr, str_ptr+rbcu->offset, --read_bytes);
+      rbcu->offset += read_bytes;
+    }
+    return read_bytes;
+  }
 
-  PutStream *pstream = (PutStream*)stream;
-  size_t sent_bytes = (size * nmemb);
-  size_t remaining = pstream->len - pstream->offset;
+ // PutStream *pstream = (PutStream*)stream;
+ // size_t sent_bytes = (size * nmemb);
+ // size_t remaining = pstream->len - pstream->offset;
+ /*
 
   // amount remaining is less then the buffer to send  - can send it all
   if( remaining < sent_bytes ) {
@@ -66,20 +103,21 @@ static size_t read_data_handler(void *ptr,
   if (sent_bytes == 0) {
     free(pstream);
   }
+  */
 
   //printf("sent_bytes: %ld of %ld\n", sent_bytes, remaining);
-  return sent_bytes;
+  //return sent_bytes;
 }
 
-static size_t proc_data_handler(char *stream, 
-                                size_t size, 
-                                size_t nmemb, 
+static size_t proc_data_handler(char *stream,
+                                size_t size,
+                                size_t nmemb,
                                 VALUE proc) {
   VALUE procret;
-  
+
   procret = rb_funcall(proc, idCall, 1, rb_str_new(stream, size * nmemb));
-  
-  switch (rb_type(procret)) {    
+
+  switch (rb_type(procret)) {
     case T_FIXNUM:
       return FIX2LONG(procret);
     case T_BIGNUM:
@@ -96,22 +134,22 @@ static int proc_progress_handler(VALUE proc,
                                  double ultotal,
                                  double ulnow) {
   VALUE procret;
-  
-  procret = rb_funcall(proc, idCall, 4, rb_float_new(dltotal), 
-                                        rb_float_new(dlnow), 
+
+  procret = rb_funcall(proc, idCall, 4, rb_float_new(dltotal),
+                                        rb_float_new(dlnow),
                                         rb_float_new(ultotal),
                                         rb_float_new(ulnow));
 
   return(((procret == Qfalse) || (procret == Qnil)) ? -1 : 0);
-}                                  
+}
 
-static int proc_debug_handler(CURL *curl, 
+static int proc_debug_handler(CURL *curl,
                               curl_infotype type,
-                              char *data, 
-                              size_t data_len, 
+                              char *data,
+                              size_t data_len,
                               VALUE proc) {
   rb_funcall(proc, idCall, 2, INT2FIX(type), rb_str_new(data, data_len));
-  return 0;  
+  return 0;
 }
 
 /* ================== MARK/FREE FUNC ==================*/
@@ -126,7 +164,7 @@ void curl_easy_mark(ruby_curl_easy *rbce) {
   rb_gc_mark(rbce->debug_proc);
   rb_gc_mark(rbce->interface);
   rb_gc_mark(rbce->userpwd);
-  rb_gc_mark(rbce->proxypwd);  
+  rb_gc_mark(rbce->proxypwd);
   rb_gc_mark(rbce->headers);
   rb_gc_mark(rbce->cookies);
   rb_gc_mark(rbce->cookiefile);
@@ -144,6 +182,10 @@ void curl_easy_mark(ruby_curl_easy *rbce) {
   if( rbce->self != Qnil ) {
     rb_gc_mark(rbce->self);
   }
+
+  if( rbce->upload != Qnil ) {
+    rb_gc_mark(rbce->upload);
+  }
 }
 
 void curl_easy_free(ruby_curl_easy *rbce) {
@@ -162,7 +204,7 @@ void curl_easy_free(ruby_curl_easy *rbce) {
  *   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.
@@ -172,13 +214,13 @@ static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
   VALUE url, blk;
   VALUE new_curl;
 
-  rb_scan_args(argc, argv, "01&", &url, &blk);    
+  rb_scan_args(argc, argv, "01&", &url, &blk);
 
   ruby_curl_easy *rbce = ALLOC(ruby_curl_easy);
-  
-  /* handler */  
-  rbce->curl = curl_easy_init();  
-  
+
+  /* handler */
+  rbce->curl = curl_easy_init();
+
   /* assoc objects */
   rbce->url = url;
   rbce->proxy_url = Qnil;
@@ -200,15 +242,15 @@ static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
   rbce->success_proc = Qnil;
   rbce->failure_proc = Qnil;
   rbce->complete_proc = Qnil;
-  
+
   /* various-typed opts */
   rbce->local_port = 0;
   rbce->local_port_range = 0;
-  rbce->proxy_port = 0;      
-  rbce->proxy_type = -1; 
+  rbce->proxy_port = 0;
+  rbce->proxy_type = -1;
   rbce->http_auth_types = 0;
-  rbce->proxy_auth_types = 0; 
-  rbce->max_redirs = -1; 
+  rbce->proxy_auth_types = 0;
+  rbce->max_redirs = -1;
   rbce->timeout = 0;
   rbce->connect_timeout = 0;
   rbce->dns_cache_timeout = 60;
@@ -226,7 +268,7 @@ 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;
@@ -234,9 +276,10 @@ static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
   rbce->curl_headers = NULL;
 
   rbce->self = Qnil;
-  
-  new_curl = Data_Wrap_Struct(cCurlEasy, curl_easy_mark, curl_easy_free, rbce);
-  
+  rbce->upload = Qnil;
+
+  new_curl = Data_Wrap_Struct(klass, curl_easy_mark, curl_easy_free, rbce);
+
   if (blk != Qnil) {
     rb_funcall(blk, idCall, 1, new_curl);
   }
@@ -247,14 +290,14 @@ static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
     raise_curl_easy_error_exception(ecode);
   }
 
-  return new_curl;  
+  return new_curl;
 }
 
 /*
  * call-seq:
  *   easy.clone                                       => #&lt;easy clone&gt;
  *   easy.dup                                         => #&lt;easy clone&gt;
- * 
+ *
  * Clone this Curl::Easy instance, creating a new instance.
  * This method duplicates the underlying CURL* handle.
  */
@@ -262,12 +305,12 @@ static VALUE ruby_curl_easy_clone(VALUE self) {
   ruby_curl_easy *rbce, *newrbce;
 
   Data_Get_Struct(self, ruby_curl_easy, rbce);
-  
+
   newrbce = ALLOC(ruby_curl_easy);
-  memcpy(newrbce, rbce, sizeof(ruby_curl_easy));  
+  memcpy(newrbce, rbce, sizeof(ruby_curl_easy));
   newrbce->curl = curl_easy_duphandle(rbce->curl);
   newrbce->curl_headers = NULL;
-  
+
   return Data_Wrap_Struct(cCurlEasy, curl_easy_mark, curl_easy_free, newrbce);
 }
 
@@ -277,7 +320,7 @@ static VALUE ruby_curl_easy_clone(VALUE self) {
 /*
  * call-seq:
  *   easy.url = "http://some.url/"                    => "http://some.url/"
- * 
+ *
  * 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+.
@@ -289,9 +332,9 @@ static VALUE ruby_curl_easy_url_set(VALUE self, VALUE url) {
 /*
  * call-seq:
  *   easy.url                                         => "http://some.url/"
- * 
+ *
  * 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);
 }
@@ -299,26 +342,26 @@ static VALUE ruby_curl_easy_url_get(VALUE self) {
 /*
  * 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 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 
+ * 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 
+ *
+ * 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 
+ * 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.
- * 
- * 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 
+ *
+ * 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) {
@@ -328,9 +371,9 @@ static VALUE ruby_curl_easy_proxy_url_set(VALUE self, VALUE proxy_url) {
 /*
  * call-seq:
  *   easy.proxy_url                                   => "some.url"
- * 
+ *
  * 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);
 }
@@ -340,20 +383,20 @@ static VALUE ruby_curl_easy_proxy_url_get(VALUE self) {
  *   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
  * custom headers, or override standard headers used by libcurl. It defaults to a
- * Hash. 
- * 
+ * Hash.
+ *
  * For example to set a standard or custom header:
- * 
+ *
  *    easy.headers["MyHeader"] = "myval"
- * 
+ *
  * To remove a standard header (this is useful when removing libcurls default
  * 'Expect: 100-Continue' header when using HTTP form posts):
- * 
+ *
  *    easy.headers["Expect:"] = ''
- * 
+ *
  * Anything passed to libcurl as a header will be converted to a string during
  * the perform step.
  */
@@ -364,9 +407,9 @@ static VALUE ruby_curl_easy_headers_set(VALUE self, VALUE headers) {
 /*
  * call-seq:
  *   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);
 }
@@ -374,8 +417,8 @@ 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. 
+ *
+ * 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) {
@@ -385,10 +428,10 @@ static VALUE ruby_curl_easy_interface_set(VALUE self, VALUE interface) {
 /*
  * call-seq:
  *   easy.interface                                   => "interface"
- * 
- * Obtain the interface name that is used as the outgoing network interface. 
+ *
+ * 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);
 }
@@ -396,7 +439,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"
  */
@@ -407,10 +450,10 @@ static VALUE ruby_curl_easy_userpwd_set(VALUE self, VALUE userpwd) {
 /*
  * call-seq:
  *   easy.userpwd                                     => "pwd string"
- * 
- * Obtain the username/password string that will be used for subsequent 
+ *
+ * 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);
 }
@@ -418,9 +461,9 @@ 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 
+ *
+ * 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) {
@@ -430,11 +473,11 @@ static VALUE ruby_curl_easy_proxypwd_set(VALUE self, VALUE proxypwd) {
 /*
  * call-seq:
  *   easy.proxypwd                                    => "pwd string"
- * 
- * Obtain the username/password string that will be used for proxy 
- * connection during subsequent calls to +perform+. The supplied 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);
 }
@@ -445,8 +488,8 @@ static VALUE ruby_curl_easy_proxypwd_get(VALUE self) {
  *   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. 
+ * 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);
@@ -455,9 +498,9 @@ static VALUE ruby_curl_easy_cookies_set(VALUE self, VALUE cookies) {
 /*
  * call-seq:
  *   easy.cookies                                   => "name1=content1; name2=content2;"
- * 
- * Obtain the cookies for this Curl::Easy instance. 
- */ 
+ *
+ * Obtain the cookies for this Curl::Easy instance.
+ */
 static VALUE ruby_curl_easy_cookies_get(VALUE self) {
   CURB_OBJECT_GETTER(ruby_curl_easy, cookies);
 }
@@ -467,7 +510,7 @@ static VALUE ruby_curl_easy_cookies_get(VALUE self) {
  *   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.
  */
@@ -478,9 +521,9 @@ static VALUE ruby_curl_easy_cookiefile_set(VALUE self, VALUE cookiefile) {
 /*
  * call-seq:
  *   easy.cookiefile                                   => "cookies.txt"
- * 
- * Obtain the cookiefile file for this Curl::Easy instance. 
- */ 
+ *
+ * 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);
 }
@@ -488,10 +531,10 @@ 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.
  */
@@ -502,9 +545,9 @@ static VALUE ruby_curl_easy_cookiejar_set(VALUE self, VALUE cookiejar) {
 /*
  * call-seq:
  *   easy.cookiejar                                   => "cookiejar.file"
- * 
- * Obtain the cookiejar file to use for this Curl::Easy instance. 
- */ 
+ *
+ * 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);
 }
@@ -512,10 +555,10 @@ static VALUE ruby_curl_easy_cookiejar_get(VALUE self) {
 /*
  * call-seq:
  *   easy.cert = "cert.file"                          => ""
- * 
+ *
  * 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);
@@ -524,9 +567,9 @@ static VALUE ruby_curl_easy_cert_set(VALUE self, VALUE cert) {
 /*
  * call-seq:
  *   easy.cert                                        => "cert.file"
- * 
- * Obtain the cert file to use for this Curl::Easy instance. 
- */ 
+ *
+ * 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);
 }
@@ -534,20 +577,20 @@ static VALUE ruby_curl_easy_cert_get(VALUE self) {
 /*
  * call-seq:
  *   easy.encoding=                                     => "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);
 }
 /*
  * call-seq:
  *   easy.encoding                                     => "string"
- * 
+ *
  * Get the set encoding types
- * 
-*/ 
+ *
+*/
 static VALUE ruby_curl_easy_encoding_get(VALUE self) {
   CURB_OBJECT_GETTER(ruby_curl_easy, encoding);
 }
@@ -557,14 +600,14 @@ static VALUE ruby_curl_easy_encoding_get(VALUE self) {
 /*
  * call-seq:
  *   easy.local_port = fixnum or nil                  => fixnum or nil
- * 
- * Set the local port that will be used for the following +perform+ calls. 
- * 
- * Passing +nil+ will return to the default behaviour (no local port 
+ *
+ * Set the local port that will be used for the following +perform+ calls.
+ *
+ * Passing +nil+ will return to the default behaviour (no local port
  * preference).
- * 
+ *
  * This option is ignored if compiled against libcurl < 7.15.2.
- */ 
+ */
 static VALUE ruby_curl_easy_local_port_set(VALUE self, VALUE local_port) {
   CURB_IMMED_PORT_SETTER(ruby_curl_easy, local_port, "port");
 }
@@ -572,11 +615,11 @@ static VALUE ruby_curl_easy_local_port_set(VALUE self, VALUE local_port) {
 /*
  * call-seq:
  *   easy.local_port                                  => fixnum or nil
- * 
+ *
  * Obtain the local port that will be used for the following +perform+ calls.
- * 
+ *
  * This option is ignored if compiled against libcurl < 7.15.2.
- */ 
+ */
 static VALUE ruby_curl_easy_local_port_get(VALUE self) {
   CURB_IMMED_PORT_GETTER(ruby_curl_easy, local_port);
 }
@@ -584,17 +627,17 @@ static VALUE ruby_curl_easy_local_port_get(VALUE self) {
 /*
  * call-seq:
  *   easy.local_port_range = fixnum or nil            => fixnum or nil
- * 
- * Set the local port range that will be used for the following +perform+ 
- * calls. This is a number (between 0 and 65535) that determines how far 
+ *
+ * Set the local port range that will be used for the following +perform+
+ * calls. This is a number (between 0 and 65535) that determines how far
  * libcurl may deviate from the supplied +local_port+ in order to find
- * an available port. 
- * 
+ * an available port.
+ *
  * If you set +local_port+ it's also recommended that you set this, since
  * it is fairly likely that your specified port will be unavailable.
- * 
+ *
  * This option is ignored if compiled against libcurl < 7.15.2.
- */ 
+ */
 static VALUE ruby_curl_easy_local_port_range_set(VALUE self, VALUE local_port_range) {
   CURB_IMMED_PORT_SETTER(ruby_curl_easy, local_port_range, "port range");
 }
@@ -602,12 +645,12 @@ static VALUE ruby_curl_easy_local_port_range_set(VALUE self, VALUE local_port_ra
 /*
  * call-seq:
  *   easy.local_port_range                            => fixnum or nil
- * 
+ *
  * Obtain the local port range that will be used for the following +perform+
  * calls.
- * 
+ *
  * This option is ignored if compiled against libcurl < 7.15.2.
- */ 
+ */
 static VALUE ruby_curl_easy_local_port_range_get(VALUE self) {
   CURB_IMMED_PORT_GETTER(ruby_curl_easy, local_port_range);
 }
@@ -615,9 +658,9 @@ static VALUE ruby_curl_easy_local_port_range_get(VALUE self) {
 /*
  * call-seq:
  *   easy.proxy_port = fixnum or nil                  => fixnum or nil
- * 
- * Set the proxy port that will be used for the following +perform+ calls. 
- */ 
+ *
+ * Set the proxy port that will be used for the following +perform+ calls.
+ */
 static VALUE ruby_curl_easy_proxy_port_set(VALUE self, VALUE proxy_port) {
   CURB_IMMED_PORT_SETTER(ruby_curl_easy, proxy_port, "port");
 }
@@ -625,9 +668,9 @@ static VALUE ruby_curl_easy_proxy_port_set(VALUE self, VALUE proxy_port) {
 /*
  * call-seq:
  *   easy.proxy_port                                  => fixnum or nil
- * 
+ *
  * Obtain the proxy port that will be used for the following +perform+ calls.
- */ 
+ */
 static VALUE ruby_curl_easy_proxy_port_get(VALUE self) {
   CURB_IMMED_PORT_GETTER(ruby_curl_easy, proxy_port);
 }
@@ -635,10 +678,10 @@ static VALUE ruby_curl_easy_proxy_port_get(VALUE self) {
 /*
  * call-seq:
  *   easy.proxy_type = fixnum or nil                  => fixnum or nil
- * 
- * Set the proxy type that will be used for the following +perform+ calls. 
+ *
+ * Set the proxy type that will be used for the following +perform+ calls.
  * This should be one of the Curl::CURLPROXY constants.
- */ 
+ */
 static VALUE ruby_curl_easy_proxy_type_set(VALUE self, VALUE proxy_type) {
   CURB_IMMED_SETTER(ruby_curl_easy, proxy_type, -1);
 }
@@ -646,9 +689,9 @@ static VALUE ruby_curl_easy_proxy_type_set(VALUE self, VALUE proxy_type) {
 /*
  * call-seq:
  *   easy.proxy_type                                  => fixnum or nil
- * 
+ *
  * Obtain the proxy type that will be used for the following +perform+ calls.
- */ 
+ */
 static VALUE ruby_curl_easy_proxy_type_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, proxy_type, -1);
 }
@@ -656,11 +699,11 @@ static VALUE ruby_curl_easy_proxy_type_get(VALUE self) {
 /*
  * call-seq:
  *   easy.http_auth_types = fixnum or nil             => fixnum or nil
- * 
- * Set the HTTP authentication types that may be used for the following 
+ *
+ * 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);
 }
@@ -668,10 +711,10 @@ static VALUE ruby_curl_easy_http_auth_types_set(VALUE self, VALUE http_auth_type
 /*
  * call-seq:
  *   easy.http_auth_types                             => fixnum or nil
- * 
- * Obtain the HTTP authentication types that may be used for the following 
+ *
+ * Obtain the HTTP authentication types that may be used for the following
  * +perform+ calls.
- */ 
+ */
 static VALUE ruby_curl_easy_http_auth_types_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, http_auth_types, 0);
 }
@@ -679,11 +722,11 @@ static VALUE ruby_curl_easy_http_auth_types_get(VALUE self) {
 /*
  * call-seq:
  *   easy.proxy_auth_types = fixnum or nil            => fixnum or nil
- * 
- * Set the proxy authentication types that may be used for the following 
- * +perform+ calls. This is a bitmap made by ORing together the 
+ *
+ * Set the proxy 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_proxy_auth_types_set(VALUE self, VALUE proxy_auth_types) {
   CURB_IMMED_SETTER(ruby_curl_easy, proxy_auth_types, 0);
 }
@@ -691,10 +734,10 @@ static VALUE ruby_curl_easy_proxy_auth_types_set(VALUE self, VALUE proxy_auth_ty
 /*
  * call-seq:
  *   easy.proxy_auth_types                            => fixnum or nil
- * 
- * Obtain the proxy authentication types that may be used for the following 
+ *
+ * Obtain the proxy authentication types that may be used for the following
  * +perform+ calls.
- */ 
+ */
 static VALUE ruby_curl_easy_proxy_auth_types_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, proxy_auth_types, 0);
 }
@@ -702,14 +745,14 @@ static VALUE ruby_curl_easy_proxy_auth_types_get(VALUE self) {
 /*
  * call-seq:
  *   easy.max_redirects = fixnum or nil               => fixnum or nil
- * 
+ *
  * Set the maximum number of redirections to follow in the following +perform+
  * calls. Set to nil or -1 allow an infinite number (the default). Setting this
  * option only makes sense if +follow_location+ is also set true.
- * 
+ *
  * With libcurl >= 7.15.1, setting this to 0 will cause libcurl to refuse any
  * redirect.
- */ 
+ */
 static VALUE ruby_curl_easy_max_redirects_set(VALUE self, VALUE max_redirs) {
   CURB_IMMED_SETTER(ruby_curl_easy, max_redirs, -1);
 }
@@ -717,10 +760,10 @@ static VALUE ruby_curl_easy_max_redirects_set(VALUE self, VALUE max_redirs) {
 /*
  * call-seq:
  *   easy.max_redirects                               => fixnum or nil
- * 
- * Obtain the maximum number of redirections to follow in the following 
+ *
+ * Obtain the maximum number of redirections to follow in the following
  * +perform+ calls.
- */ 
+ */
 static VALUE ruby_curl_easy_max_redirects_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, max_redirs, -1);
 }
@@ -728,15 +771,15 @@ static VALUE ruby_curl_easy_max_redirects_get(VALUE self) {
 /*
  * call-seq:
  *   easy.timeout = fixnum or nil                     => fixnum or nil
- * 
- * Set the maximum time in seconds that you allow the libcurl transfer 
- * operation to take. Normally, name lookups can take a considerable time 
- * and limiting operations to less than a few minutes risk aborting 
+ *
+ * Set the maximum time in seconds that you allow the libcurl transfer
+ * operation to take. Normally, name lookups can take a considerable time
+ * and limiting operations to less than a few minutes risk aborting
  * perfectly normal operations.
- * 
- * Set to nil (or zero) to disable timeout (it will then only timeout 
+ *
+ * Set to nil (or zero) to disable timeout (it will then only timeout
  * on the system's internal timeouts).
- */ 
+ */
 static VALUE ruby_curl_easy_timeout_set(VALUE self, VALUE timeout) {
   CURB_IMMED_SETTER(ruby_curl_easy, timeout, 0);
 }
@@ -744,10 +787,10 @@ static VALUE ruby_curl_easy_timeout_set(VALUE self, VALUE timeout) {
 /*
  * call-seq:
  *   easy.timeout                                     => fixnum or nil
- * 
- * Obtain the maximum time in seconds that you allow the libcurl transfer 
+ *
+ * Obtain the maximum time in seconds that you allow the libcurl transfer
  * operation to take.
- */ 
+ */
 static VALUE ruby_curl_easy_timeout_get(VALUE self, VALUE timeout) {
   CURB_IMMED_GETTER(ruby_curl_easy, timeout, 0);
 }
@@ -755,14 +798,14 @@ static VALUE ruby_curl_easy_timeout_get(VALUE self, VALUE timeout) {
 /*
  * call-seq:
  *   easy.connect_timeout = fixnum or nil             => fixnum or nil
- * 
+ *
  * Set the maximum time in seconds that you allow the connection to the
- * server to take. This only limits the connection phase, once it has 
- * connected, this option is of no more use. 
- * 
+ * server to take. This only limits the connection phase, once it has
+ * connected, this option is of no more use.
+ *
  * Set to nil (or zero) to disable connection timeout (it will then only
  * timeout on the system's internal timeouts).
- */ 
+ */
 static VALUE ruby_curl_easy_connect_timeout_set(VALUE self, VALUE connect_timeout) {
   CURB_IMMED_SETTER(ruby_curl_easy, connect_timeout, 0);
 }
@@ -770,10 +813,10 @@ static VALUE ruby_curl_easy_connect_timeout_set(VALUE self, VALUE connect_timeou
 /*
  * call-seq:
  *   easy.connect_timeout                             => fixnum or nil
- * 
+ *
  * Obtain the maximum time in seconds that you allow the connection to the
  * server to take.
- */ 
+ */
 static VALUE ruby_curl_easy_connect_timeout_get(VALUE self, VALUE connect_timeout) {
   CURB_IMMED_GETTER(ruby_curl_easy, connect_timeout, 0);
 }
@@ -781,12 +824,12 @@ static VALUE ruby_curl_easy_connect_timeout_get(VALUE self, VALUE connect_timeou
 /*
  * call-seq:
  *   easy.dns_cache_timeout = fixnum or nil           => fixnum or nil
- * 
- * Set the dns cache timeout in seconds. Name resolves will be kept in 
- * memory for this number of seconds. Set to zero (0) to completely disable 
+ *
+ * Set the dns cache timeout in seconds. Name resolves will be kept in
+ * memory for this number of seconds. Set to zero (0) to completely disable
  * caching, or set to nil (or -1) to make the cached entries remain forever.
  * By default, libcurl caches this info for 60 seconds.
- */ 
+ */
 static VALUE ruby_curl_easy_dns_cache_timeout_set(VALUE self, VALUE dns_cache_timeout) {
   CURB_IMMED_SETTER(ruby_curl_easy, dns_cache_timeout, -1);
 }
@@ -794,26 +837,26 @@ static VALUE ruby_curl_easy_dns_cache_timeout_set(VALUE self, VALUE dns_cache_ti
 /*
  * call-seq:
  *   easy.dns_cache_timeout                           => fixnum or nil
- * 
+ *
  * Obtain the dns cache timeout in seconds.
- */ 
+ */
 static VALUE ruby_curl_easy_dns_cache_timeout_get(VALUE self, VALUE dns_cache_timeout) {
-  CURB_IMMED_GETTER(ruby_curl_easy, dns_cache_timeout, -1);  
+  CURB_IMMED_GETTER(ruby_curl_easy, dns_cache_timeout, -1);
 }
 
 /*
  * call-seq:
  *   easy.ftp_response_timeout = fixnum or nil        => fixnum or nil
- * 
- * Set a timeout period (in seconds) on the amount of time that the server 
- * is allowed to take in order to generate a response message for a command 
- * before the session is considered hung. While curl is waiting for a 
+ *
+ * Set a timeout period (in seconds) on the amount of time that the server
+ * is allowed to take in order to generate a response message for a command
+ * before the session is considered hung. While curl is waiting for a
  * response, this value overrides +timeout+. It is recommended that if used
- * in conjunction with +timeout+, you set +ftp_response_timeout+ to a value 
- * smaller than +timeout+. 
- * 
+ * in conjunction with +timeout+, you set +ftp_response_timeout+ to a value
+ * smaller than +timeout+.
+ *
  * Ignored if libcurl version is < 7.10.8.
- */ 
+ */
 static VALUE ruby_curl_easy_ftp_response_timeout_set(VALUE self, VALUE ftp_response_timeout) {
   CURB_IMMED_SETTER(ruby_curl_easy, ftp_response_timeout, 0);
 }
@@ -821,11 +864,11 @@ static VALUE ruby_curl_easy_ftp_response_timeout_set(VALUE self, VALUE ftp_respo
 /*
  * call-seq:
  *   easy.ftp_response_timeout                        => fixnum or nil
- * 
+ *
  * Obtain the maximum time that libcurl will wait for FTP command responses.
- */ 
+ */
 static VALUE ruby_curl_easy_ftp_response_timeout_get(VALUE self, VALUE ftp_response_timeout) {
-  CURB_IMMED_GETTER(ruby_curl_easy, ftp_response_timeout, 0);  
+  CURB_IMMED_GETTER(ruby_curl_easy, ftp_response_timeout, 0);
 }
 
 /* ================== BOOL ATTRS ===================*/
@@ -833,7 +876,7 @@ static VALUE ruby_curl_easy_ftp_response_timeout_get(VALUE self, VALUE ftp_respo
 /*
  * call-seq:
  *   proxy_tunnel = boolean                           => boolean
- * 
+ *
  * Configure whether this Curl instance will use proxy tunneling.
  */
 static VALUE ruby_curl_easy_proxy_tunnel_set(VALUE self, VALUE proxy_tunnel) {
@@ -843,7 +886,7 @@ static VALUE ruby_curl_easy_proxy_tunnel_set(VALUE self, VALUE proxy_tunnel) {
 /*
  * call-seq:
  *   proxy_tunnel?                                    => boolean
- * 
+ *
  * Determine whether this Curl instance will use proxy tunneling.
  */
 static VALUE ruby_curl_easy_proxy_tunnel_q(VALUE self) {
@@ -853,7 +896,7 @@ static VALUE ruby_curl_easy_proxy_tunnel_q(VALUE self) {
 /*
  * call-seq:
  *   fetch_file_time = boolean                        => boolean
- * 
+ *
  * Configure whether this Curl instance will fetch remote file
  * times, if available.
  */
@@ -864,7 +907,7 @@ static VALUE ruby_curl_easy_fetch_file_time_set(VALUE self, VALUE fetch_file_tim
 /*
  * call-seq:
  *   fetch_file_time?                                 => boolean
- * 
+ *
  * Determine whether this Curl instance will fetch remote file
  * times, if available.
  */
@@ -875,15 +918,15 @@ static VALUE ruby_curl_easy_fetch_file_time_q(VALUE self) {
 /*
  * call-seq:
  *   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 
- * prove that the certificate is authentic, the connection fails. When 
+ * certificate. When true (the default), and the verification fails to
+ * prove that the certificate is authentic, the connection fails. When
  * false, the connection succeeds regardless.
- * 
- * Authenticating the certificate is not by itself very useful. You 
- * typically want to ensure that the server, as authentically identified 
- * by its certificate, is the server you mean to be talking to. 
+ *
+ * Authenticating the certificate is not by itself very useful. You
+ * typically want to ensure that the server, as authentically identified
+ * by its certificate, is the server you mean to be talking to.
  * The ssl_verify_host? options controls that.
  */
 static VALUE ruby_curl_easy_ssl_verify_peer_set(VALUE self, VALUE ssl_verify_peer) {
@@ -893,7 +936,7 @@ static VALUE ruby_curl_easy_ssl_verify_peer_set(VALUE self, VALUE ssl_verify_pee
 /*
  * call-seq:
  *   ssl_verify_peer?                                 => boolean
- * 
+ *
  * Determine whether this Curl instance will verify the SSL peer
  * certificate.
  */
@@ -904,14 +947,14 @@ static VALUE ruby_curl_easy_ssl_verify_peer_q(VALUE self) {
 /*
  * call-seq:
  *   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 
- * certificate must indicate that the server is the server to which you 
+ *
+ * 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
+ * certificate must indicate that the server is the server to which you
  * meant to connect, or the connection fails. When false, the connection
  * will succeed regardless of the names in the certificate.
- * 
- * this option controls is of the identity that the server claims. 
+ *
+ * this option controls is of the identity that the server claims.
  * 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) {
@@ -921,8 +964,8 @@ static VALUE ruby_curl_easy_ssl_verify_host_set(VALUE self, VALUE ssl_verify_hos
 /*
  * call-seq:
  *   ssl_verify_host?                                 => boolean
- * 
- * Determine whether this Curl instance will verify that the server cert 
+ *
+ * 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) {
@@ -932,8 +975,8 @@ static VALUE ruby_curl_easy_ssl_verify_host_q(VALUE self) {
 /*
  * call-seq:
  *   header_in_body = boolean                         => boolean
- * 
- * Configure whether this Curl instance will return HTTP headers 
+ *
+ * Configure whether this Curl instance will return HTTP headers
  * combined with body data. If this option is set true, both header
  * and body data will go to +body_str+ (or the configured +on_body+ handler).
  */
@@ -944,7 +987,7 @@ static VALUE ruby_curl_easy_header_in_body_set(VALUE self, VALUE header_in_body)
 /*
  * call-seq:
  *   header_in_body?                                  => boolean
- * 
+ *
  * Determine whether this Curl instance will verify the SSL peer
  * certificate.
  */
@@ -955,7 +998,7 @@ static VALUE ruby_curl_easy_header_in_body_q(VALUE self) {
 /*
  * call-seq:
  *   use_netrc = boolean                              => boolean
- * 
+ *
  * Configure whether this Curl instance will use data from the user's
  * .netrc file for FTP connections.
  */
@@ -966,7 +1009,7 @@ static VALUE ruby_curl_easy_use_netrc_set(VALUE self, VALUE use_netrc) {
 /*
  * call-seq:
  *   use_netrc?                                       => boolean
- * 
+ *
  * Determine whether this Curl instance will use data from the user's
  * .netrc file for FTP connections.
  */
@@ -977,7 +1020,7 @@ 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+.
@@ -989,7 +1032,7 @@ static VALUE ruby_curl_easy_follow_location_set(VALUE self, VALUE follow_locatio
 /*
  * call-seq:
  *   follow_location?                                 => boolean
- * 
+ *
  * Determine whether this Curl instance will follow Location: headers
  * in HTTP responses.
  */
@@ -1000,7 +1043,7 @@ static VALUE ruby_curl_easy_follow_location_q(VALUE self) {
 /*
  * call-seq:
  *   unrestricted_auth = boolean                      => boolean
- * 
+ *
  * Configure whether this Curl instance may use any HTTP authentication
  * method available when necessary.
  */
@@ -1011,7 +1054,7 @@ static VALUE ruby_curl_easy_unrestricted_auth_set(VALUE self, VALUE unrestricted
 /*
  * call-seq:
  *   unrestricted_auth?                               => boolean
- * 
+ *
  * Determine whether this Curl instance may use any HTTP authentication
  * method available when necessary.
  */
@@ -1022,7 +1065,7 @@ static VALUE ruby_curl_easy_unrestricted_auth_q(VALUE self) {
 /*
  * call-seq:
  *   easy.verbose = boolean                           => boolean
- * 
+ *
  * Configure whether this Curl instance gives verbose output to STDERR
  * during transfers. Ignored if this instance has an on_debug handler.
  */
@@ -1033,7 +1076,7 @@ static VALUE ruby_curl_easy_verbose_set(VALUE self, VALUE verbose) {
 /*
  * call-seq:
  *   easy.verbose?                                    => boolean
- * 
+ *
  * Determine whether this Curl instance gives verbose output to STDERR
  * during transfers.
  */
@@ -1044,12 +1087,12 @@ static VALUE ruby_curl_easy_verbose_q(VALUE self) {
 /*
  * call-seq:
  *   easy.multipart_form_post = boolean               => boolean
- * 
- * Configure whether this Curl instance uses multipart/formdata content 
+ *
+ * Configure whether this Curl instance uses multipart/formdata content
  * type for HTTP POST requests. If this is false (the default), then the
- * application/x-www-form-urlencoded content type is used for the form 
- * data. 
- * 
+ * application/x-www-form-urlencoded content type is used for the form
+ * data.
+ *
  * If this is set true, you must pass one or more PostField instances
  * to the http_post method - no support for posting multipart forms from
  * a string is provided.
@@ -1062,8 +1105,8 @@ static VALUE ruby_curl_easy_multipart_form_post_set(VALUE self, VALUE multipart_
 /*
  * call-seq:
  *   easy.multipart_form_post?                        => boolean
- * 
- * Determine whether this Curl instance uses multipart/formdata content 
+ *
+ * Determine whether this Curl instance uses multipart/formdata content
  * type for HTTP POST requests.
  */
 static VALUE ruby_curl_easy_multipart_form_post_q(VALUE self) {
@@ -1073,7 +1116,7 @@ static VALUE ruby_curl_easy_multipart_form_post_q(VALUE self) {
 /*
  * call-seq:
  *   easy.enable_cookies = boolean                    => boolean
- * 
+ *
  * Configure whether the libcurl cookie engine is enabled for this Curl::Easy
  * instance.
  */
@@ -1085,8 +1128,8 @@ static VALUE ruby_curl_easy_enable_cookies_set(VALUE self, VALUE enable_cookies)
 /*
  * call-seq:
  *   easy.enable_cookies?                        => boolean
- * 
- * Determine whether the libcurl cookie engine is enabled for this 
+ *
+ * Determine whether the libcurl cookie engine is enabled for this
  * Curl::Easy instance.
  */
 static VALUE ruby_curl_easy_enable_cookies_q(VALUE self) {
@@ -1098,14 +1141,14 @@ static VALUE ruby_curl_easy_enable_cookies_q(VALUE self) {
 /*
  * call-seq:
  *   easy.on_body { |body_data| ... }                 => &lt;old handler&gt;
- * 
+ *
  * Assign or remove the +on_body+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
  * attached block.
- * 
+ *
  * The +on_body+ handler is called for each chunk of response body passed back
  * by libcurl during +perform+. It should perform any processing necessary,
- * and return the actual number of bytes handled. Normally, this will 
+ * and return the actual number of bytes handled. Normally, this will
  * equal the length of the data string, and CURL will continue processing.
  * If the returned length does not equal the input length, CURL will abort
  * the processing with a Curl::Err::AbortedByCallbackError.
@@ -1117,11 +1160,11 @@ static VALUE ruby_curl_easy_on_body_set(int argc, VALUE *argv, VALUE self) {
 /*
  * call-seq:
  *   easy.on_success { ... }                 => &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
  * attached block.
- * 
+ *
  * The +on_success+ handler is called when the request is finished with a
  * status of 20x
  */
@@ -1132,11 +1175,11 @@ static VALUE ruby_curl_easy_on_success_set(int argc, VALUE *argv, VALUE self) {
 /*
  * call-seq:
  *   easy.on_failure { ... }                 => &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
  * attached block.
- * 
+ *
  * The +on_failure+ handler is called when the request is finished with a
  * status of 50x
  */
@@ -1147,11 +1190,11 @@ static VALUE ruby_curl_easy_on_failure_set(int argc, VALUE *argv, VALUE self) {
 /*
  * call-seq:
  *   easy.on_complete { ... }                 => &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
  * attached block.
- * 
+ *
  * 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) {
@@ -1161,12 +1204,12 @@ static VALUE ruby_curl_easy_on_complete_set(int argc, VALUE *argv, VALUE self) {
 /*
  * call-seq:
  *   easy.on_header { |header_data| ... }             => &lt;old handler&gt;
- * 
+ *
  * Assign or remove the +on_header+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
  * attached block.
- * 
- * The +on_header+ handler is called for each chunk of response header passed 
+ *
+ * The +on_header+ handler is called for each chunk of response header passed
  * back by libcurl during +perform+. The semantics are the same as for the
  * block supplied to +on_body+.
  */
@@ -1177,16 +1220,16 @@ static VALUE ruby_curl_easy_on_header_set(int argc, VALUE *argv, VALUE self) {
 /*
  * call-seq:
  *   easy.on_progress { |dl_total, dl_now, ul_total, ul_now| ... } => &lt;old handler&gt;
- * 
+ *
  * Assign or remove the +on_progress+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
  * attached block.
- * 
+ *
  * The +on_progress+ handler is called regularly by libcurl (approximately once
  * per second) during transfers to allow the application to receive progress
  * information. There is no guarantee that the reported progress will change
  * between calls.
- * 
+ *
  * The result of the block call determines whether libcurl continues the transfer.
  * Returning a non-true value (i.e. nil or false) will cause the transfer to abort,
  * throwing a Curl::Err::AbortedByCallbackError.
@@ -1198,16 +1241,16 @@ static VALUE ruby_curl_easy_on_progress_set(int argc, VALUE *argv, VALUE self) {
 /*
  * call-seq:
  *   easy.on_debug { |type, data| ... }               => &lt;old handler&gt;
- * 
+ *
  * Assign or remove the +on_debug+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
  * attached block.
- * 
+ *
  * The +on_debug+ handler, if configured, will receive detailed information
  * from libcurl during the perform call. This can be useful for debugging.
  * Setting a debug handler overrides libcurl's internal handler, disabling
  * any output from +verbose+, if set.
- * 
+ *
  * The type argument will match one of the Curl::Easy::CURLINFO_XXXX
  * constants, and specifies the kind of information contained in the
  * data. The data is passed as a String.
@@ -1224,16 +1267,16 @@ static VALUE ruby_curl_easy_on_debug_set(int argc, VALUE *argv, VALUE self) {
  */
 static VALUE cb_each_http_header(VALUE header, struct curl_slist **list) {
   VALUE header_str = Qnil;
-  
+
   //rb_p(header);
-  
+
   if (rb_type(header) == T_ARRAY) {
     // we're processing a hash, header is [name, val]
     VALUE name, value;
-    
+
     name = rb_obj_as_string(rb_ary_entry(header, 0));
     value = rb_obj_as_string(rb_ary_entry(header, 1));
-    
+
     // This is a bit inefficient, but we don't want to be modifying
     // the actual values in the original hash.
     header_str = rb_str_plus(name, rb_str_new2(": "));
@@ -1241,11 +1284,11 @@ static VALUE cb_each_http_header(VALUE header, struct curl_slist **list) {
   } else {
     header_str = rb_obj_as_string(header);
   }
-  
+
   //rb_p(header_str);
-  
+
   *list = curl_slist_append(*list, StringValuePtr(header_str));
-  return header_str;  
+  return header_str;
 }
 
 /***********************************************
@@ -1259,8 +1302,8 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
   CURL *curl;
 
   curl = rbce->curl;
-  
-  if (rbce->url == Qnil) {  
+
+  if (rbce->url == Qnil) {
     rb_raise(eCurlErrError, "No URL supplied");
   }
 
@@ -1268,35 +1311,35 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
 
   // 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 != Qnil) {
     curl_easy_setopt(curl, CURLOPT_INTERFACE, StringValuePtr(rbce->interface));
   } else {
     curl_easy_setopt(curl, CURLOPT_INTERFACE, NULL);
-  }      
-  
+  }
+
   if (rbce->userpwd != Qnil) {
     curl_easy_setopt(curl, CURLOPT_USERPWD, StringValuePtr(rbce->userpwd));
   } else {
     curl_easy_setopt(curl, CURLOPT_USERPWD, NULL);
-  }      
-  
+  }
+
   if (rbce->proxy_url != Qnil) {
     curl_easy_setopt(curl, CURLOPT_PROXY, StringValuePtr(rbce->proxy_url));
   } else {
     curl_easy_setopt(curl, CURLOPT_PROXY, NULL);
-  }      
-  
+  }
+
   if (rbce->proxypwd != Qnil) {
     curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, StringValuePtr(rbce->proxypwd));
   } else {
     curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, NULL);
-  }      
-  
+  }
+
   // body/header procs
-  if (rbce->body_proc != Qnil) {      
-    *body_buffer = Qnil;      
+  if (rbce->body_proc != Qnil) {
+    *body_buffer = Qnil;
     curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)&proc_data_handler);
     curl_easy_setopt(curl, CURLOPT_WRITEDATA, rbce->body_proc);
   } else {
@@ -1304,23 +1347,23 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
     curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)&default_data_handler);
     curl_easy_setopt(curl, CURLOPT_WRITEDATA, *body_buffer);
   }
-      
+
   if (rbce->header_proc != Qnil) {
-    *header_buffer = Qnil;      
+    *header_buffer = Qnil;
     curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, (curl_write_callback)&proc_data_handler);
     curl_easy_setopt(curl, CURLOPT_HEADERDATA, rbce->header_proc);
   } else {
-    *header_buffer = rb_str_buf_new(32768);      
+    *header_buffer = rb_str_buf_new(32768);
     curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, (curl_write_callback)&default_data_handler);
     curl_easy_setopt(curl, CURLOPT_HEADERDATA, *header_buffer);
   }
 
   /* encoding */
   if (rbce->encoding != Qnil) {
-    curl_easy_setopt(curl, CURLOPT_ENCODING, StringValuePtr(rbce->encoding)); 
+    curl_easy_setopt(curl, CURLOPT_ENCODING, StringValuePtr(rbce->encoding));
   }
 
-  // progress and debug procs    
+  // progress and debug procs
   if (rbce->progress_proc != Qnil) {
     curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, (curl_progress_callback)&proc_progress_handler);
     curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, rbce->progress_proc);
@@ -1328,7 +1371,7 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
   } else {
     curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1);
   }
-  
+
   if (rbce->debug_proc != Qnil) {
     curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, (curl_debug_callback)&proc_debug_handler);
     curl_easy_setopt(curl, CURLOPT_DEBUGDATA, rbce->debug_proc);
@@ -1338,10 +1381,10 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
     curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, NULL);
     curl_easy_setopt(curl, CURLOPT_DEBUGDATA, NULL);
     curl_easy_setopt(curl, CURLOPT_VERBOSE, rbce->verbose);
-  }    
-  
+  }
+
   /* general opts */
-  
+
   curl_easy_setopt(curl, CURLOPT_HEADER, rbce->header_in_body);
 
   curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, rbce->follow_location);
@@ -1351,15 +1394,15 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
   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);
-          
+
   if ((rbce->use_netrc != Qnil) && (rbce->use_netrc != Qfalse)) {
     curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, CURL_NETRC_OPTIONAL);
   } else {
     curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, CURL_NETRC_IGNORED);
-  }      
+  }
 
   curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, rbce->unrestricted_auth);
-  
+
   curl_easy_setopt(curl, CURLOPT_TIMEOUT, rbce->timeout);
   curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, rbce->connect_timeout);
   curl_easy_setopt(curl, CURLOPT_DNS_CACHE_TIMEOUT, rbce->dns_cache_timeout);
@@ -1371,25 +1414,25 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
     rb_warn("Installed libcurl is too old to support ftp_response_timeout");
   }
 #endif
-  
+
   // Set up localport / proxy port
   // FIXME these won't get returned to default if they're unset Ruby
   if (rbce->proxy_port > 0) {
-    curl_easy_setopt(curl, CURLOPT_PROXYPORT, rbce->proxy_port);      
+    curl_easy_setopt(curl, CURLOPT_PROXYPORT, rbce->proxy_port);
   }
-  
+
   if (rbce->local_port > 0) {
 #if LIBCURL_VERSION_NUM >= 0x070f02
     curl_easy_setopt(curl, CURLOPT_LOCALPORT, rbce->local_port);
-    
+
     if (rbce->local_port_range > 0) {
       curl_easy_setopt(curl, CURLOPT_LOCALPORTRANGE, rbce->local_port_range);
     }
 #else
     rb_warn("Installed libcurl is too old to support local_port");
-#endif   
-  }    
-  
+#endif
+  }
+
   if (rbce->proxy_type != -1) {
 #if LIBCURL_VERSION_NUM >= 0x070a00
     if (rbce->proxy_type == -2) {
@@ -1400,8 +1443,8 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
   } else {
     curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
 #else
-    rb_warn("Installed libcurl is too old to support proxy_type");      
-#endif      
+    rb_warn("Installed libcurl is too old to support proxy_type");
+#endif
   }
 
   if (rbce->http_auth_types > 0) {
@@ -1410,8 +1453,8 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
   } else {
     curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
 #else
-    rb_warn("Installed libcurl is too old to support http_auth_types");      
-#endif      
+    rb_warn("Installed libcurl is too old to support http_auth_types");
+#endif
   }
 
   if (rbce->proxy_auth_types > 0) {
@@ -1420,10 +1463,10 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
   } else {
     curl_easy_setopt(curl, CURLOPT_PROXYAUTH, CURLAUTH_ANY);
 #else
-    rb_warn("Installed libcurl is too old to support proxy_auth_types");      
-#endif      
+    rb_warn("Installed libcurl is too old to support proxy_auth_types");
+#endif
   }
-  
+
   /* Set up HTTP cookie handling if necessary
      FIXME this may not get disabled if it's enabled, the disabled again from ruby.
      */
@@ -1448,18 +1491,18 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
     curl_easy_setopt(curl, CURLOPT_SSLCERT, StringValuePtr(rbce->cert));
     curl_easy_setopt(curl, CURLOPT_CAINFO, "/usr/local/share/curl/curl-ca-bundle.crt");
   }
-  
+
   /* 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 (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);        
+      rb_iterate(rb_each, rbce->headers, cb_each_http_header, (VALUE)hdrs);
     } else {
       VALUE headers_str = rb_obj_as_string(rbce->headers);
       *hdrs = curl_slist_append(*hdrs, StringValuePtr(headers_str));
     }
-    
+
     if (*hdrs) {
       curl_easy_setopt(curl, CURLOPT_HTTPHEADER, *hdrs);
     }
@@ -1480,7 +1523,7 @@ VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce, VALUE bodybuf, V
     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) {
@@ -1514,16 +1557,16 @@ VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce, VALUE bodybuf, V
 }
 
 /***********************************************
- * 
+ *
  * 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) {  
+static VALUE handle_perform(VALUE self, ruby_curl_easy *rbce) {
 
   int msgs;
   int still_running = 1;
@@ -1532,6 +1575,10 @@ static VALUE handle_perform(VALUE self, ruby_curl_easy *rbce) {
   CURLM *multi_handle = curl_multi_init();
   struct curl_slist *headers = NULL;
   VALUE bodybuf = Qnil, headerbuf = Qnil;
+  long timeout;
+  struct timeval tv = {0, 0};
+  int rc; /* select() return code */
+  int maxfd;
 //  char errors[CURL_ERROR_SIZE*2];
 
   ruby_curl_easy_setup(rbce, &bodybuf, &headerbuf, &headers);
@@ -1544,7 +1591,7 @@ static VALUE handle_perform(VALUE self, ruby_curl_easy *rbce) {
 //  else {
 
     /* NOTE:
-     * We create an Curl multi handle here and use rb_thread_select allowing other ruby threads to 
+     * We create an Curl multi handle here and use rb_thread_select allowing other ruby threads to
      * perform actions... ideally we'd have just 1 shared multi handle per all curl easy handles globally
      */
     mcode = curl_multi_add_handle(multi_handle, rbce->curl);
@@ -1558,10 +1605,8 @@ static VALUE handle_perform(VALUE self, ruby_curl_easy *rbce) {
       raise_curl_multi_error_exception(mcode);
     }
 
+
     while(still_running) {
-      struct timeval timeout;
-      int rc; /* select() return code */
-      int maxfd;
 
       fd_set fdread;
       fd_set fdwrite;
@@ -1578,14 +1623,33 @@ static VALUE handle_perform(VALUE self, ruby_curl_easy *rbce) {
         raise_curl_multi_error_exception(mcode);
       }
 
+#ifdef HAVE_CURL_MULTI_TIMEOUT
+      /* get the curl suggested time out */
+      mcode = curl_multi_timeout(multi_handle, &timeout);
+      if (mcode != CURLM_OK) {
+        raise_curl_multi_error_exception(mcode);
+      }
+#else
+      /* libcurl doesn't have a timeout method defined... make a wild guess */
+      timeout = 1; /* wait a second */
+#endif
+
+      if (timeout == 0) { /* no delay */
+        while(CURLM_CALL_MULTI_PERFORM == (mcode=curl_multi_perform(multi_handle, &still_running)) );
+        continue;
+      }
+      else if (timeout == -1) {
+        timeout = 1; /* wait a second */
+      }
+
       /* set a suitable timeout to play around with - ruby seems to be greedy about this and won't necessarily yield so the timeout is small.. */
-      timeout.tv_sec = 0.0;
-      timeout.tv_usec = 100000.0;
-      rc = rb_thread_select(maxfd+1, &fdread, &fdwrite, &fdexcep, &timeout);
+      tv.tv_sec = timeout / 1000;
+      tv.tv_usec = (timeout * 1000) % 1000000;
+      rc = rb_thread_select(maxfd+1, &fdread, &fdwrite, &fdexcep, &tv);
       if (rc < 0) {
         rb_raise(rb_eRuntimeError, "select(): %s", strerror(errno));
       }
-   
+
       if( rc >= 0 ) {
         switch(rc) {
         case 0:
@@ -1600,13 +1664,13 @@ static VALUE handle_perform(VALUE self, ruby_curl_easy *rbce) {
       else {
         // error
       }
-   
+
       if (mcode != CURLM_CALL_MULTI_PERFORM && mcode != CURLM_OK) {
         raise_curl_multi_error_exception(mcode);
       }
 
     }
- 
+
     /* check for errors */
     CURLMsg *msg = curl_multi_info_read(multi_handle, &msgs);
     if (msg && msg->msg == CURLMSG_DONE) {
@@ -1618,7 +1682,7 @@ static VALUE handle_perform(VALUE self, ruby_curl_easy *rbce) {
 //  }
 
   ruby_curl_easy_cleanup(self, rbce, bodybuf, headerbuf, headers);
-  
+
   if (rbce->complete_proc != Qnil) {
     rb_funcall( rbce->complete_proc, idCall, 1, self );
   }
@@ -1639,7 +1703,7 @@ static VALUE handle_perform(VALUE self, ruby_curl_easy *rbce) {
            ((response_code >= 200 && response_code < 300) || response_code == 0)) {
     rb_funcall( rbce->success_proc, idCall, 1, self );
   }
-  else if (rbce->failure_proc != Qnil && 
+  else if (rbce->failure_proc != Qnil &&
            (response_code >= 300 && response_code <= 999)) {
     rb_funcall( rbce->failure_proc, idCall, 2, rbce->self, INT2FIX(result) );
   }
@@ -1650,20 +1714,20 @@ static VALUE handle_perform(VALUE self, ruby_curl_easy *rbce) {
 /*
  * 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) {  
+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);
 }
 
@@ -1681,7 +1745,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");
 
   VALUE retval = handle_perform(self,rbce);
@@ -1694,16 +1758,16 @@ static VALUE ruby_curl_easy_perform_delete(VALUE self) {
 /*
  * call-seq:
  *   easy.perform                                     => true
- * 
+ *
  * 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.
  */
-static VALUE ruby_curl_easy_perform(VALUE self) {  
+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);
 }
 
@@ -1713,37 +1777,37 @@ static VALUE ruby_curl_easy_perform(VALUE self) {
  *   easy.http_post("url=encoded%20form%20data", "and=so%20on", ...) => true
  *   easy.http_post("url=encoded%20form%20data", Curl::PostField, "and=so%20on", ...) => true
  *   easy.http_post(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 
+ *
+ * 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.
- * 
+ *
  * The Content-type of the POST is determined by the current setting
  * of multipart_form_post? , according to the following rules:
- * * When false (the default): the form will be POSTed with a 
+ * * When false (the default): the form will be POSTed with a
  *   content-type of 'application/x-www-form-urlencoded', and any of the
- *   four calling forms may be used. 
- * * When true: the form will be POSTed with a content-type of 
- *   'multipart/formdata'. Only the last calling form may be used, 
+ *   four calling forms may be used.
+ * * When true: the form will be POSTed with a content-type of
+ *   'multipart/formdata'. Only the last calling form may be used,
  *   i.e. only PostField instances may be POSTed. In this mode,
  *   individual fields' content-types are recognised, and file upload
  *   fields are supported.
- * 
+ *
  */
-static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {  
+static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
   ruby_curl_easy *rbce;
   CURL *curl;
   int i;
   VALUE args_ary;
-  
+
   rb_scan_args(argc, argv, "*", &args_ary);
-  
+
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl = curl_easy_duphandle(rbce->curl);
   curl_easy_cleanup(rbce->curl);
   rbce->curl = curl;
-  
+
   if (rbce->multipart_form_post) {
     VALUE ret;
     struct curl_httppost *first = NULL, *last = NULL;
@@ -1759,22 +1823,22 @@ 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);    
+    curl_easy_setopt(curl, CURLOPT_HTTPPOST, first);
+    ret = handle_perform(self,rbce);
     curl_formfree(first);
-    
-    return ret;    
+
+    return ret;
   } else {
     long len;
     char *data;
-    
+
     if ((rbce->postdata_buffer = rb_funcall(args_ary, idJoin, 1, rbstrAmp)) == Qnil) {
       rb_raise(eCurlErrError, "Failed to join arguments");
       return Qnil;
-    } else { 
-      data = StringValuePtr(rbce->postdata_buffer);   
+    } else {
+      data = StringValuePtr(rbce->postdata_buffer);
       len = RSTRING_LEN(rbce->postdata_buffer);
-      
+
       curl_easy_setopt(curl, CURLOPT_POST, 1);
       curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
       curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, len);
@@ -1787,12 +1851,12 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
 /*
  * 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 
+ * 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;
@@ -1831,7 +1895,7 @@ static VALUE ruby_curl_easy_set_head_option(VALUE self, VALUE onoff) {
 /*
  * call-seq:
  *   easy.http_put(data)                              => true
- * 
+ *
  * PUT the supplied data 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.
@@ -1840,21 +1904,38 @@ static VALUE ruby_curl_easy_perform_put(VALUE self, VALUE data) {
   ruby_curl_easy *rbce;
   CURL *curl;
 
-  PutStream *pstream = (PutStream*)malloc(sizeof(PutStream));
-  memset(pstream, 0, sizeof(PutStream));
-
   Data_Get_Struct(self, ruby_curl_easy, rbce);
-  curl = rbce->curl;
 
-  pstream->len = RSTRING_LEN(data);
-  pstream->buffer = StringValuePtr(data);
+  VALUE upload = ruby_curl_upload_new(cCurlUpload);
+  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... */
 
   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, pstream);
-  //printf("uploading %d bytes\n", pstream->len);
-  curl_easy_setopt(curl, CURLOPT_INFILESIZE, pstream->len);
+  curl_easy_setopt(curl, CURLOPT_READDATA, rbce);
+
+  if (rb_respond_to(data, rb_intern("read"))) {
+    VALUE stat = rb_funcall(data, rb_intern("stat"), 0);
+    if( stat ) {
+      ruby_curl_easy_headers_set(self,rb_str_new2("Expect:"));
+      VALUE size = rb_funcall(stat, rb_intern("size"), 0);
+      curl_easy_setopt(curl, CURLOPT_INFILESIZE, FIX2INT(size));
+    }
+    else {
+      ruby_curl_easy_headers_set(self,rb_str_new2("Transfer-Encoding: chunked"));
+    }
+  }
+  else if (rb_respond_to(data, rb_intern("to_s"))) {
+    curl_easy_setopt(curl, CURLOPT_INFILESIZE, RSTRING_LEN(data));
+    ruby_curl_easy_headers_set(self,rb_str_new2("Expect:"));
+  }
+  else {
+    rb_raise(rb_eRuntimeError, "PUT data must respond to read or to_s");
+  }
 
   VALUE ret = handle_perform(self, rbce);
   /* cleanup  */
@@ -1871,9 +1952,9 @@ static VALUE ruby_curl_easy_perform_put(VALUE self, VALUE data) {
 /*
  * call-seq:
  *   easy.body_str                                    => "response body"
- * 
+ *
  * Return the response body from the previous call to +perform+. This
- * is populated by the default +on_body+ handler - if you supply 
+ * is populated by the default +on_body+ handler - if you supply
  * your own body handler, this string will be empty.
  */
 static VALUE ruby_curl_easy_body_str_get(VALUE self) {
@@ -1883,9 +1964,9 @@ static VALUE ruby_curl_easy_body_str_get(VALUE self) {
 /*
  * call-seq:
  *   easy.header_str                                  => "response header"
- * 
+ *
  * Return the response header from the previous call to +perform+. This
- * is populated by the default +on_header+ handler - if you supply 
+ * is populated by the default +on_header+ handler - if you supply
  * your own header handler, this string will be empty.
  */
 static VALUE ruby_curl_easy_header_str_get(VALUE self) {
@@ -1898,7 +1979,7 @@ static VALUE ruby_curl_easy_header_str_get(VALUE self) {
 /*
  * call-seq:
  *   easy.last_effective_url                          => "http://some.url" or nil
- * 
+ *
  * Retrieve the last effective URL used by this instance.
  * This is the URL used in the last +perform+ call,
  * and may differ from the value of easy.url.
@@ -1906,514 +1987,514 @@ static VALUE ruby_curl_easy_header_str_get(VALUE self) {
 static VALUE ruby_curl_easy_last_effective_url_get(VALUE self) {
   ruby_curl_easy *rbce;
   char* url;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_EFFECTIVE_URL, &url);
-  
+
   if (url && url[0]) {    // curl returns empty string if none
     return rb_str_new2(url);
   } else {
     return Qnil;
   }
 }
-  
+
 /*
  * call-seq:
  *   easy.response_code                               => fixnum
- * 
- * Retrieve the last received HTTP or FTP code. This will be zero 
- * if no server response code has been received. Note that a proxy's 
+ *
+ * Retrieve the last received HTTP or FTP code. This will be zero
+ * if no server response code has been received. Note that a proxy's
  * CONNECT response should be read with +http_connect_code+
  * and not this method.
  */
 static VALUE ruby_curl_easy_response_code_get(VALUE self) {
   ruby_curl_easy *rbce;
   long code;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
 #ifdef HAVE_CURLINFO_RESPONSE_CODE
   curl_easy_getinfo(rbce->curl, CURLINFO_RESPONSE_CODE, &code);
 #else
   // old libcurl
   curl_easy_getinfo(rbce->curl, CURLINFO_HTTP_CODE, &code);
 #endif
-  
-  return LONG2NUM(code);  
+
+  return LONG2NUM(code);
 }
-  
+
 /*
  * call-seq:
  *   easy.http_connect_code                           => fixnum
- * 
+ *
  * Retrieve the last received proxy response code to a CONNECT request.
  */
 static VALUE ruby_curl_easy_http_connect_code_get(VALUE self) {
   ruby_curl_easy *rbce;
   long code;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_HTTP_CONNECTCODE, &code);
-  
-  return LONG2NUM(code);  
+
+  return LONG2NUM(code);
 }
-  
+
 /*
  * call-seq:
  *   easy.file_time                                   => fixnum
- * 
- * Retrieve the remote time of the retrieved document (in number of 
- * seconds since 1 jan 1970 in the GMT/UTC time zone). If you get -1, 
- * it can be because of many reasons (unknown, the server hides it 
- * or the server doesn't support the command that tells document time 
- * etc) and the time of the document is unknown. 
- * 
- * Note that you must tell the server to collect this information 
- * before the transfer is made, by setting +fetch_file_time?+ to true, 
+ *
+ * Retrieve the remote time of the retrieved document (in number of
+ * seconds since 1 jan 1970 in the GMT/UTC time zone). If you get -1,
+ * it can be because of many reasons (unknown, the server hides it
+ * or the server doesn't support the command that tells document time
+ * etc) and the time of the document is unknown.
+ *
+ * Note that you must tell the server to collect this information
+ * before the transfer is made, by setting +fetch_file_time?+ to true,
  * or you will unconditionally get a -1 back.
- * 
- * This requires libcurl 7.5 or higher - otherwise -1 is unconditionally 
+ *
+ * This requires libcurl 7.5 or higher - otherwise -1 is unconditionally
  * returned.
  */
 static VALUE ruby_curl_easy_file_time_get(VALUE self) {
 #ifdef HAVE_CURLINFO_FILETIME
   ruby_curl_easy *rbce;
   long time;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_FILETIME, &time);
-  
+
   return LONG2NUM(time);
 #else
   rb_warn("Installed libcurl is too old to support file_time");
-  return INT2FIX(0);  
+  return INT2FIX(0);
 #endif
 }
-  
+
 /*
  * call-seq:
  *   easy.total_time                                  => float
- * 
- * Retrieve the total time in seconds for the previous transfer, 
- * including name resolving, TCP connect etc. 
+ *
+ * Retrieve the total time in seconds for the previous transfer,
+ * including name resolving, TCP connect etc.
  */
 static VALUE ruby_curl_easy_total_time_get(VALUE self) {
   ruby_curl_easy *rbce;
   double time;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_TOTAL_TIME, &time);
-  
-  return rb_float_new(time);  
+
+  return rb_float_new(time);
 }
-  
+
 /*
  * call-seq:
  *   easy.name_lookup_time                            => float
- * 
+ *
  * Retrieve the time, in seconds, it took from the start until the
- * name resolving was completed. 
+ * name resolving was completed.
  */
 static VALUE ruby_curl_easy_name_lookup_time_get(VALUE self) {
   ruby_curl_easy *rbce;
   double time;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_NAMELOOKUP_TIME, &time);
-  
-  return rb_float_new(time);  
+
+  return rb_float_new(time);
 }
-  
+
 /*
  * call-seq:
  *   easy.connect_time                                => float
- * 
+ *
  * Retrieve the time, in seconds, it took from the start until the
- * connect to the remote host (or proxy) was completed. 
+ * connect to the remote host (or proxy) was completed.
  */
 static VALUE ruby_curl_easy_connect_time_get(VALUE self) {
   ruby_curl_easy *rbce;
   double time;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_CONNECT_TIME, &time);
-  
-  return rb_float_new(time);  
+
+  return rb_float_new(time);
 }
-  
+
 /*
  * call-seq:
  *   easy.pre_transfer_time                           => float
- * 
- * Retrieve the time, in seconds, it took from the start until the 
- * file transfer is just about to begin. This includes all pre-transfer 
- * commands and negotiations that are specific to the particular protocol(s) 
- * involved. 
+ *
+ * Retrieve the time, in seconds, it took from the start until the
+ * file transfer is just about to begin. This includes all pre-transfer
+ * commands and negotiations that are specific to the particular protocol(s)
+ * involved.
  */
 static VALUE ruby_curl_easy_pre_transfer_time_get(VALUE self) {
   ruby_curl_easy *rbce;
   double time;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_PRETRANSFER_TIME, &time);
-  
-  return rb_float_new(time);  
+
+  return rb_float_new(time);
 }
-  
+
 /*
  * call-seq:
  *   easy.start_transfer_time                         => float
- * 
- * Retrieve the time, in seconds, it took from the start until the first byte 
- * is just about to be transferred. This includes the +pre_transfer_time+ and 
- * also the time the server needs to calculate the result. 
+ *
+ * Retrieve the time, in seconds, it took from the start until the first byte
+ * is just about to be transferred. This includes the +pre_transfer_time+ and
+ * also the time the server needs to calculate the result.
  */
 static VALUE ruby_curl_easy_start_transfer_time_get(VALUE self) {
   ruby_curl_easy *rbce;
   double time;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_STARTTRANSFER_TIME, &time);
-  
-  return rb_float_new(time);  
+
+  return rb_float_new(time);
 }
-  
+
 /*
  * call-seq:
  *   easy.redirect_time                               => float
- * 
+ *
  * Retrieve the total time, in seconds, it took for all redirection steps
- * include name lookup, connect, pretransfer and transfer before final 
- * transaction was started. +redirect_time+ contains the complete 
+ * include name lookup, connect, pretransfer and transfer before final
+ * transaction was started. +redirect_time+ contains the complete
  * execution time for multiple redirections.
- * 
+ *
  * Requires libcurl 7.9.7 or higher, otherwise -1 is always returned.
  */
 static VALUE ruby_curl_easy_redirect_time_get(VALUE self) {
 #ifdef HAVE_CURLINFO_REDIRECT_TIME
   ruby_curl_easy *rbce;
   double time;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_REDIRECT_TIME, &time);
-  
-  return rb_float_new(time); 
+
+  return rb_float_new(time);
 #else
   rb_warn("Installed libcurl is too old to support redirect_time");
   return rb_float_new(-1);
 #endif
 }
-  
+
 /*
  * call-seq:
  *   easy.redirect_count                           => integer
- * 
+ *
  * Retrieve the total number of redirections that were actually followed.
- * 
+ *
  * Requires libcurl 7.9.7 or higher, otherwise -1 is always returned.
  */
 static VALUE ruby_curl_easy_redirect_count_get(VALUE self) {
 #ifdef HAVE_CURLINFO_REDIRECT_COUNT
   ruby_curl_easy *rbce;
   long count;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_REDIRECT_COUNT, &count);
-  
+
   return LONG2NUM(count);
 #else
   rb_warn("Installed libcurl is too old to support redirect_count");
   return INT2FIX(-1);
 #endif
-    
+
 }
-  
+
 /*
  * call-seq:
  *   easy.uploaded_bytes                              => float
- * 
+ *
  * Retrieve the total amount of bytes that were uploaded in the
  * preceeding transfer.
  */
 static VALUE ruby_curl_easy_uploaded_bytes_get(VALUE self) {
   ruby_curl_easy *rbce;
   double bytes;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_SIZE_UPLOAD, &bytes);
-  
-  return rb_float_new(bytes);  
+
+  return rb_float_new(bytes);
 }
-  
+
 /*
  * call-seq:
  *   easy.downloaded_bytes                            => float
- * 
+ *
  * Retrieve the total amount of bytes that were downloaded in the
  * preceeding transfer.
  */
 static VALUE ruby_curl_easy_downloaded_bytes_get(VALUE self) {
   ruby_curl_easy *rbce;
   double bytes;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_SIZE_DOWNLOAD, &bytes);
-  
-  return rb_float_new(bytes);  
+
+  return rb_float_new(bytes);
 }
-  
+
 /*
  * call-seq:
  *   easy.upload_speed                                => float
- * 
- * Retrieve the average upload speed that curl measured for the 
- * preceeding complete upload. 
+ *
+ * Retrieve the average upload speed that curl measured for the
+ * preceeding complete upload.
  */
 static VALUE ruby_curl_easy_upload_speed_get(VALUE self) {
   ruby_curl_easy *rbce;
   double bytes;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_SPEED_UPLOAD, &bytes);
-  
-  return rb_float_new(bytes);  
+
+  return rb_float_new(bytes);
 }
-  
+
 /*
  * call-seq:
  *   easy.download_speed                              => float
- * 
- * Retrieve the average download speed that curl measured for 
- * the preceeding complete download. 
+ *
+ * Retrieve the average download speed that curl measured for
+ * the preceeding complete download.
  */
 static VALUE ruby_curl_easy_download_speed_get(VALUE self) {
   ruby_curl_easy *rbce;
   double bytes;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_SPEED_DOWNLOAD, &bytes);
-  
-  return rb_float_new(bytes);  
+
+  return rb_float_new(bytes);
 }
-  
+
 /*
  * call-seq:
  *   easy.header_size                                 => fixnum
- * 
- * Retrieve the total size of all the headers received in the 
+ *
+ * Retrieve the total size of all the headers received in the
  * preceeding transfer.
  */
 static VALUE ruby_curl_easy_header_size_get(VALUE self) {
   ruby_curl_easy *rbce;
   long size;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_HEADER_SIZE, &size);
-  
-  return LONG2NUM(size);  
+
+  return LONG2NUM(size);
 }
-  
+
 /*
  * call-seq:
  *   easy.request_size                                => fixnum
- * 
- * Retrieve the total size of the issued requests. This is so far 
+ *
+ * Retrieve the total size of the issued requests. This is so far
  * only for HTTP requests. Note that this may be more than one request
- * if +follow_location?+ is true. 
+ * if +follow_location?+ is true.
  */
 static VALUE ruby_curl_easy_request_size_get(VALUE self) {
   ruby_curl_easy *rbce;
   long size;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_REQUEST_SIZE, &size);
-  
-  return LONG2NUM(size);  
+
+  return LONG2NUM(size);
 }
-  
+
 /*
  * call-seq:
  *   easy.ssl_verify_result                           => integer
- * 
- * Retrieve the result of the certification verification that was requested 
- * (by setting +ssl_verify_peer?+ to +true+).  
+ *
+ * Retrieve the result of the certification verification that was requested
+ * (by setting +ssl_verify_peer?+ to +true+).
  */
 static VALUE ruby_curl_easy_ssl_verify_result_get(VALUE self) {
   ruby_curl_easy *rbce;
   long result;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_SSL_VERIFYRESULT, &result);
-  
-  return LONG2NUM(result);  
+
+  return LONG2NUM(result);
 }
-    
-/* 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) 
+/* 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)
 */
 
 /*
  * call-seq:
  *   easy.downloaded_content_length                   => float
- * 
- * Retrieve the content-length of the download. This is the value read 
- * from the Content-Length: field.  
+ *
+ * Retrieve the content-length of the download. This is the value read
+ * from the Content-Length: field.
  */
 static VALUE ruby_curl_easy_downloaded_content_length_get(VALUE self) {
   ruby_curl_easy *rbce;
   double bytes;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &bytes);
-  
-  return rb_float_new(bytes);  
+
+  return rb_float_new(bytes);
 }
-  
+
 /*
  * call-seq:
  *   easy.uploaded_content_length                     => float
- * 
+ *
  * Retrieve the content-length of the upload.
  */
 static VALUE ruby_curl_easy_uploaded_content_length_get(VALUE self) {
   ruby_curl_easy *rbce;
   double bytes;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_CONTENT_LENGTH_UPLOAD, &bytes);
-  
-  return rb_float_new(bytes);  
+
+  return rb_float_new(bytes);
 }
-  
+
 /*
  * call-seq:
  *   easy.content_type                                => "content/type" or nil
- * 
+ *
  * Retrieve the content-type of the downloaded object. This is the value read
- * from the Content-Type: field. If you get +nil+, it means that the server 
- * didn't send a valid Content-Type header or that the protocol used doesn't 
- * support this. 
+ * from the Content-Type: field. If you get +nil+, it means that the server
+ * didn't send a valid Content-Type header or that the protocol used doesn't
+ * support this.
  */
 static VALUE ruby_curl_easy_content_type_get(VALUE self) {
   ruby_curl_easy *rbce;
   char* type;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_CONTENT_TYPE, &type);
-  
+
   if (type && type[0]) {    // curl returns empty string if none
     return rb_str_new2(type);
   } else {
     return Qnil;
   }
 }
-  
 
-/* NOT REQUIRED? 
-CURLINFO_PRIVATE 
 
-Pass a pointer to a 'char *' to receive the pointer to the private data associated with the curl handle (set with the CURLOPT_PRIVATE option to curl_easy_setopt(3)). (Added in 7.10.3) 
+/* NOT REQUIRED?
+CURLINFO_PRIVATE
+
+Pass a pointer to a 'char *' to receive the pointer to the private data associated with the curl handle (set with the CURLOPT_PRIVATE option to curl_easy_setopt(3)). (Added in 7.10.3)
 */
 
 /* TODO these will need constants setting up too for checking the bits.
- * 
- * Alternatively, could return an object that wraps the long, and has 
+ *
+ * Alternatively, could return an object that wraps the long, and has
  * question methods to query the auth types. Could return long from to_i(nt)
  *
-CURLINFO_HTTPAUTH_AVAIL 
+CURLINFO_HTTPAUTH_AVAIL
 
-Pass a pointer to a long to receive a bitmask indicating the authentication method(s) available. The meaning of the bits is explained in the CURLOPT_HTTPAUTH option for curl_easy_setopt(3). (Added in 7.10.8) 
+Pass a pointer to a long to receive a bitmask indicating the authentication method(s) available. The meaning of the bits is explained in the CURLOPT_HTTPAUTH option for curl_easy_setopt(3). (Added in 7.10.8)
 
-CURLINFO_PROXYAUTH_AVAIL 
+CURLINFO_PROXYAUTH_AVAIL
 
-Pass a pointer to a long to receive a bitmask indicating the authentication method(s) available for your proxy authentication. (Added in 7.10.8) 
+Pass a pointer to a long to receive a bitmask indicating the authentication method(s) available for your proxy authentication. (Added in 7.10.8)
 */
 
 /*
  * call-seq:
  *   easy.os_errno                                    => integer
- * 
- * Retrieve the errno variable from a connect failure (requires 
+ *
+ * Retrieve the errno variable from a connect failure (requires
  * libcurl 7.12.2 or higher, otherwise 0 is always returned).
  */
 static VALUE ruby_curl_easy_os_errno_get(VALUE self) {
 #ifdef HAVE_CURLINFO_OS_ERRNO
   ruby_curl_easy *rbce;
   long result;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_OS_ERRNO, &result);
-  
-  return LONG2NUM(result);  
+
+  return LONG2NUM(result);
 #else
   rb_warn("Installed libcurl is too old to support os_errno");
   return INT2FIX(0);
 #endif
 }
-    
+
 /*
  * call-seq:
  *   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). 
- * Combined with +redirect_count+ you are able to know how many times libcurl 
- * successfully reused existing connection(s) or not. 
- * 
+ *
+ * Retrieve the number of new connections libcurl had to create to achieve
+ * the previous transfer (only the successful connects are counted).
+ * Combined with +redirect_count+ you are able to know how many times libcurl
+ * successfully reused existing connection(s) or not.
+ *
  * See the Connection Options of curl_easy_setopt(3) to see how libcurl tries
  * to make persistent connections to save time.
- *  
+ *
  * (requires libcurl 7.12.3 or higher, otherwise -1 is always returned).
  */
 static VALUE ruby_curl_easy_num_connects_get(VALUE self) {
 #ifdef HAVE_CURLINFO_NUM_CONNECTS
   ruby_curl_easy *rbce;
   long result;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_NUM_CONNECTS, &result);
-  
-  return LONG2NUM(result);  
+
+  return LONG2NUM(result);
 #else
   rb_warn("Installed libcurl is too old to support num_connects");
   return INT2FIX(-1);
 #endif
 }
-    
+
 
 /* TODO this needs to be implemented.
 
-CURLINFO_COOKIELIST 
+CURLINFO_COOKIELIST
 
-Pass a pointer to a 'struct curl_slist *' to receive a linked-list of all cookies cURL knows (expired ones, too). Don't forget to curl_slist_free_all(3) the list after it has been used. If there are no cookies (cookies for the handle have not been enabled or simply none have been received) 'struct curl_slist *' will be set to point to NULL. (Added in 7.14.1) 
+Pass a pointer to a 'struct curl_slist *' to receive a linked-list of all cookies cURL knows (expired ones, too). Don't forget to curl_slist_free_all(3) the list after it has been used. If there are no cookies (cookies for the handle have not been enabled or simply none have been received) 'struct curl_slist *' will be set to point to NULL. (Added in 7.14.1)
 */
 
 /* TODO this needs to be implemented. Could probably support CONNECT_ONLY by having this
  *      return an open Socket or something.
  *
-CURLINFO_LASTSOCKET 
+CURLINFO_LASTSOCKET
 
-Pass a pointer to a long to receive the last socket used by this curl session. If the socket is no longer valid, -1 is returned. When you finish working with the socket, you must call curl_easy_cleanup() as usual and let libcurl close the socket and cleanup other resources associated with the handle. This is typically used in combination with CURLOPT_CONNECT_ONLY. (Added in 7.15.2) 
+Pass a pointer to a long to receive the last socket used by this curl session. If the socket is no longer valid, -1 is returned. When you finish working with the socket, you must call curl_easy_cleanup() as usual and let libcurl close the socket and cleanup other resources associated with the handle. This is typically used in combination with CURLOPT_CONNECT_ONLY. (Added in 7.15.2)
 */
 
 /*
  * call-seq:
  *   easy.content_type                                => "content/type" 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 
+ *
+ * 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
  * something is wrong.
- *  
+ *
  * (requires libcurl 7.15.4 or higher, otherwise +nil+ is always returned).
  */
 static VALUE ruby_curl_easy_ftp_entry_path_get(VALUE self) {
 #ifdef HAVE_CURLINFO_FTP_ENTRY_PATH
   ruby_curl_easy *rbce;
   char* path = NULL;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);  
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_FTP_ENTRY_PATH, &path);
-  
+
   if (path && path[0]) {    // curl returns NULL or empty string if none
     return rb_str_new2(path);
   } else {
@@ -2424,17 +2505,17 @@ static VALUE ruby_curl_easy_ftp_entry_path_get(VALUE self) {
   return Qnil;
 #endif
 }
-  
+
 
 /* ================== ESCAPING FUNCS ==============*/
 
-/* 
+/*
  * call-seq:
  *   easy.escape("some text")                         => "some%20text"
- * 
+ *
  * Convert the given input string to a URL encoded string and return
- * the result. All input characters that are not a-z, A-Z or 0-9 are 
- * converted to their "URL escaped" version (%NN where NN is a 
+ * the result. All input characters that are not a-z, A-Z or 0-9 are
+ * converted to their "URL escaped" version (%NN where NN is a
  * two-digit hexadecimal number).
  */
 static VALUE ruby_curl_easy_escape(VALUE self, VALUE str) {
@@ -2443,7 +2524,7 @@ static VALUE ruby_curl_easy_escape(VALUE self, VALUE str) {
   VALUE rresult;
 
   Data_Get_Struct(self, ruby_curl_easy, rbce);
-  
+
 #if (LIBCURL_VERSION_NUM >= 0x070f04)
   result = (char*)curl_easy_escape(rbce->curl, StringValuePtr(str), RSTRING_LEN(str));
 #else
@@ -2451,17 +2532,17 @@ static VALUE ruby_curl_easy_escape(VALUE self, VALUE str) {
 #endif
 
   rresult = rb_str_new2(result);
-  curl_free(result); 
-  
+  curl_free(result);
+
   return rresult;
 }
 
 /*
  * call-seq:
  *   easy.unescape("some text")                       => "some%20text"
- * 
+ *
  * 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 
+ * the result. All input characters that are URL encoded (%XX where XX is a
  * two-digit hexadecimal number) are converted to their binary versions.
  */
 static VALUE ruby_curl_easy_unescape(VALUE self, VALUE str) {
@@ -2469,9 +2550,9 @@ static VALUE ruby_curl_easy_unescape(VALUE self, VALUE str) {
   int rlen;
   char *result;
   VALUE rresult;
-  
+
   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);
 #else
@@ -2480,8 +2561,8 @@ static VALUE ruby_curl_easy_unescape(VALUE self, VALUE str) {
 #endif
 
   rresult = rb_str_new(result, rlen);
-  curl_free(result); 
-  
+  curl_free(result);
+
   return rresult;
 }
 
@@ -2491,63 +2572,63 @@ 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 
+ *
+ * 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);  
-  
+  VALUE c = ruby_curl_easy_new(argc, argv, klass);
+
   if (rb_block_given_p()) {
     rb_yield(c);
   }
-  
+
   ruby_curl_easy_perform(c);
-  return 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 
+ *
+ * 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);  
-  
+  VALUE c = ruby_curl_easy_new(argc, argv, klass);
+
   if (rb_block_given_p()) {
     rb_yield(c);
   }
-  
+
   ruby_curl_easy_perform_get(c);
-  return 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 
+ *
+ * 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);  
-  
+  VALUE c = ruby_curl_easy_new(argc, argv, klass);
+
   if (rb_block_given_p()) {
     rb_yield(c);
   }
-  
+
   ruby_curl_easy_perform_delete(c);
   return c;
 }
@@ -2581,30 +2662,30 @@ static VALUE ruby_curl_easy_class_perform_head(int argc, VALUE *argv, VALUE klas
  *   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 
+ *
+ * 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.
- * 
+ *
  * 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 
+ * in order to set multipart_form_post true. See #http_post for more
  * information.
  */
-static VALUE ruby_curl_easy_class_perform_post(int argc, VALUE *argv, VALUE klass) {   
+static VALUE ruby_curl_easy_class_perform_post(int argc, VALUE *argv, VALUE klass) {
   VALUE url, fields;
-  
+
   rb_scan_args(argc, argv, "1*", &url, &fields);
-  
-  VALUE c = ruby_curl_easy_new(1, &url, klass);  
-  
+
+  VALUE 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;  
+  }
+
+  return c;
 }
 
 
@@ -2612,10 +2693,10 @@ static VALUE ruby_curl_easy_class_perform_post(int argc, VALUE *argv, VALUE klas
 void init_curb_easy() {
   idCall = rb_intern("call");
   idJoin = rb_intern("join");
-  
+
   rbstrAmp = rb_str_new2("&");
   rb_global_variable(&rbstrAmp);
-  
+
   cCurlEasy = rb_define_class_under(mCurl, "Easy", rb_cObject);
 
   /* Class methods */
@@ -2628,7 +2709,7 @@ void init_curb_easy() {
 
   /* 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, "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);
@@ -2672,7 +2753,7 @@ 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, "proxy_tunnel=", ruby_curl_easy_proxy_tunnel_set, 1);
   rb_define_method(cCurlEasy, "proxy_tunnel?", ruby_curl_easy_proxy_tunnel_q, 0);
   rb_define_method(cCurlEasy, "fetch_file_time=", ruby_curl_easy_fetch_file_time_set, 1);
@@ -2721,7 +2802,6 @@ void init_curb_easy() {
   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);
-  rb_define_method(cCurlEasy, "total_time", ruby_curl_easy_total_time_get, 0);
   rb_define_method(cCurlEasy, "name_lookup_time", ruby_curl_easy_name_lookup_time_get, 0);
   rb_define_method(cCurlEasy, "connect_time", ruby_curl_easy_connect_time_get, 0);
   rb_define_method(cCurlEasy, "pre_transfer_time", ruby_curl_easy_pre_transfer_time_get, 0);
@@ -2748,5 +2828,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_alias(cCurlEasy, "dup", "clone");
 }