curb 0.1.4 → 0.3.1

data/README

@@ -2,21 +2,22 @@
 
 * http://curb.rubyforge.org/
 * http://rubyforge.org/projects/curb
+* http://github.com/taf2/curb/tree/master
 
 Curb (probably CUrl-RuBy or something) provides Ruby-language bindings for the
 libcurl(3), a fully-featured client-side URL transfer library.
 cURL and libcurl live at http://curl.haxx.se/ .
 
-Curb is a work-in-progress, and currently only supports libcurl's 'easy' mode.
+Curb is a work-in-progress, and currently only supports libcurl's 'easy' and 'multi' modes.
 
 === License
 
-Curb is copyright (c)2006 Ross Bamford, and released under the terms of the 
+Curb is copyright (c) 2006 Ross Bamford, and released under the terms of the 
 Ruby license. See the LICENSE file for the gory details. 
 
 === You will need
 
-* A working Ruby installation (1.8+, tested with 1.8.5)
+* A working Ruby installation (1.8+, tested with 1.8.5, 1.8.6, 1.8.7, and 1.9.1)
 * A working (lib)curl installation, with development stuff (7.5+, tested with 7.15)
 * A sane build environment
 
@@ -104,3 +105,25 @@ HTTP POST file upload:
   c = Curl::Easy.new("http://my.rails.box/files/upload")
   c.multipart_form_post = true
   c.http_post(Curl::PostField.file('myfile.rb'))
+
+Multi Interface:
+  responses = {}
+  requests = ["http://www.google.co.uk/", "http://www.ruby-lang.org/"]
+  m = Curl::Multi.new
+  # add a few easy handles
+  requests.each do |url|
+    responses[url] = ""
+    c = Curl::Easy.new(url) do|curl|
+      curl.follow_location = true
+      curl.on_body{|data| responses[url] << data; data.size }
+    end
+    m.add(c)
+  end
+
+  m.perform do
+    puts "idling... can do some work here, including add new requests"
+  end
+
+  requests.each do|url|
+    puts responses[url]
+  end

data/Rakefile

@@ -4,12 +4,6 @@ require 'rake/clean'
 require 'rake/testtask'
 require 'rake/rdoctask'
 
-begin
-  require 'rake/gempackagetask'
-rescue LoadError
-  $stderr.puts("Rubygems support disabled")
-end
-
 CLEAN.include '**/*.o'
 CLEAN.include "**/*.#{Config::MAKEFILE_CONFIG['DLEXT']}"
 CLOBBER.include 'doc'
@@ -21,8 +15,8 @@ def announce(msg='')
   $stderr.puts msg
 end
 
-desc "Default Task (Build packages)"
-task :default => :package
+desc "Default Task (Test project)"
+task :default => :test
 
 # Determine the current version of the software
 if File.read('ext/curb.h') =~ /\s*CURB_VERSION\s*['"](\d.+)['"]/
@@ -61,7 +55,7 @@ def make(target = '')
 end
 
 # Let make handle dependencies between c/o/so - we'll just run it. 
-file CURB_SO => 'ext/Makefile' do
+file CURB_SO => (['ext/Makefile'] + Dir['ext/*.c'] + Dir['ext/*.h']) do
   m = make
   fail "Make failed (status #{m})" unless m == 0
 end
@@ -130,73 +124,30 @@ task :doc_upload => [ :doc ] do
   end
 end
 
-# Packaging ------------------------------------------------
-PKG_FILES = FileList[
-  'ext/*.rb',
-  'ext/*.c',
-  'ext/*.h',
-  'tests/**/*',
-  'samples/**/*',
-  'doc.rb',
-  '[A-Z]*',
-]
-
 if ! defined?(Gem)
   warn "Package Target requires RubyGEMs"
 else
-  spec = Gem::Specification.new do |s|
-    
-    #### Basic information.
-
-    s.name = 'curb'
-    s.version = PKG_VERSION
-    s.summary = "Ruby bindings for the libcurl(3) URL transfer library."
-    s.description = <<-EOF
-      C-language Ruby bindings for the libcurl(3) URL transfer library.
-    EOF
-    s.extensions = 'ext/extconf.rb'    
-
-    #### Which files are to be included in this gem? 
-
-    s.files = PKG_FILES.to_a
-
-    #### Load-time details
-    s.require_path = 'lib'
-    
-    #### Documentation and testing.
-    s.has_rdoc = true
-    s.extra_rdoc_files = Dir['ext/*.c'] << 'ext/curb.rb' << 'README' << 'LICENSE'
-    s.rdoc_options <<
-      '--title' <<  'Curb API' <<
-      '--main' << 'README'
-
-    s.test_files = Dir.glob('tests/tc_*.rb')
-    
-    #### Author and project details.
-
-    s.author = "Ross Bamford"
-    s.email = "curb-devel@rubyforge.org"
-    s.homepage = "http://curb.rubyforge.org"
-    s.rubyforge_project = "curb"
-  end
-  
-  # Quick fix for Ruby 1.8.3 / YAML bug
-  if (RUBY_VERSION == '1.8.3')
-    def spec.to_yaml
-      out = super
-      out = '--- ' + out unless out =~ /^---/
-      out
-    end  
+  desc 'Generate gem specification'
+  task :gemspec do
+    require 'erb'
+    tspec = ERB.new(File.read(File.join(File.dirname(__FILE__),'lib','curb.gemspec.erb')))
+    File.open(File.join(File.dirname(__FILE__),'curb.gemspec'),'wb') do|f|
+      f << tspec.result
+    end
   end
 
-  package_task = Rake::GemPackageTask.new(spec) do |pkg|
-    pkg.need_zip = true
-    pkg.need_tar_gz = true
-    pkg.package_dir = 'pkg'    
-  end      
+  desc 'Build gem'
+  task :package => :gemspec do
+    require 'rubygems/specification'
+    spec_source = File.read File.join(File.dirname(__FILE__),'curb.gemspec')
+    spec = nil
+    # see: http://gist.github.com/16215
+    Thread.new { spec = eval("$SAFE = 3\n#{spec_source}") }.join
+    spec.validate
+    Gem::Builder.new(spec).build
+  end
 end
 
-
 # --------------------------------------------------------------------
 # Creating a release
 desc "Make a new release (Requires SVN commit / webspace access)"

data/doc.rb

@@ -34,7 +34,7 @@ begin
     end
   end
  
-  system("rdoc --title='Curb - libcurl bindings for ruby' --main=README #{pp_srcdir}/*.c README LICENSE ext/curb.rb")
+  system("rdoc --title='Curb - libcurl bindings for ruby' --main=README #{pp_srcdir}/*.c README LICENSE lib/curb.rb")
 ensure
   rm_rf(tmpdir)
 end

data/ext/curb.c

@@ -42,7 +42,7 @@ static VALUE ruby_curl_kerberos4_q(VALUE mod) {
  * For libcurl versions < 7.10, always returns false.
  */
 static VALUE ruby_curl_ssl_q(VALUE mod) {
-#ifdef CURL_VERSION_SSL
+#ifdef HAVE_CURL_VERSION_SSL
   curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
   return((ver->features & CURL_VERSION_SSL) ? Qtrue : Qfalse);
 #else
@@ -58,7 +58,7 @@ static VALUE ruby_curl_ssl_q(VALUE mod) {
  * using libz. For libcurl versions < 7.10, always returns false.
  */
 static VALUE ruby_curl_libz_q(VALUE mod) {
-#ifdef CURL_VERSION_LIBZ
+#ifdef HAVE_CURL_VERSION_LIBZ
   curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
   return((ver->features & CURL_VERSION_LIBZ) ? Qtrue : Qfalse);
 #else
@@ -74,7 +74,7 @@ static VALUE ruby_curl_libz_q(VALUE mod) {
  * For libcurl versions < 7.10.6, always returns false.
  */
 static VALUE ruby_curl_ntlm_q(VALUE mod) {
-#ifdef CURL_VERSION_NTLM
+#ifdef HAVE_CURL_VERSION_NTLM
   curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
   return((ver->features & CURL_VERSION_NTLM) ? Qtrue : Qfalse);
 #else
@@ -90,7 +90,7 @@ static VALUE ruby_curl_ntlm_q(VALUE mod) {
  * For libcurl versions < 7.10.6, always returns false.
  */
 static VALUE ruby_curl_gssnegotiate_q(VALUE mod) {
-#ifdef CURL_VERSION_GSSNEGOTIATE
+#ifdef HAVE_CURL_VERSION_GSSNEGOTIATE
   curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
   return((ver->features & CURL_VERSION_GSSNEGOTIATE) ? Qtrue : Qfalse);
 #else
@@ -107,7 +107,7 @@ static VALUE ruby_curl_gssnegotiate_q(VALUE mod) {
  * false.
  */
 static VALUE ruby_curl_debug_q(VALUE mod) {
-#ifdef CURL_VERSION_DEBUG
+#ifdef HAVE_CURL_VERSION_DEBUG
   curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
   return((ver->features & CURL_VERSION_DEBUG) ? Qtrue : Qfalse);
 #else
@@ -125,7 +125,7 @@ static VALUE ruby_curl_debug_q(VALUE mod) {
  * For libcurl versions < 7.10.7, always returns false.
  */
 static VALUE ruby_curl_asyncdns_q(VALUE mod) {
-#ifdef CURL_VERSION_ASYNCHDNS
+#ifdef HAVE_CURL_VERSION_ASYNCHDNS
   curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
   return((ver->features & CURL_VERSION_ASYNCHDNS) ? Qtrue : Qfalse);
 #else
@@ -142,7 +142,7 @@ static VALUE ruby_curl_asyncdns_q(VALUE mod) {
  * in RFC 2478). For libcurl versions < 7.10.8, always returns false.
  */
 static VALUE ruby_curl_spnego_q(VALUE mod) {
-#ifdef CURL_VERSION_SPNEGO
+#ifdef HAVE_CURL_VERSION_SPNEGO
   curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
   return((ver->features & CURL_VERSION_SPNEGO) ? Qtrue : Qfalse);
 #else
@@ -158,7 +158,7 @@ static VALUE ruby_curl_spnego_q(VALUE mod) {
  * files. For libcurl versions < 7.11.1, always returns false.
  */
 static VALUE ruby_curl_largefile_q(VALUE mod) {
-#ifdef CURL_VERSION_LARGEFILE
+#ifdef HAVE_CURL_VERSION_LARGEFILE
   curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
   return((ver->features & CURL_VERSION_LARGEFILE) ? Qtrue : Qfalse);
 #else
@@ -175,7 +175,7 @@ static VALUE ruby_curl_largefile_q(VALUE mod) {
  * always returns false.
  */
 static VALUE ruby_curl_idn_q(VALUE mod) {
-#ifdef CURL_VERSION_IDN
+#ifdef HAVE_CURL_VERSION_IDN
   curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
   return((ver->features & CURL_VERSION_IDN) ? Qtrue : Qfalse);
 #else
@@ -194,7 +194,7 @@ static VALUE ruby_curl_idn_q(VALUE mod) {
  * For libcurl versions < 7.13.2, always returns false.
  */
 static VALUE ruby_curl_sspi_q(VALUE mod) {
-#ifdef CURL_VERSION_SSPI
+#ifdef HAVE_CURL_VERSION_SSPI
   curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
   return((ver->features & CURL_VERSION_SSPI) ? Qtrue : Qfalse);
 #else
@@ -210,7 +210,7 @@ static VALUE ruby_curl_sspi_q(VALUE mod) {
  * conversions. For libcurl versions < 7.15.4, always returns false.
  */
 static VALUE ruby_curl_conv_q(VALUE mod) {
-#ifdef CURL_VERSION_CONV
+#ifdef HAVE_CURL_VERSION_CONV
   curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);  
   return((ver->features & CURL_VERSION_CONV) ? Qtrue : Qfalse);
 #else
@@ -254,63 +254,63 @@ void Init_curb_core() {
   rb_define_const(mCurl, "CURLINFO_DATA_OUT", INT2FIX(CURLINFO_DATA_OUT));
 
   /* When passed to Curl::Easy#proxy_type , indicates that the proxy is an HTTP proxy. (libcurl >= 7.10) */
-#ifdef CURLPROXY_HTTP
+#ifdef HAVE_CURLPROXY_HTTP
   rb_define_const(mCurl, "CURLPROXY_HTTP", INT2FIX(CURLPROXY_HTTP));
 #else
   rb_define_const(mCurl, "CURLPROXY_HTTP", INT2FIX(-1));
 #endif
 
   /* When passed to Curl::Easy#proxy_type , indicates that the proxy is a SOCKS4 proxy. (libcurl >= 7.15.2) */
-#ifdef 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 CURLPROXY_SOCKS5    
+#ifdef HAVE_CURLPROXY_SOCKS5    
   rb_define_const(mCurl, "CURLPROXY_SOCKS5", INT2FIX(CURLPROXY_SOCKS5));
 #else
   rb_define_const(mCurl, "CURLPROXY_SOCKS5", INT2FIX(-2));
 #endif
 
   /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, directs libcurl to use Basic authentication. */
-#ifdef CURLAUTH_BASIC
+#ifdef HAVE_CURLAUTH_BASIC
   rb_define_const(mCurl, "CURLAUTH_BASIC", INT2FIX(CURLAUTH_BASIC));
 #else
   rb_define_const(mCurl, "CURLAUTH_BASIC", INT2FIX(0);
 #endif
 
   /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, directs libcurl to use Digest authentication. */
-#ifdef CURLAUTH_DIGEST
+#ifdef HAVE_CURLAUTH_DIGEST
   rb_define_const(mCurl, "CURLAUTH_DIGEST", INT2FIX(CURLAUTH_DIGEST));
 #else
   rb_define_const(mCurl, "CURLAUTH_DIGEST", INT2FIX(0));
 #endif
 
   /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, directs libcurl to use GSS Negotiate authentication. Requires a suitable GSS-API library. */
-#ifdef CURLAUTH_GSSNEGOTIATE
+#ifdef HAVE_CURLAUTH_GSSNEGOTIATE
   rb_define_const(mCurl, "CURLAUTH_GSSNEGOTIATE", INT2FIX(CURLAUTH_GSSNEGOTIATE));
 #else
   rb_define_const(mCurl, "CURLAUTH_GSSNEGOTIATE", INT2FIX(0));
 #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 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 CURLAUTH_ANYSAFE  
+#ifdef HAVE_CURLAUTH_ANYSAFE  
   rb_define_const(mCurl, "CURLAUTH_ANYSAFE", INT2FIX(CURLAUTH_ANYSAFE));
 #else
   rb_define_const(mCurl, "CURLAUTH_ANYSAFE", 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. */
-#ifdef CURLAUTH_ANY
+#ifdef HAVE_CURLAUTH_ANY
   rb_define_const(mCurl, "CURLAUTH_ANY", INT2FIX(CURLAUTH_ANY));
 #else
   rb_define_const(mCurl, "CURLAUTH_ANY", INT2FIX(0));
@@ -333,4 +333,5 @@ void Init_curb_core() {
   init_curb_errors();
   init_curb_easy();
   init_curb_postfield();
+  init_curb_multi();
 }

data/ext/curb.h

@@ -11,18 +11,20 @@
 #include <ruby.h>
 #include <curl/curl.h>
 
+#include "curb_config.h"
 #include "curb_easy.h"
 #include "curb_errors.h"
 #include "curb_postfield.h"
+#include "curb_multi.h"
 
 #include "curb_macros.h"
 
 // These should be managed from the Rake 'release' task.
-#define CURB_VERSION   "0.1.4"
-#define CURB_VER_NUM   140
+#define CURB_VERSION   "0.3.1"
+#define CURB_VER_NUM   310
 #define CURB_VER_MAJ   0
-#define CURB_VER_MIN   1
-#define CURB_VER_MIC   4
+#define CURB_VER_MIN   3
+#define CURB_VER_MIC   1
 #define CURB_VER_PATCH 0
 
 
@@ -31,6 +33,12 @@
 #define RSTRING_LEN(x) RSTRING(x)->len 
 #endif
 
+#ifdef HAVE_RUBY19_HASH
+  #define RHASH_LEN(hash) RHASH(hash)->ntbl->num_entries
+#else
+  #define RHASH_LEN(hash) RHASH(hash)->tbl->num_entries
+#endif
+
 extern VALUE mCurl;
 
 extern void Init_curb_core();

data/ext/curb_config.h

@@ -0,0 +1,42 @@
+#ifndef CURB_CONFIG_H
+#define CURB_CONFIG_H
+#define  HAVE_CURLINFO_REDIRECT_TIME 1
+#define  HAVE_CURLINFO_RESPONSE_CODE 1
+#define  HAVE_CURLINFO_FILETIME 1
+#define  HAVE_CURLINFO_REDIRECT_COUNT 1
+#define  HAVE_CURLINFO_OS_ERRNO 1
+#define  HAVE_CURLINFO_NUM_CONNECTS 1
+#define  HAVE_CURLINFO_FTP_ENTRY_PATH 1
+#define  HAVE_CURL_VERSION_SSL 1
+#define  HAVE_CURL_VERSION_LIBZ 1
+#define  HAVE_CURL_VERSION_NTLM 1
+#define  HAVE_CURL_VERSION_GSSNEGOTIATE 1
+#define  HAVE_CURL_VERSION_DEBUG 1
+#define  HAVE_CURL_VERSION_ASYNCHDNS 1
+#define  HAVE_CURL_VERSION_SPNEGO 1
+#define  HAVE_CURL_VERSION_LARGEFILE 1
+#define  HAVE_CURL_VERSION_IDN 1
+#define  HAVE_CURL_VERSION_SSPI 1
+#define  HAVE_CURL_VERSION_CONV 1
+#define  HAVE_CURLPROXY_HTTP 1
+#define  HAVE_CURLPROXY_SOCKS4 1
+#define  HAVE_CURLPROXY_SOCKS5 1
+#define  HAVE_CURLAUTH_BASIC 1
+#define  HAVE_CURLAUTH_DIGEST 1
+#define  HAVE_CURLAUTH_GSSNEGOTIATE 1
+#define  HAVE_CURLAUTH_NTLM 1
+#define  HAVE_CURLAUTH_ANYSAFE 1
+#define  HAVE_CURLAUTH_ANY 1
+#define  HAVE_CURLE_TFTP_NOTFOUND 1
+#define  HAVE_CURLE_TFTP_PERM 1
+#define  HAVE_CURLE_TFTP_DISKFULL 1
+#define  HAVE_CURLE_TFTP_ILLEGAL 1
+#define  HAVE_CURLE_TFTP_UNKNOWNID 1
+#define  HAVE_CURLE_TFTP_EXISTS 1
+#define  HAVE_CURLE_TFTP_NOSUCHUSER 1
+#define  HAVE_CURLE_SEND_FAIL_REWIND 1
+#define  HAVE_CURLE_SSL_ENGINE_INITFAILED 1
+#define  HAVE_CURLE_LOGIN_DENIED 1
+#define  HAVE_RUBY19_ST_H 1
+#define  HAVE_CURL_EASY_ESCAPE 1
+#endif

data/ext/curb_easy.c

@@ -8,6 +8,7 @@
 #include "curb_errors.h"
 #include "curb_postfield.h"
 
+#include <errno.h>
 #include <string.h>
 
 extern VALUE mCurl;
@@ -33,6 +34,42 @@ static size_t default_data_handler(char *stream,
   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) {
+
+  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 ) {
+    memcpy(ptr, pstream->buffer+pstream->offset, remaining);
+    sent_bytes = remaining;
+    pstream->offset += remaining;
+  }
+  else if( remaining > sent_bytes ) { // sent_bytes <= remaining - send what we can fit in the buffer(ptr)
+    memcpy(ptr, pstream->buffer+pstream->offset, sent_bytes);
+    pstream->offset += sent_bytes;
+  }
+  else { // they're equal
+    memcpy(ptr, pstream->buffer+pstream->offset, --sent_bytes);
+    pstream->offset += sent_bytes;
+  }
+  if (sent_bytes == 0) {
+    free(pstream);
+  }
+
+  //printf("sent_bytes: %ld of %ld\n", sent_bytes, remaining);
+  return sent_bytes;
+}
 
 static size_t proc_data_handler(char *stream, 
                                 size_t size, 
@@ -92,11 +129,21 @@ void curl_easy_mark(ruby_curl_easy *rbce) {
   rb_gc_mark(rbce->proxypwd);  
   rb_gc_mark(rbce->headers);
   rb_gc_mark(rbce->cookiejar);
+  rb_gc_mark(rbce->cert);
+  rb_gc_mark(rbce->encoding);
+  rb_gc_mark(rbce->success_proc);
+  rb_gc_mark(rbce->failure_proc);
+  rb_gc_mark(rbce->complete_proc);
 
   rb_gc_mark(rbce->postdata_buffer);
+  rb_gc_mark(rbce->bodybuf);
+  rb_gc_mark(rbce->headerbuf);
 }
 
 void curl_easy_free(ruby_curl_easy *rbce) {
+  if (rbce->curl_headers) {
+    curl_slist_free_all(rbce->curl_headers);
+  }
   curl_easy_cleanup(rbce->curl);
   free(rbce);
 }
@@ -115,9 +162,10 @@ void curl_easy_free(ruby_curl_easy *rbce) {
  * the instance is returned.
  */
 static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
+  CURLcode ecode;
   VALUE url, blk;
   VALUE new_curl;
-    
+
   rb_scan_args(argc, argv, "01&", &url, &blk);    
 
   ruby_curl_easy *rbce = ALLOC(ruby_curl_easy);
@@ -139,6 +187,11 @@ static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
   rbce->proxypwd = Qnil;
   rbce->headers = rb_hash_new();
   rbce->cookiejar = Qnil;
+  rbce->cert = Qnil;
+  rbce->encoding = Qnil;
+  rbce->success_proc = Qnil;
+  rbce->failure_proc = Qnil;
+  rbce->complete_proc = Qnil;
   
   /* various-typed opts */
   rbce->local_port = 0;
@@ -168,13 +221,22 @@ static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
   
   /* buffers */
   rbce->postdata_buffer = Qnil;
+  rbce->bodybuf = Qnil;
+  rbce->headerbuf = Qnil;
+  rbce->curl_headers = NULL;
   
   new_curl = Data_Wrap_Struct(cCurlEasy, curl_easy_mark, curl_easy_free, rbce);
   
   if (blk != Qnil) {
     rb_funcall(blk, idCall, 1, new_curl);
   }
-  
+
+  /* set the rbce pointer to the curl handle */
+  ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)rbce);
+  if (ecode != CURLE_OK) {
+    raise_curl_easy_error_exception(ecode);
+  }
+
   return new_curl;  
 }
 
@@ -194,6 +256,7 @@ static VALUE ruby_curl_easy_clone(VALUE self) {
   newrbce = ALLOC(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);
 }
@@ -390,6 +453,48 @@ static VALUE ruby_curl_easy_cookiejar_get(VALUE self) {
   CURB_OBJECT_GETTER(ruby_curl_easy, cookiejar);
 }
 
+/*
+ * 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);
+}
+
+/*
+ * call-seq:
+ *   easy.cert                                        => "cert.file"
+ * 
+ * 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);
+}
+
+/*
+ * 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);
+}
 
 /* ================== IMMED ATTRS ==================*/
 
@@ -953,6 +1058,50 @@ static VALUE ruby_curl_easy_on_body_set(int argc, VALUE *argv, VALUE self) {
   CURB_HANDLER_PROC_SETTER(ruby_curl_easy, body_proc);
 }
 
+/*
+ * 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
+ */
+static VALUE ruby_curl_easy_on_success_set(int argc, VALUE *argv, VALUE self) {
+  CURB_HANDLER_PROC_SETTER(ruby_curl_easy, success_proc);
+}
+
+/*
+ * 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
+ */
+static VALUE ruby_curl_easy_on_failure_set(int argc, VALUE *argv, VALUE self) {
+  CURB_HANDLER_PROC_SETTER(ruby_curl_easy, failure_proc);
+}
+
+/*
+ * 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) {
+  CURB_HANDLER_PROC_SETTER(ruby_curl_easy, complete_proc);
+}
+
 /*
  * call-seq:
  *   easy.on_header { |header_data| ... }             => &lt;old handler&gt;
@@ -1044,234 +1193,393 @@ static VALUE cb_each_http_header(VALUE header, struct curl_slist **list) {
 }
 
 /***********************************************
- * 
- * 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.
- * 
+ *
+ * Setup a connection
+ *
  * Always returns Qtrue, rb_raise on error.
- * 
  */
-static VALUE handle_perform(ruby_curl_easy *rbce) {  
+VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *header_buffer, struct curl_slist **hdrs ) {
   // TODO this could do with a bit of refactoring...
   CURL *curl;
-  CURLcode result = -1;
-  struct curl_slist *headers = NULL;
 
   curl = rbce->curl;
   
-  if (rbce->url != Qnil) {  
-    VALUE url = rb_check_string_type(rbce->url);
-    VALUE bodybuf, headerbuf;
+  if (rbce->url == Qnil) {  
+    rb_raise(eCurlErrError, "No URL supplied");
+  }
+
+  VALUE url = rb_check_string_type(rbce->url);
+
+  // Need to configure the handler as per settings in rbce
+  curl_easy_setopt(curl, CURLOPT_URL, StringValuePtr(url));
   
-    // Need to configure the handler as per settings in rbce
-    curl_easy_setopt(curl, CURLOPT_URL, StringValuePtr(url));
-    
-    // network stuff and auth
-    if (rbce->interface != 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) {      
-      bodybuf = Qnil;      
-      curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &proc_data_handler);
-      curl_easy_setopt(curl, CURLOPT_WRITEDATA, rbce->body_proc);
-    } else {
-      bodybuf = rb_str_buf_new(32768);
-      curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &default_data_handler);
-      curl_easy_setopt(curl, CURLOPT_WRITEDATA, bodybuf);
-    }
-        
-    if (rbce->header_proc != Qnil) {
-      headerbuf = Qnil;      
-      curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, &proc_data_handler);
-      curl_easy_setopt(curl, CURLOPT_HEADERDATA, rbce->header_proc);
-    } else {
-      headerbuf = rb_str_buf_new(32768);      
-      curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, &default_data_handler);
-      curl_easy_setopt(curl, CURLOPT_HEADERDATA, headerbuf);
-    }
+  // 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;      
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)&proc_data_handler);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, rbce->body_proc);
+  } else {
+    *body_buffer = rb_str_buf_new(32768);
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)&default_data_handler);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, *body_buffer);
+  }
+      
+  if (rbce->header_proc != 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);      
+    curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, (curl_write_callback)&default_data_handler);
+    curl_easy_setopt(curl, CURLOPT_HEADERDATA, *header_buffer);
+  }
 
-    // progress and debug procs    
-    if (rbce->progress_proc != Qnil) {
-      curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, &proc_progress_handler);
-      curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, rbce->progress_proc);
-      curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
-    } else {
-      curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1);
-    }
-    
-    if (rbce->debug_proc != Qnil) {
-      curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, &proc_debug_handler);
-      curl_easy_setopt(curl, CURLOPT_DEBUGDATA, rbce->debug_proc);
-      curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
-    } else {
-      // have to remove handler to re-enable standard verbosity
-      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);
-    curl_easy_setopt(curl, CURLOPT_MAXREDIRS, rbce->max_redirs);
-
-    curl_easy_setopt(curl, CURLOPT_HTTPPROXYTUNNEL, rbce->proxy_tunnel);
-    curl_easy_setopt(curl, CURLOPT_FILETIME, rbce->fetch_file_time);
-    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, rbce->ssl_verify_peer);
-    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, rbce->ssl_verify_peer);
-            
-    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);
-    }      
+  /* encoding */
+  if (rbce->encoding != Qnil) {
+    curl_easy_setopt(curl, CURLOPT_ENCODING, StringValuePtr(rbce->encoding)); 
+  }
 
-    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);
+  // 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);
+    curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
+  } 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);
+    curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
+  } else {
+    // have to remove handler to re-enable standard verbosity
+    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);
+  curl_easy_setopt(curl, CURLOPT_MAXREDIRS, rbce->max_redirs);
+
+  curl_easy_setopt(curl, CURLOPT_HTTPPROXYTUNNEL, rbce->proxy_tunnel);
+  curl_easy_setopt(curl, CURLOPT_FILETIME, rbce->fetch_file_time);
+  curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, rbce->ssl_verify_peer);
+  curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, rbce->ssl_verify_peer);
+          
+  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);
 
 #if LIBCURL_VERSION_NUM >= 0x070a08
-    curl_easy_setopt(curl, CURLOPT_FTP_RESPONSE_TIMEOUT, rbce->ftp_response_timeout);
+  curl_easy_setopt(curl, CURLOPT_FTP_RESPONSE_TIMEOUT, rbce->ftp_response_timeout);
 #else
-    if (rbce->ftp_response_timeout > 0) {
-      rb_warn("Installed libcurl is too old to support ftp_response_timeout");
-    }
+  if (rbce->ftp_response_timeout > 0) {
+    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);      
+  }
+  
+  if (rbce->local_port > 0) {
+#if LIBCURL_VERSION_NUM >= 0x070f02
+    curl_easy_setopt(curl, CURLOPT_LOCALPORT, rbce->local_port);
     
-    // 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);      
+    if (rbce->local_port_range > 0) {
+      curl_easy_setopt(curl, CURLOPT_LOCALPORTRANGE, rbce->local_port_range);
     }
-    
-    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");
+    rb_warn("Installed libcurl is too old to support local_port");
 #endif   
-    }    
-    
-    if (rbce->proxy_type != -1) {
+  }    
+  
+  if (rbce->proxy_type != -1) {
 #if LIBCURL_VERSION_NUM >= 0x070a00
-      if (rbce->proxy_type == -2) {
-        rb_warn("Installed libcurl is too old to support the selected proxy type");
-      } else {
-        curl_easy_setopt(curl, CURLOPT_PROXYTYPE, rbce->proxy_type);
-      }
+    if (rbce->proxy_type == -2) {
+      rb_warn("Installed libcurl is too old to support the selected proxy type");
     } else {
-      curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
+      curl_easy_setopt(curl, CURLOPT_PROXYTYPE, rbce->proxy_type);
+    }
+  } else {
+    curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
 #else
-      rb_warn("Installed libcurl is too old to support proxy_type");      
+    rb_warn("Installed libcurl is too old to support proxy_type");      
 #endif      
-    }
+  }
 
-    if (rbce->http_auth_types > 0) {
+  if (rbce->http_auth_types > 0) {
 #if LIBCURL_VERSION_NUM >= 0x070a06
-      curl_easy_setopt(curl, CURLOPT_HTTPAUTH, rbce->http_auth_types);
-    } else {
-      curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
+    curl_easy_setopt(curl, CURLOPT_HTTPAUTH, rbce->http_auth_types);
+  } else {
+    curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
 #else
-      rb_warn("Installed libcurl is too old to support http_auth_types");      
+    rb_warn("Installed libcurl is too old to support http_auth_types");      
 #endif      
-    }
+  }
 
-    if (rbce->proxy_auth_types > 0) {
+  if (rbce->proxy_auth_types > 0) {
 #if LIBCURL_VERSION_NUM >= 0x070a07
-      curl_easy_setopt(curl, CURLOPT_PROXYAUTH, rbce->proxy_auth_types);
-    } else {
-      curl_easy_setopt(curl, CURLOPT_PROXYAUTH, CURLAUTH_ANY);
+    curl_easy_setopt(curl, CURLOPT_PROXYAUTH, rbce->proxy_auth_types);
+  } else {
+    curl_easy_setopt(curl, CURLOPT_PROXYAUTH, CURLAUTH_ANY);
 #else
-      rb_warn("Installed libcurl is too old to support proxy_auth_types");      
+    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.
+     */
+  if (rbce->enable_cookies) {
+    if (rbce->cookiejar != Qnil) {
+      curl_easy_setopt(curl, CURLOPT_COOKIEJAR, StringValuePtr(rbce->cookiejar));
+    } else {
+      curl_easy_setopt(curl, CURLOPT_COOKIEFILE, ""); /* "" = magic to just enable */
     }
-    
-    // Set up HTTP cookie handling if necessary
-    // FIXME this may not get disabled if it's enabled, the disabled again from ruby.
-    if (rbce->enable_cookies) {
-      if (rbce->cookiejar != Qnil) {
-        curl_easy_setopt(curl, CURLOPT_COOKIEJAR, StringValuePtr(rbce->cookiejar));
-      } else {
-        curl_easy_setopt(curl, CURLOPT_COOKIEFILE, ""); /* "" = magic to just enable */
-      }
-    }
-    
-    // Setup HTTP headers if necessary
-    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, NULL);   // clear
-    
-    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)&headers);        
-      } else {
-        VALUE headers_str = rb_obj_as_string(rbce->headers);
-        headers = curl_slist_append(headers, StringValuePtr(headers_str));
-      }
-      
-      if (headers) {
-        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
-      }
+  }
+
+  /* Set up HTTPS cert handling if necessary */
+  if (rbce->cert != Qnil) {
+    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 ((rb_type(rbce->headers) == T_ARRAY) || (rb_type(rbce->headers) == T_HASH)) {
+      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));
     }
     
-    // Okay, do it.
-    result = curl_easy_perform(curl);
-    
-    // Free everything up
-    if (headers) {
-      curl_slist_free_all(headers);
+    if (*hdrs) {
+      curl_easy_setopt(curl, CURLOPT_HTTPHEADER, *hdrs);
     }
-    
-    // Sort out the built-in body/header data.
-    if (bodybuf != Qnil) {
+  }
+
+  return Qnil;
+}
+/***********************************************
+ *
+ * Clean up a connection
+ *
+ * Always returns Qtrue.
+ */
+VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce, VALUE bodybuf, VALUE headerbuf, struct curl_slist *headers ) {
+
+  // Free everything up
+  if (headers) {
+    curl_slist_free_all(headers);
+    rbce->curl_headers = NULL;
+  }
+  
+  // Sort out the built-in body/header data.
+  if (bodybuf != Qnil) {
+    if (TYPE(bodybuf) == T_STRING) {
       rbce->body_data = rb_str_to_str(bodybuf);
-    } else {
+    }
+    else if (rb_respond_to(bodybuf, rb_intern("to_s"))) {
+      rbce->body_data = rb_funcall(bodybuf, rb_intern("to_s"), 0);
+    }
+    else {
       rbce->body_data = Qnil;
     }
+  } else {
+    rbce->body_data = Qnil;
+  }
 
-    if (headerbuf != Qnil) {
+  if (headerbuf != Qnil) {
+    if (TYPE(headerbuf) == T_STRING) {
       rbce->header_data = rb_str_to_str(headerbuf);
-    } else {
+    }
+    else if (rb_respond_to(headerbuf, rb_intern("to_s"))) {
+      rbce->header_data = rb_funcall(headerbuf, rb_intern("to_s"), 0);
+    }
+    else {
       rbce->header_data = Qnil;
     }
+  } else {
+    rbce->header_data = Qnil;
+  }
+
+  return Qnil;
+}
+
+/***********************************************
+ * 
+ * This is the main worker for the perform methods (get, post, head, put).
+ * It's not surfaced as a Ruby method - instead, the individual request
+ * methods are responsible for setting up stuff specific to that type,
+ * then calling this to handle common stuff and do the perform.
+ * 
+ * Always returns Qtrue, rb_raise on error.
+ * 
+ */
+static VALUE handle_perform(VALUE self, ruby_curl_easy *rbce) {  
+
+  int msgs;
+  int still_running = 1;
+  CURLcode result = -1;
+  CURLMcode mcode = -1;
+  CURLM *multi_handle = curl_multi_init();
+  struct curl_slist *headers = NULL;
+  VALUE bodybuf = Qnil, headerbuf = Qnil;
+//  char errors[CURL_ERROR_SIZE*2];
+
+  ruby_curl_easy_setup(rbce, &bodybuf, &headerbuf, &headers);
+//  curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, errors);
+//  curl_easy_setopt(rbce->curl, CURLOPT_VERBOSE, 1);
+
+//  if( rb_thread_alone() ) {
+//    result = curl_easy_perform(rbce->curl);
+//  }
+//  else {
+
+    /* NOTE:
+     * 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);
+    if (mcode != CURLM_CALL_MULTI_PERFORM && mcode != CURLM_OK) {
+      raise_curl_multi_error_exception(mcode);
+    }
 
-    if (result != 0) {
+    while(CURLM_CALL_MULTI_PERFORM == (mcode=curl_multi_perform(multi_handle, &still_running)) ) ;
+
+    if (mcode != CURLM_CALL_MULTI_PERFORM && mcode != CURLM_OK) {
+      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;
+      fd_set fdexcep;
+
+      FD_ZERO(&fdread);
+      FD_ZERO(&fdwrite);
+      FD_ZERO(&fdexcep);
+
+      //time_t timer = time(NULL);
+      /* get file descriptors from the transfers */
+      mcode = curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
+      if (mcode != CURLM_CALL_MULTI_PERFORM && mcode != CURLM_OK) {
+        raise_curl_multi_error_exception(mcode);
+      }
+
+      /* 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);
+      if (rc < 0) {
+        rb_raise(rb_eRuntimeError, "select(): %s", strerror(errno));
+      }
+   
+      if( rc >= 0 ) {
+        switch(rc) {
+        case 0:
+          //printf("timeout(%.6f) :", difftime(time(NULL), timer) );
+        default:
+          //printf("readable/writable: %d\n", rc);
+          /* timeout or readable/writable sockets */
+          while(CURLM_CALL_MULTI_PERFORM == (mcode=curl_multi_perform(multi_handle, &still_running)) );
+          break;
+        }
+      }
+      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) {
+      result = msg->data.result;
+    }
+
+    curl_multi_remove_handle(multi_handle, rbce->curl);
+    curl_multi_cleanup(multi_handle);
+//  }
+
+  ruby_curl_easy_cleanup(self, rbce, bodybuf, headerbuf, headers);
+  
+  if (rbce->complete_proc != Qnil) {
+    rb_funcall( rbce->complete_proc, idCall, 1, self );
+  }
+
+  /* check the request status and determine if on_success or on_failure should be called */
+  long response_code = -1;
+  curl_easy_getinfo(rbce->curl, CURLINFO_RESPONSE_CODE, &response_code);
+  if (result != 0) {
+//    printf("error: %s\n", errors);
+    if (rbce->failure_proc != Qnil) {
+      rb_funcall( rbce->failure_proc, idCall, 1, self );
+    } else {
       raise_curl_easy_error_exception(result);
     }
-  } else {
-    rb_raise(eCurlErrError, "No URL supplied");
   }
-  
+  else if (rbce->success_proc != Qnil &&
+           /* NOTE: we allow response_code == 0, in the case the file is being read from disk */
+           ((response_code >= 200 && response_code < 300) || response_code == 0)) {
+    rb_funcall( rbce->success_proc, idCall, 1, self );
+  }
+  else if (rbce->failure_proc != Qnil && 
+           (response_code >= 300 && response_code <= 999)) {
+    rb_funcall( rbce->failure_proc, idCall, 1, self );
+  }
+
   return Qtrue;
 }
 
@@ -1292,7 +1600,31 @@ static VALUE ruby_curl_easy_perform_get(VALUE self) {
   
   curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);
   
-  return handle_perform(rbce);
+  return handle_perform(self,rbce);
+}
+
+/*
+ * call-seq:
+ *   easy.http_delete
+ *
+ * DELETE the currently configured URL using the current options set for
+ * this Curl::Easy instance. This method always returns true, or raises
+ * an exception (defined under Curl::Err) on error.
+ */
+static VALUE ruby_curl_easy_perform_delete(VALUE self) {
+  ruby_curl_easy *rbce;
+  CURL *curl;
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  curl = rbce->curl;
+  
+  curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
+
+  VALUE retval = handle_perform(self,rbce);
+
+  curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, NULL);
+
+  return retval;
 }
 
 /*
@@ -1341,7 +1673,9 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
   rb_scan_args(argc, argv, "*", &args_ary);
   
   Data_Get_Struct(self, ruby_curl_easy, rbce);
-  curl = rbce->curl;
+  curl = curl_easy_duphandle(rbce->curl);
+  curl_easy_cleanup(rbce->curl);
+  rbce->curl = curl;
   
   if (rbce->multipart_form_post) {
     VALUE ret;
@@ -1359,7 +1693,7 @@ 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(rbce);    
+    ret = handle_perform(self,rbce);    
     curl_formfree(first);
     
     return ret;    
@@ -1378,7 +1712,7 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
       curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
       curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, len);
 
-      return handle_perform(rbce);
+      return handle_perform(self,rbce);
     }
   }
 }
@@ -1392,10 +1726,17 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
  * method always returns true, or raises an exception (defined under 
  * Curl::Err) on error.
  * 
- * TODO Not yet implemented
  */
-static VALUE ruby_curl_easy_perform_head(VALUE self) {  
-  rb_raise(eCurlErrError, "Not yet implemented");
+static VALUE ruby_curl_easy_perform_head(VALUE self) {
+  ruby_curl_easy *rbce;
+  CURL *curl;
+
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  curl = rbce->curl;
+
+  curl_easy_setopt(curl, CURLOPT_NOBODY, 1);
+
+  return handle_perform(self,rbce);
 }
 
 /*
@@ -1405,11 +1746,35 @@ static VALUE ruby_curl_easy_perform_head(VALUE self) {
  * 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.
- * 
- * TODO Not yet implemented
  */
-static VALUE ruby_curl_easy_perform_put(VALUE self) {  
-  rb_raise(eCurlErrError, "Not yet implemented");
+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);
+
+
+  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);
+
+  VALUE ret = handle_perform(self, rbce);
+  /* cleanup  */
+  curl_easy_setopt(curl, CURLOPT_UPLOAD, 0);
+  curl_easy_setopt(curl, CURLOPT_READFUNCTION, NULL);
+  curl_easy_setopt(curl, CURLOPT_READDATA, NULL);
+  curl_easy_setopt(curl, CURLOPT_INFILESIZE, 0);
+
+  return ret;
 }
 
 /* =================== DATA FUNCS =============== */
@@ -1477,7 +1842,7 @@ static VALUE ruby_curl_easy_response_code_get(VALUE self) {
   long code;
   
   Data_Get_Struct(self, ruby_curl_easy, rbce);  
-#ifdef CURLINFO_RESPONSE_CODE
+#ifdef HAVE_CURLINFO_RESPONSE_CODE
   curl_easy_getinfo(rbce->curl, CURLINFO_RESPONSE_CODE, &code);
 #else
   // old libcurl
@@ -1521,7 +1886,7 @@ static VALUE ruby_curl_easy_http_connect_code_get(VALUE self) {
  * returned.
  */
 static VALUE ruby_curl_easy_file_time_get(VALUE self) {
-#ifdef CURLINFO_FILETIME  
+#ifdef HAVE_CURLINFO_FILETIME
   ruby_curl_easy *rbce;
   long time;
   
@@ -1635,7 +2000,7 @@ static VALUE ruby_curl_easy_start_transfer_time_get(VALUE self) {
  * Requires libcurl 7.9.7 or higher, otherwise -1 is always returned.
  */
 static VALUE ruby_curl_easy_redirect_time_get(VALUE self) {
-#ifdef CURLINFO_REDIRECT_TIME
+#ifdef HAVE_CURLINFO_REDIRECT_TIME
   ruby_curl_easy *rbce;
   double time;
   
@@ -1658,7 +2023,7 @@ static VALUE ruby_curl_easy_redirect_time_get(VALUE self) {
  * Requires libcurl 7.9.7 or higher, otherwise -1 is always returned.
  */
 static VALUE ruby_curl_easy_redirect_count_get(VALUE self) {
-#ifdef CURLINFO_REDIRECT_COUNT
+#ifdef HAVE_CURLINFO_REDIRECT_COUNT
   ruby_curl_easy *rbce;
   long count;
   
@@ -1883,7 +2248,7 @@ Pass a pointer to a long to receive a bitmask indicating the authentication meth
  * libcurl 7.12.2 or higher, otherwise 0 is always returned).
  */
 static VALUE ruby_curl_easy_os_errno_get(VALUE self) {
-#ifdef CURLINFO_OS_ERRNO
+#ifdef HAVE_CURLINFO_OS_ERRNO
   ruby_curl_easy *rbce;
   long result;
   
@@ -1912,7 +2277,7 @@ static VALUE ruby_curl_easy_os_errno_get(VALUE self) {
  * (requires libcurl 7.12.3 or higher, otherwise -1 is always returned).
  */
 static VALUE ruby_curl_easy_num_connects_get(VALUE self) {
-#ifdef CURLINFO_NUM_CONNECTS
+#ifdef HAVE_CURLINFO_NUM_CONNECTS
   ruby_curl_easy *rbce;
   long result;
   
@@ -1953,14 +2318,14 @@ Pass a pointer to a long to receive the last socket used by this curl session. I
  * (requires libcurl 7.15.4 or higher, otherwise +nil+ is always returned).
  */
 static VALUE ruby_curl_easy_ftp_entry_path_get(VALUE self) {
-#ifdef CURLINFO_FTP_ENTRY_PATH
+#ifdef HAVE_CURLINFO_FTP_ENTRY_PATH
   ruby_curl_easy *rbce;
-  char* path;
+  char* path = NULL;
   
   Data_Get_Struct(self, ruby_curl_easy, rbce);  
   curl_easy_getinfo(rbce->curl, CURLINFO_FTP_ENTRY_PATH, &path);
   
-  if (type && type[0]) {    // curl returns NULL or empty string if none
+  if (path && path[0]) {    // curl returns NULL or empty string if none
     return rb_str_new2(path);
   } else {
     return Qnil;
@@ -2077,6 +2442,50 @@ static VALUE ruby_curl_easy_class_perform_get(int argc, VALUE *argv, VALUE klass
   return c;  
 }
 
+/*
+ * call-seq:
+ *   Curl::Easy.http_delete(url) { |easy| ... }          => #&lt;Curl::Easy...&gt;
+ *   
+ * Convenience method that creates a new Curl::Easy instance with 
+ * the specified URL and calls +http_delete+, before returning the new instance.
+ * 
+ * If a block is supplied, the new instance will be yielded just prior to
+ * the +http_delete+ call.
+ */
+static VALUE ruby_curl_easy_class_perform_delete(int argc, VALUE *argv, VALUE klass) {
+  VALUE c = ruby_curl_easy_new(argc, argv, klass);  
+  
+  if (rb_block_given_p()) {
+    rb_yield(c);
+  }
+  
+  ruby_curl_easy_perform_delete(c);
+  return c;
+}
+
+/*
+ * call-seq:
+ *   Curl::Easy.http_head(url) { |easy| ... }          => #&lt;Curl::Easy...&gt;
+ *
+ * Convenience method that creates a new Curl::Easy instance with
+ * the specified URL and calls +http_head+, before returning the new instance.
+ *
+ * If a block is supplied, the new instance will be yielded just prior to
+ * the +http_head+ call.
+ */
+static VALUE ruby_curl_easy_class_perform_head(int argc, VALUE *argv, VALUE klass) {
+  VALUE c = ruby_curl_easy_new(argc, argv, klass);
+
+  if (rb_block_given_p()) {
+    rb_yield(c);
+  }
+
+  ruby_curl_easy_perform_head(c);
+  return c;
+}
+
+// TODO: add convenience method for http_post
+
 /*
  * call-seq:
  *   Curl::Easy.http_post(url, "some=urlencoded%20form%20data&and=so%20on") => true
@@ -2123,8 +2532,10 @@ void init_curb_easy() {
   /* Class methods */
   rb_define_singleton_method(cCurlEasy, "new", ruby_curl_easy_new, -1);
   rb_define_singleton_method(cCurlEasy, "perform", ruby_curl_easy_class_perform, -1);
+  rb_define_singleton_method(cCurlEasy, "http_delete", ruby_curl_easy_class_perform_delete, -1);
   rb_define_singleton_method(cCurlEasy, "http_get", ruby_curl_easy_class_perform_get, -1);
   rb_define_singleton_method(cCurlEasy, "http_post", ruby_curl_easy_class_perform_post, -1);
+  rb_define_singleton_method(cCurlEasy, "http_head", ruby_curl_easy_class_perform_head, -1);
 
   /* Attributes for config next perform */
   rb_define_method(cCurlEasy, "url=", ruby_curl_easy_url_set, 1);
@@ -2141,6 +2552,10 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "proxypwd", ruby_curl_easy_proxypwd_get, 0);
   rb_define_method(cCurlEasy, "cookiejar=", ruby_curl_easy_cookiejar_set, 1);
   rb_define_method(cCurlEasy, "cookiejar", ruby_curl_easy_cookiejar_get, 0);
+  rb_define_method(cCurlEasy, "cert=", ruby_curl_easy_cert_set, 1);
+  rb_define_method(cCurlEasy, "cert", ruby_curl_easy_cert_get, 0);
+  rb_define_method(cCurlEasy, "encoding=", ruby_curl_easy_encoding_set, 1);
+  rb_define_method(cCurlEasy, "encoding", ruby_curl_easy_encoding_get, 0);
 
   rb_define_method(cCurlEasy, "local_port=", ruby_curl_easy_local_port_set, 1);
   rb_define_method(cCurlEasy, "local_port", ruby_curl_easy_local_port_get, 0);
@@ -2192,12 +2607,16 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "on_header", ruby_curl_easy_on_header_set, -1);
   rb_define_method(cCurlEasy, "on_progress", ruby_curl_easy_on_progress_set, -1);
   rb_define_method(cCurlEasy, "on_debug", ruby_curl_easy_on_debug_set, -1);
-  
+  rb_define_method(cCurlEasy, "on_success", ruby_curl_easy_on_success_set, -1);
+  rb_define_method(cCurlEasy, "on_failure", ruby_curl_easy_on_failure_set, -1);
+  rb_define_method(cCurlEasy, "on_complete", ruby_curl_easy_on_complete_set, -1);
+
   rb_define_method(cCurlEasy, "perform", ruby_curl_easy_perform, 0);
+  rb_define_method(cCurlEasy, "http_delete", ruby_curl_easy_perform_delete, 0);
   rb_define_method(cCurlEasy, "http_get", ruby_curl_easy_perform_get, 0);
   rb_define_method(cCurlEasy, "http_post", ruby_curl_easy_perform_post, -1);
   rb_define_method(cCurlEasy, "http_head", ruby_curl_easy_perform_head, 0);
-  rb_define_method(cCurlEasy, "http_put", ruby_curl_easy_perform_put, 0);
+  rb_define_method(cCurlEasy, "http_put", ruby_curl_easy_perform_put, 1);
 
   /* Post-perform info methods */
   rb_define_method(cCurlEasy, "body_str", ruby_curl_easy_body_str_get, 0);