ghazel-curb 0.6.1.0 → 0.6.2.1

data/ext/curb.h

@@ -20,11 +20,11 @@
 #include "curb_macros.h"
 
 // These should be managed from the Rake 'release' task.
-#define CURB_VERSION   "0.6.1.0"
-#define CURB_VER_NUM   610
+#define CURB_VERSION   "0.6.4.0"
+#define CURB_VER_NUM   640
 #define CURB_VER_MAJ   0
 #define CURB_VER_MIN   6
-#define CURB_VER_MIC   1
+#define CURB_VER_MIC   4
 #define CURB_VER_PATCH 0
 
 

data/ext/curb_easy.c

@@ -42,8 +42,9 @@ static size_t read_data_handler(void *ptr,
                                 size_t size,
                                 size_t nmemb,
                                 ruby_curl_easy *rbce) {
+  VALUE upload = rb_easy_get("upload");
   size_t read_bytes = (size*nmemb);
-  VALUE stream = ruby_curl_upload_stream_get(rbce->upload);
+  VALUE stream = ruby_curl_upload_stream_get(upload);
 
   if (rb_respond_to(stream, rb_intern("read"))) {//if (rb_respond_to(stream, rb_intern("to_s"))) {
     /* copy read_bytes from stream into ptr */
@@ -62,7 +63,7 @@ static size_t read_data_handler(void *ptr,
     size_t len;
     size_t remaining;
     char *str_ptr;
-    Data_Get_Struct(rbce->upload, ruby_curl_upload, rbcu);
+    Data_Get_Struct(upload, ruby_curl_upload, rbcu);
     str = rb_funcall(stream, rb_intern("to_s"), 0);
     len = RSTRING_LEN(str);
     remaining = len - rbcu->offset;
@@ -133,6 +134,7 @@ static int proc_debug_handler(CURL *curl,
 
 /* ================== MARK/FREE FUNC ==================*/
 void curl_easy_mark(ruby_curl_easy *rbce) {
+#if 0
   rb_gc_mark(rbce->url);
   rb_gc_mark(rbce->proxy_url);
   rb_gc_mark(rbce->body_proc);
@@ -143,6 +145,12 @@ void curl_easy_mark(ruby_curl_easy *rbce) {
   rb_gc_mark(rbce->debug_proc);
   rb_gc_mark(rbce->interface_hm);
   rb_gc_mark(rbce->userpwd);
+#if HAVE_CURLOPT_USERNAME
+  rb_gc_mark(rbce->username);
+#endif
+#if HAVE_CURLOPT_PASSWORD
+  rb_gc_mark(rbce->password);
+#endif
   rb_gc_mark(rbce->proxypwd);
   rb_gc_mark(rbce->headers);
   rb_gc_mark(rbce->cookies);
@@ -165,6 +173,8 @@ void curl_easy_mark(ruby_curl_easy *rbce) {
   if( rbce->upload != Qnil ) {
     rb_gc_mark(rbce->upload);
   }
+#endif
+  rb_gc_mark(rbce->opts);
 }
 
 void curl_easy_free(ruby_curl_easy *rbce) {
@@ -201,31 +211,11 @@ static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
   /* handler */
   rbce->curl = curl_easy_init();
 
-  /* assoc objects */
-  rbce->url = url;
-  rbce->proxy_url = Qnil;
-  rbce->body_data = Qnil;
-  rbce->body_proc = Qnil;
-  rbce->header_data = Qnil;
-  rbce->header_proc = Qnil;
-  rbce->progress_proc = Qnil;
-  rbce->debug_proc = Qnil;
-  rbce->interface_hm = Qnil;
-  rbce->userpwd = Qnil;
-  rbce->proxypwd = Qnil;
-  rbce->headers = rb_hash_new();
-  rbce->cookies = Qnil;
-  rbce->cookiefile = Qnil;
-  rbce->cookiejar = Qnil;
-  rbce->cert = Qnil;
-  rbce->cacert = Qnil;
-  rbce->certpassword = Qnil;
-  rbce->certtype = rb_str_new2("PEM");
-  rbce->encoding = Qnil;
-  rbce->useragent = Qnil;
-  rbce->success_proc = Qnil;
-  rbce->failure_proc = Qnil;
-  rbce->complete_proc = Qnil;
+  rbce->opts = rb_hash_new();
+
+  rb_easy_set("url", url);
+
+  rbce->curl_headers = NULL;
 
   /* various-typed opts */
   rbce->local_port = 0;
@@ -253,14 +243,6 @@ static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
   rbce->multipart_form_post = 0;
   rbce->enable_cookies = 0;
 
-  /* buffers */
-  rbce->postdata_buffer = Qnil;
-  rbce->bodybuf = Qnil;
-  rbce->headerbuf = Qnil;
-  rbce->curl_headers = NULL;
-
-  rbce->upload = Qnil;
-
   new_curl = Data_Wrap_Struct(klass, curl_easy_mark, curl_easy_free, rbce);
 
   /* set the new_curl pointer to the curl handle */
@@ -309,7 +291,7 @@ static VALUE ruby_curl_easy_clone(VALUE self) {
  * the URL between calls to +perform+.
  */
 static VALUE ruby_curl_easy_url_set(VALUE self, VALUE url) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, url);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, url);
 }
 
 /*
@@ -319,7 +301,7 @@ static VALUE ruby_curl_easy_url_set(VALUE self, VALUE 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);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, url);
 }
 
 /*
@@ -348,7 +330,7 @@ static VALUE ruby_curl_easy_url_get(VALUE self) {
  * proxy_url, including protocol prefix (http://) and embedded user + password.
   */
 static VALUE ruby_curl_easy_proxy_url_set(VALUE self, VALUE proxy_url) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, proxy_url);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, proxy_url);
 }
 
 /*
@@ -358,7 +340,7 @@ static VALUE ruby_curl_easy_proxy_url_set(VALUE self, VALUE proxy_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);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, proxy_url);
 }
 
 /*
@@ -384,7 +366,7 @@ static VALUE ruby_curl_easy_proxy_url_get(VALUE self) {
  * the perform step.
  */
 static VALUE ruby_curl_easy_headers_set(VALUE self, VALUE headers) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, headers);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, headers);
 }
 
 /*
@@ -394,7 +376,12 @@ static VALUE ruby_curl_easy_headers_set(VALUE self, VALUE headers) {
  * Obtain the custom HTTP headers for following requests.
  */
 static VALUE ruby_curl_easy_headers_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, headers);
+  ruby_curl_easy *rbce;
+  VALUE headers;
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  headers = rb_easy_get("headers");//rb_hash_aref(rbce->opts, rb_intern("headers")); 
+  if (headers == Qnil) { headers = rb_easy_set("headers", rb_hash_new()); }
+  return headers;
 }
 
 /*
@@ -405,7 +392,7 @@ static VALUE ruby_curl_easy_headers_get(VALUE self) {
  * The name can be an interface name, an IP address or a host name.
  */
 static VALUE ruby_curl_easy_interface_set(VALUE self, VALUE interface_hm) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, interface_hm);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, interface_hm);
 }
 
 /*
@@ -416,7 +403,7 @@ static VALUE ruby_curl_easy_interface_set(VALUE self, VALUE interface_hm) {
  * The name can be an interface name, an IP address or a host name.
  */
 static VALUE ruby_curl_easy_interface_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, interface_hm);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, interface_hm);
 }
 
 /*
@@ -427,7 +414,7 @@ static VALUE ruby_curl_easy_interface_get(VALUE self) {
  * The supplied string should have the form "username:password"
  */
 static VALUE ruby_curl_easy_userpwd_set(VALUE self, VALUE userpwd) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, userpwd);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, userpwd);
 }
 
 /*
@@ -438,7 +425,7 @@ static VALUE ruby_curl_easy_userpwd_set(VALUE self, VALUE userpwd) {
  * calls to +perform+.
  */
 static VALUE ruby_curl_easy_userpwd_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, userpwd);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, userpwd);
 }
 
 /*
@@ -450,7 +437,7 @@ static VALUE ruby_curl_easy_userpwd_get(VALUE self) {
  * form "username:password"
  */
 static VALUE ruby_curl_easy_proxypwd_set(VALUE self, VALUE proxypwd) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, proxypwd);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, proxypwd);
 }
 
 /*
@@ -462,7 +449,7 @@ static VALUE ruby_curl_easy_proxypwd_set(VALUE self, VALUE proxypwd) {
  * should have the form "username:password"
  */
 static VALUE ruby_curl_easy_proxypwd_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, proxypwd);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, proxypwd);
 }
 
 
@@ -475,7 +462,7 @@ static VALUE ruby_curl_easy_proxypwd_get(VALUE self) {
  * Set multiple cookies in one string like this: "name1=content1; name2=content2;" etc.
  */
 static VALUE ruby_curl_easy_cookies_set(VALUE self, VALUE cookies) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, cookies);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, cookies);
 }
 
 /*
@@ -485,7 +472,7 @@ static VALUE ruby_curl_easy_cookies_set(VALUE self, VALUE cookies) {
  * Obtain the cookies for this Curl::Easy instance.
  */
 static VALUE ruby_curl_easy_cookies_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, cookies);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, cookies);
 }
 
 /*
@@ -498,7 +485,7 @@ static VALUE ruby_curl_easy_cookies_get(VALUE self) {
  * engine, or this option will be ignored.
  */
 static VALUE ruby_curl_easy_cookiefile_set(VALUE self, VALUE cookiefile) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, cookiefile);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, cookiefile);
 }
 
 /*
@@ -508,7 +495,7 @@ static VALUE ruby_curl_easy_cookiefile_set(VALUE self, VALUE cookiefile) {
  * Obtain the cookiefile file for this Curl::Easy instance.
  */
 static VALUE ruby_curl_easy_cookiefile_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, cookiefile);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, cookiefile);
 }
 
 /*
@@ -522,7 +509,7 @@ static VALUE ruby_curl_easy_cookiefile_get(VALUE self) {
  * engine, or this option will be ignored.
  */
 static VALUE ruby_curl_easy_cookiejar_set(VALUE self, VALUE cookiejar) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, cookiejar);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, cookiejar);
 }
 
 /*
@@ -532,7 +519,7 @@ static VALUE ruby_curl_easy_cookiejar_set(VALUE self, VALUE cookiejar) {
  * Obtain the cookiejar file to use for this Curl::Easy instance.
  */
 static VALUE ruby_curl_easy_cookiejar_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, cookiejar);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, cookiejar);
 }
 
 /*
@@ -544,7 +531,7 @@ static VALUE ruby_curl_easy_cookiejar_get(VALUE self) {
  *
  */
 static VALUE ruby_curl_easy_cert_set(VALUE self, VALUE cert) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, cert);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, cert);
 }
 
 /*
@@ -554,7 +541,7 @@ static VALUE ruby_curl_easy_cert_set(VALUE self, VALUE cert) {
  * Obtain the cert file to use for this Curl::Easy instance.
  */
 static VALUE ruby_curl_easy_cert_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, cert);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, cert);
 }
 
 /*
@@ -566,7 +553,7 @@ static VALUE ruby_curl_easy_cert_get(VALUE self) {
  *
  */
 static VALUE ruby_curl_easy_cacert_set(VALUE self, VALUE cacert) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, cacert);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, cacert);
 }
 
 /*
@@ -576,7 +563,7 @@ static VALUE ruby_curl_easy_cacert_set(VALUE self, VALUE cacert) {
  * Obtain the cacert file to use for this Curl::Easy instance.
  */
 static VALUE ruby_curl_easy_cacert_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, cacert);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, cacert);
 }
 
 /*
@@ -586,7 +573,7 @@ static VALUE ruby_curl_easy_cacert_get(VALUE self) {
  * Set a password used to open the specified cert
  */
 static VALUE ruby_curl_easy_certpassword_set(VALUE self, VALUE certpassword) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, certpassword);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, certpassword);
 }
 
 /*
@@ -598,7 +585,7 @@ static VALUE ruby_curl_easy_certpassword_set(VALUE self, VALUE certpassword) {
  *
  */
 static VALUE ruby_curl_easy_certtype_set(VALUE self, VALUE certtype) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, certtype);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, certtype);
 }
 
 /*
@@ -608,7 +595,7 @@ static VALUE ruby_curl_easy_certtype_set(VALUE self, VALUE certtype) {
  * Obtain the cert type used for this Curl::Easy instance
  */
 static VALUE ruby_curl_easy_certtype_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, certtype);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, certtype);
 }
 
 /*
@@ -619,7 +606,7 @@ static VALUE ruby_curl_easy_certtype_get(VALUE self) {
  *
  */
 static VALUE ruby_curl_easy_encoding_set(VALUE self, VALUE encoding) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, encoding);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, encoding);
 }
 /*
  * call-seq:
@@ -629,7 +616,7 @@ static VALUE ruby_curl_easy_encoding_set(VALUE self, VALUE encoding) {
  *
 */
 static VALUE ruby_curl_easy_encoding_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, encoding);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, encoding);
 }
 
 /*
@@ -640,7 +627,7 @@ static VALUE ruby_curl_easy_encoding_get(VALUE self) {
  *
  */
 static VALUE ruby_curl_easy_useragent_set(VALUE self, VALUE useragent) {
-  CURB_OBJECT_SETTER(ruby_curl_easy, useragent);
+  CURB_OBJECT_HSETTER(ruby_curl_easy, useragent);
 }
 
 /*
@@ -650,7 +637,7 @@ static VALUE ruby_curl_easy_useragent_set(VALUE self, VALUE useragent) {
  * Obtain the user agent string used for this Curl::Easy instance
  */
 static VALUE ruby_curl_easy_useragent_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, useragent);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, useragent);
 }
 
 /*
@@ -675,7 +662,8 @@ static VALUE ruby_curl_easy_post_body_set(VALUE self, VALUE post_body) {
   curl = rbce->curl;
   
   if ( post_body == Qnil ) {
-    rbce->postdata_buffer = Qnil;
+    //rbce->postdata_buffer = Qnil;
+    rb_easy_del("postdata_buffer");
     
   } else {  
     data = StringValuePtr(post_body);
@@ -683,7 +671,8 @@ static VALUE ruby_curl_easy_post_body_set(VALUE self, VALUE post_body) {
   
     // Store the string, since it has to hang around for the duration of the 
     // request.  See CURLOPT_POSTFIELDS in the libcurl docs.
-    rbce->postdata_buffer = post_body;
+    //rbce->postdata_buffer = post_body;
+    rb_easy_set("postdata_buffer", post_body);
   
     curl_easy_setopt(curl, CURLOPT_POST, 1);
     curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
@@ -702,7 +691,7 @@ static VALUE ruby_curl_easy_post_body_set(VALUE self, VALUE post_body) {
  * Obtain the POST body used in this Curl::Easy instance.
  */
 static VALUE ruby_curl_easy_post_body_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, postdata_buffer);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, postdata_buffer);
 }
 
 /*
@@ -724,9 +713,9 @@ static VALUE ruby_curl_easy_put_data_set(VALUE self, VALUE data) {
   ruby_curl_upload_stream_set(upload,data);
 
   curl = rbce->curl;
-  rbce->upload = upload; /* keep the upload object alive as long as
-                            the easy handle is active or until the upload
-                            is complete or terminated... */
+  rb_easy_set("upload", upload); /* keep the upload object alive as long as
+                                    the easy handle is active or until the upload
+                                    is complete or terminated... */
 
   curl_easy_setopt(curl, CURLOPT_NOBODY,0);
   curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
@@ -737,35 +726,40 @@ static VALUE ruby_curl_easy_put_data_set(VALUE self, VALUE data) {
    * we need to set specific headers for the PUT to work... so
    * convert the internal headers structure to a HASH if one is set
    */
-  if (rbce->headers != Qnil) {
-    if (rb_type(rbce->headers) == T_ARRAY || rb_type(rbce->headers) == T_STRING) {
+  if (!rb_easy_nil("headers")) {
+    if (rb_easy_type_check("headers", T_ARRAY) || rb_easy_type_check("headers", T_STRING)) {
       rb_raise(rb_eRuntimeError, "Must set headers as a HASH to modify the headers in an PUT request");
     }
   }
 
+  VALUE headers = rb_easy_get("headers");
+  if( headers == Qnil ) { 
+    headers = rb_hash_new();
+  }
   if (rb_respond_to(data, rb_intern("read"))) {
     VALUE stat = rb_funcall(data, rb_intern("stat"), 0);
     if( stat ) {
       VALUE size;
-      if( rb_hash_aref(rbce->headers, rb_str_new2("Expect")) == Qnil ) {
-        rb_hash_aset(rbce->headers, rb_str_new2("Expect"), rb_str_new2(""));
+      if( rb_hash_aref(headers, rb_str_new2("Expect")) == Qnil ) {
+        rb_hash_aset(headers, rb_str_new2("Expect"), rb_str_new2(""));
       }
       size = rb_funcall(stat, rb_intern("size"), 0);
       curl_easy_setopt(curl, CURLOPT_INFILESIZE, FIX2INT(size));
     }
-    else if( rb_hash_aref(rbce->headers, rb_str_new2("Transfer-Encoding")) == Qnil ) {
-      rb_hash_aset(rbce->headers, rb_str_new2("Transfer-Encoding"), rb_str_new2("chunked"));
+    else if( rb_hash_aref(headers, rb_str_new2("Transfer-Encoding")) == Qnil ) {
+      rb_hash_aset(headers, rb_str_new2("Transfer-Encoding"), rb_str_new2("chunked"));
     }
   }
   else if (rb_respond_to(data, rb_intern("to_s"))) {
     curl_easy_setopt(curl, CURLOPT_INFILESIZE, RSTRING_LEN(data));
-    if( rb_hash_aref(rbce->headers, rb_str_new2("Expect")) == Qnil ) {
-      rb_hash_aset(rbce->headers, rb_str_new2("Expect"), rb_str_new2(""));
+    if( rb_hash_aref(headers, rb_str_new2("Expect")) == Qnil ) {
+      rb_hash_aset(headers, rb_str_new2("Expect"), rb_str_new2(""));
     }
   }
   else {
     rb_raise(rb_eRuntimeError, "PUT data must respond to read or to_s");
   }
+  rb_easy_set("headers",headers);
   
   // if we made it this far, all should be well.
   return data;
@@ -872,16 +866,61 @@ static VALUE ruby_curl_easy_proxy_type_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, proxy_type, -1);
 }
 
+#if defined(HAVE_CURLAUTH_DIGEST_IE)
+#define CURL_HTTPAUTH_STR_TO_NUM(node) \
+  (!strncmp("basic",node,5)) ? CURLAUTH_BASIC : \
+  (!strncmp("digest_ie",node,9)) ? CURLAUTH_DIGEST_IE : \
+  (!strncmp("digest",node,6)) ? CURLAUTH_DIGEST : \
+  (!strncmp("gssnegotiate",node,12)) ? CURLAUTH_GSSNEGOTIATE : \
+  (!strncmp("ntlm",node,4)) ? CURLAUTH_NTLM : \
+  (!strncmp("any",node,3)) ? CURLAUTH_ANY : \
+  (!strncmp("anysafe",node,7)) ? CURLAUTH_ANYSAFE : 0
+#else 
+#define CURL_HTTPAUTH_STR_TO_NUM(node) \
+  (!strncmp("basic",node,5)) ? CURLAUTH_BASIC : \
+  (!strncmp("digest",node,6)) ? CURLAUTH_DIGEST : \
+  (!strncmp("gssnegotiate",node,12)) ? CURLAUTH_GSSNEGOTIATE : \
+  (!strncmp("ntlm",node,4)) ? CURLAUTH_NTLM : \
+  (!strncmp("any",node,3)) ? CURLAUTH_ANY : \
+  (!strncmp("anysafe",node,7)) ? CURLAUTH_ANYSAFE : 0
+#endif
 /*
  * call-seq:
  *   easy.http_auth_types = fixnum or nil             => fixnum or nil
+ *   easy.http_auth_types = [:basic,:digest,:digest_ie,:gssnegotiate, :ntlm, :any, :anysafe]
  *
  * Set the HTTP authentication types that may be used for the following
  * +perform+ calls. This is a bitmap made by ORing together the
  * Curl::CURLAUTH constants.
  */
-static VALUE ruby_curl_easy_http_auth_types_set(VALUE self, VALUE http_auth_types) {
-  CURB_IMMED_SETTER(ruby_curl_easy, http_auth_types, 0);
+static VALUE ruby_curl_easy_http_auth_types_set(int argc, VALUE *argv, VALUE self) {//VALUE self, VALUE http_auth_types) {
+  ruby_curl_easy *rbce;
+  VALUE args_ary;
+  rb_scan_args(argc, argv, "*", &args_ary);
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  int i, len = RARRAY_LEN(args_ary);
+  char* node = NULL;
+  long mask = 0x000000;
+
+  if (len == 1 && (TYPE(rb_ary_entry(args_ary,0)) == T_FIXNUM || rb_ary_entry(args_ary,0) == Qnil)) {
+    if (rb_ary_entry(args_ary,0) == Qnil) { 
+      rbce->http_auth_types = 0;
+    }
+    else {
+      rbce->http_auth_types = NUM2INT(rb_ary_entry(args_ary,0));
+    }
+  }
+  else {
+    // we could have multiple values, but they should be symbols
+    node = RSTRING_PTR(rb_funcall(rb_ary_entry(args_ary,0),rb_intern("to_s"),0));
+    mask = CURL_HTTPAUTH_STR_TO_NUM(node);
+    for( i = 1; i < len; ++i ) {
+      node = RSTRING_PTR(rb_funcall(rb_ary_entry(args_ary,i),rb_intern("to_s"),0));
+      mask |= CURL_HTTPAUTH_STR_TO_NUM(node);
+    }
+    rbce->http_auth_types = mask;
+  }
+  return INT2NUM(rbce->http_auth_types);
 }
 
 /*
@@ -1047,6 +1086,62 @@ static VALUE ruby_curl_easy_ftp_response_timeout_get(VALUE self, VALUE ftp_respo
   CURB_IMMED_GETTER(ruby_curl_easy, ftp_response_timeout, 0);
 }
 
+/*
+ * call-seq:
+ *   easy.username = "foo"  => String
+ *
+ * Set the HTTP Authentication username.
+ */
+static VALUE ruby_curl_easy_username_set(VALUE self, VALUE username) {
+#if HAVE_CURLOPT_USERNAME
+  CURB_OBJECT_HSETTER(ruby_curl_easy, username);
+#else
+  return Qnil;
+#endif
+}
+
+/*
+ * call-seq:
+ *   easy.username   => String
+ * 
+ * Get the current username
+ */
+static VALUE ruby_curl_easy_username_get(VALUE self, VALUE username) {
+#if HAVE_CURLOPT_USERNAME
+  CURB_OBJECT_HGETTER(ruby_curl_easy, username);
+#else
+  return Qnil;
+#endif
+}
+
+/*
+ * call-seq:
+ *   easy.password = "foo"  => String
+ *
+ * Set the HTTP Authentication password.
+ */
+static VALUE ruby_curl_easy_password_set(VALUE self, VALUE password) {
+#if HAVE_CURLOPT_PASSWORD
+  CURB_OBJECT_HSETTER(ruby_curl_easy, password);
+#else
+  return Qnil;
+#endif
+}
+
+/*
+ * call-seq:
+ *   easy.password   => String
+ * 
+ * Get the current password
+ */
+static VALUE ruby_curl_easy_password_get(VALUE self, VALUE password) {
+#if HAVE_CURLOPT_PASSWORD
+  CURB_OBJECT_HGETTER(ruby_curl_easy, password);
+#else
+  return Qnil;
+#endif
+}
+
 /* ================== BOOL ATTRS ===================*/
 
 /*
@@ -1330,12 +1425,12 @@ static VALUE ruby_curl_easy_enable_cookies_q(VALUE self) {
  * the processing with a Curl::Err::AbortedByCallbackError.
  */
 static VALUE ruby_curl_easy_on_body_set(int argc, VALUE *argv, VALUE self) {
-  CURB_HANDLER_PROC_SETTER(ruby_curl_easy, body_proc);
+  CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, body_proc);
 }
 
 /*
  * call-seq:
- *   easy.on_success { ... }                 => &lt;old handler&gt;
+ *   easy.on_success { |easy| ... }                 => &lt;old handler&gt;
  *
  * Assign or remove the +on_success+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1345,12 +1440,12 @@ static VALUE ruby_curl_easy_on_body_set(int argc, VALUE *argv, VALUE self) {
  * status of 20x
  */
 static VALUE ruby_curl_easy_on_success_set(int argc, VALUE *argv, VALUE self) {
-  CURB_HANDLER_PROC_SETTER(ruby_curl_easy, success_proc);
+  CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, success_proc);
 }
 
 /*
  * call-seq:
- *   easy.on_failure { ... }                 => &lt;old handler&gt;
+ *   easy.on_failure {|easy,code| ... }                 => &lt;old handler&gt;
  *
  * Assign or remove the +on_failure+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1360,12 +1455,12 @@ static VALUE ruby_curl_easy_on_success_set(int argc, VALUE *argv, VALUE self) {
  * status of 50x
  */
 static VALUE ruby_curl_easy_on_failure_set(int argc, VALUE *argv, VALUE self) {
-  CURB_HANDLER_PROC_SETTER(ruby_curl_easy, failure_proc);
+  CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, failure_proc);
 }
 
 /*
  * call-seq:
- *   easy.on_complete { ... }                 => &lt;old handler&gt;
+ *   easy.on_complete {|easy| ... }                 => &lt;old handler&gt;
  *
  * Assign or remove the +on_complete+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1374,7 +1469,7 @@ static VALUE ruby_curl_easy_on_failure_set(int argc, VALUE *argv, VALUE self) {
  * The +on_complete+ handler is called when the request is finished.
  */
 static VALUE ruby_curl_easy_on_complete_set(int argc, VALUE *argv, VALUE self) {
-  CURB_HANDLER_PROC_SETTER(ruby_curl_easy, complete_proc);
+  CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, complete_proc);
 }
 
 /*
@@ -1390,7 +1485,7 @@ static VALUE ruby_curl_easy_on_complete_set(int argc, VALUE *argv, VALUE self) {
  * block supplied to +on_body+.
  */
 static VALUE ruby_curl_easy_on_header_set(int argc, VALUE *argv, VALUE self) {
-  CURB_HANDLER_PROC_SETTER(ruby_curl_easy, header_proc);
+  CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, header_proc);
 }
 
 /*
@@ -1411,7 +1506,7 @@ static VALUE ruby_curl_easy_on_header_set(int argc, VALUE *argv, VALUE self) {
  * throwing a Curl::Err::AbortedByCallbackError.
  */
 static VALUE ruby_curl_easy_on_progress_set(int argc, VALUE *argv, VALUE self) {
-  CURB_HANDLER_PROC_SETTER(ruby_curl_easy, progress_proc);
+  CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, progress_proc);
 }
 
 /*
@@ -1432,7 +1527,7 @@ static VALUE ruby_curl_easy_on_progress_set(int argc, VALUE *argv, VALUE self) {
  * data. The data is passed as a String.
  */
 static VALUE ruby_curl_easy_on_debug_set(int argc, VALUE *argv, VALUE self) {
-  CURB_HANDLER_PROC_SETTER(ruby_curl_easy, debug_proc);
+  CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, debug_proc);
 }
 
 
@@ -1473,85 +1568,105 @@ static VALUE cb_each_http_header(VALUE header, struct curl_slist **list) {
  *
  * Always returns Qtrue, rb_raise on error.
  */
-VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *header_buffer, struct curl_slist **hdrs ) {
+VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, struct curl_slist **hdrs ) {
   // TODO this could do with a bit of refactoring...
   CURL *curl;
-  VALUE url;
+  VALUE url, _url = rb_easy_get("url");
 
   curl = rbce->curl;
 
-  if (rbce->url == Qnil) {
+  if (_url == Qnil) {
     rb_raise(eCurlErrError, "No URL supplied");
   }
 
-  url = rb_check_string_type(rbce->url);
+  url = rb_check_string_type(_url);
 
   // Need to configure the handler as per settings in rbce
   curl_easy_setopt(curl, CURLOPT_URL, StringValuePtr(url));
 
   // network stuff and auth
-  if (rbce->interface_hm != Qnil) {
-    curl_easy_setopt(curl, CURLOPT_INTERFACE, StringValuePtr(rbce->interface_hm));
+  if (!rb_easy_nil("interface_hm")) {
+    curl_easy_setopt(curl, CURLOPT_INTERFACE, rb_easy_get_str("interface_hm"));
   } else {
     curl_easy_setopt(curl, CURLOPT_INTERFACE, NULL);
   }
 
-  if (rbce->userpwd != Qnil) {
-    curl_easy_setopt(curl, CURLOPT_USERPWD, StringValuePtr(rbce->userpwd));
+#if HAVE_CURLOPT_USERNAME == 1 && HAVE_CURLOPT_PASSWORD == 1
+  if (!rb_easy_nil("username")) {
+    curl_easy_setopt(curl, CURLOPT_USERNAME, rb_easy_get_str("username"));
+  } else {
+    curl_easy_setopt(curl, CURLOPT_USERNAME, NULL);
+  }
+  if (!rb_easy_nil("password")) {
+    curl_easy_setopt(curl, CURLOPT_PASSWORD, rb_easy_get_str("password"));
+  }
+  else {
+    curl_easy_setopt(curl, CURLOPT_PASSWORD, NULL);
+  }
+#endif
+
+  if (!rb_easy_nil("userpwd")) {
+    curl_easy_setopt(curl, CURLOPT_USERPWD, rb_easy_get_str("userpwd"));
+#if HAVE_CURLOPT_USERNAME == 1
+  } else if (rb_easy_nil("username") && rb_easy_nil("password")) { /* don't set this even to NULL if we have set username and password */
+#else
   } else {
+#endif
     curl_easy_setopt(curl, CURLOPT_USERPWD, NULL);
   }
 
-  if (rbce->proxy_url != Qnil) {
-    curl_easy_setopt(curl, CURLOPT_PROXY, StringValuePtr(rbce->proxy_url));
+  if (!rb_easy_nil("proxy_url")) {
+    curl_easy_setopt(curl, CURLOPT_PROXY, rb_easy_get_str("proxy_url"));
   } else {
     curl_easy_setopt(curl, CURLOPT_PROXY, NULL);
   }
 
-  if (rbce->proxypwd != Qnil) {
-    curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, StringValuePtr(rbce->proxypwd));
+  if (!rb_easy_nil("proxypwd")) {
+    curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, rb_easy_get_str("proxy_pwd"));
   } else {
     curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, NULL);
   }
 
   // body/header procs
-  if (rbce->body_proc != Qnil) {
-    *body_buffer = Qnil;
+  if (!rb_easy_nil("body_proc")) {
     curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)&proc_data_handler);
-    curl_easy_setopt(curl, CURLOPT_WRITEDATA, rbce->body_proc);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, rb_easy_get("body_proc"));//rbce->body_proc);
+    /* clear out the body_data if it was set */
+    rb_easy_del("body_data");
   } else {
-    *body_buffer = rb_str_buf_new(32768);
+    VALUE body_buffer = rb_easy_set("body_data", rb_str_buf_new(32768));
     curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)&default_data_handler);
-    curl_easy_setopt(curl, CURLOPT_WRITEDATA, *body_buffer);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, body_buffer);
   }
 
-  if (rbce->header_proc != Qnil) {
-    *header_buffer = Qnil;
+  if (!rb_easy_nil("header_proc")) {
     curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, (curl_write_callback)&proc_data_handler);
-    curl_easy_setopt(curl, CURLOPT_HEADERDATA, rbce->header_proc);
+    curl_easy_setopt(curl, CURLOPT_HEADERDATA, rb_easy_get("header_proc"));
+    /* clear out the header_data if it was set */
+    rb_easy_del("header_data");
   } else {
-    *header_buffer = rb_str_buf_new(32768);
+    VALUE header_buffer = rb_easy_set("header_data", rb_str_buf_new(16384));
     curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, (curl_write_callback)&default_data_handler);
-    curl_easy_setopt(curl, CURLOPT_HEADERDATA, *header_buffer);
+    curl_easy_setopt(curl, CURLOPT_HEADERDATA, header_buffer);
   }
 
   /* encoding */
-  if (rbce->encoding != Qnil) {
-    curl_easy_setopt(curl, CURLOPT_ENCODING, StringValuePtr(rbce->encoding));
+  if (!rb_easy_nil("encoding")) {
+    curl_easy_setopt(curl, CURLOPT_ENCODING, rb_easy_get_str("encoding"));
   }
 
   // progress and debug procs
-  if (rbce->progress_proc != Qnil) {
+  if (!rb_easy_nil("progress_proc")) {
     curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, (curl_progress_callback)&proc_progress_handler);
-    curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, rbce->progress_proc);
+    curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, rb_easy_get("progress_proc"));
     curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
   } else {
     curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1);
   }
 
-  if (rbce->debug_proc != Qnil) {
+  if (!rb_easy_nil("debug_proc")) {
     curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, (curl_debug_callback)&proc_debug_handler);
-    curl_easy_setopt(curl, CURLOPT_DEBUGDATA, rbce->debug_proc);
+    curl_easy_setopt(curl, CURLOPT_DEBUGDATA, rb_easy_get("debug_proc"));
     curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
   } else {
     // have to remove handler to re-enable standard verbosity
@@ -1648,30 +1763,30 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
      FIXME this may not get disabled if it's enabled, the disabled again from ruby.
      */
   if (rbce->enable_cookies) {
-    if (rbce->cookiejar != Qnil) {
-      curl_easy_setopt(curl, CURLOPT_COOKIEJAR, StringValuePtr(rbce->cookiejar));
+    if (!rb_easy_nil("cookiejar")) {
+      curl_easy_setopt(curl, CURLOPT_COOKIEJAR, rb_easy_get_str("cookiejar"));
     }
 
-    if (rbce->cookiefile != Qnil) {
-      curl_easy_setopt(curl, CURLOPT_COOKIEFILE, StringValuePtr(rbce->cookiefile));
+    if (!rb_easy_nil("cookiefile")) {
+      curl_easy_setopt(curl, CURLOPT_COOKIEFILE, rb_easy_get_str("cookiefile"));
     } else {
       curl_easy_setopt(curl, CURLOPT_COOKIEFILE, ""); /* "" = magic to just enable */
     }
   }
 
-  if (rbce->cookies != Qnil) {
-    curl_easy_setopt(curl, CURLOPT_COOKIE, StringValuePtr(rbce->cookies));
+  if (!rb_easy_nil("cookies")) {
+    curl_easy_setopt(curl, CURLOPT_COOKIE, rb_easy_get_str("cookies"));
   }
 
   /* Set up HTTPS cert handling if necessary */
-  if (rbce->cert != Qnil) {
-    curl_easy_setopt(curl, CURLOPT_SSLCERTTYPE, StringValuePtr(rbce->certtype));
-    curl_easy_setopt(curl, CURLOPT_SSLCERT, StringValuePtr(rbce->cert));
-    if (rbce->certpassword != Qnil) {
-      curl_easy_setopt(curl, CURLOPT_SSLCERTPASSWD, StringValuePtr(rbce->certpassword));
+  if (!rb_easy_nil("cert")) {
+    curl_easy_setopt(curl, CURLOPT_SSLCERTTYPE, rb_easy_get_str("certtype"));
+    curl_easy_setopt(curl, CURLOPT_SSLCERT, rb_easy_get_str("cert"));
+    if (!rb_easy_nil("certpassword")) {
+      curl_easy_setopt(curl, CURLOPT_SSLCERTPASSWD, rb_easy_get_str("certpassword"));
     }
   }
-  if (rbce->cacert != Qnil) {
+  if (!rb_easy_nil("cacert")) {
 #ifdef HAVE_CURL_CONFIG_CA
     curl_easy_setopt(curl, CURLOPT_CAINFO, CURL_CONFIG_CA);
 #else
@@ -1680,18 +1795,18 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
   }
   
   /* Set the user-agent string if specified */
-  if (rbce->useragent != Qnil) {
-    curl_easy_setopt(curl, CURLOPT_USERAGENT, StringValuePtr(rbce->useragent));
+  if (!rb_easy_nil("useragent")) {
+    curl_easy_setopt(curl, CURLOPT_USERAGENT, rb_easy_get_str("useragent"));
   }
 
   /* Setup HTTP headers if necessary */
   curl_easy_setopt(curl, CURLOPT_HTTPHEADER, NULL);   // XXX: maybe we shouldn't be clearing this?
 
-  if (rbce->headers != Qnil) {
-    if ((rb_type(rbce->headers) == T_ARRAY) || (rb_type(rbce->headers) == T_HASH)) {
-      rb_iterate(rb_each, rbce->headers, cb_each_http_header, (VALUE)hdrs);
+  if (!rb_easy_nil("headers")) {
+    if (rb_easy_type_check("headers", T_ARRAY) || rb_easy_type_check("headers", T_HASH)) {
+      rb_iterate(rb_each, rb_easy_get("headers"), cb_each_http_header, (VALUE)hdrs);
     } else {
-      VALUE headers_str = rb_obj_as_string(rbce->headers);
+      VALUE headers_str = rb_obj_as_string(rb_easy_get("headers"));
       *hdrs = curl_slist_append(*hdrs, StringValuePtr(headers_str));
     }
 
@@ -1708,7 +1823,7 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
  *
  * Always returns Qtrue.
  */
-VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce, VALUE bodybuf, VALUE headerbuf, struct curl_slist *headers ) {
+VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce, struct curl_slist *headers ) {
 
   CURL *curl = rbce->curl;
   
@@ -1718,38 +1833,9 @@ VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce, VALUE bodybuf, V
     rbce->curl_headers = NULL;
   }
 
-  // Sort out the built-in body/header data.
-  if (bodybuf != Qnil) {
-    if (TYPE(bodybuf) == T_STRING) {
-      rbce->body_data = rb_str_to_str(bodybuf);
-    }
-    else if (rb_respond_to(bodybuf, rb_intern("to_s"))) {
-      rbce->body_data = rb_funcall(bodybuf, rb_intern("to_s"), 0);
-    }
-    else {
-      rbce->body_data = Qnil;
-    }
-  } else {
-    rbce->body_data = Qnil;
-  }
-
-  if (headerbuf != Qnil) {
-    if (TYPE(headerbuf) == T_STRING) {
-      rbce->header_data = rb_str_to_str(headerbuf);
-    }
-    else if (rb_respond_to(headerbuf, rb_intern("to_s"))) {
-      rbce->header_data = rb_funcall(headerbuf, rb_intern("to_s"), 0);
-    }
-    else {
-      rbce->header_data = Qnil;
-    }
-  } else {
-    rbce->header_data = Qnil;
-  }
-  
   // clean up a PUT request's curl options.
-  if (rbce->upload != Qnil) {
-    rbce->upload = Qnil; // set the upload object to Qnil to let the GC clean up
+  if (!rb_easy_nil("upload")) {
+    rb_easy_del("upload"); // set the upload object to Qnil to let the GC clean up
     curl_easy_setopt(curl, CURLOPT_UPLOAD, 0);
     curl_easy_setopt(curl, CURLOPT_READFUNCTION, NULL);
     curl_easy_setopt(curl, CURLOPT_READDATA, NULL);
@@ -1778,7 +1864,7 @@ static VALUE handle_perform(VALUE self, ruby_curl_easy *rbce) {
   ret = rb_funcall(multi, rb_intern("perform"), 0);
 
   /* check for errors in the easy response and raise exceptions if anything went wrong and their is no on_failure handler */
-  if( rbce->last_result != 0 && rbce->failure_proc == Qnil ) {
+  if (rbce->last_result != 0 && rb_easy_nil("failure_proc")) {
     raise_curl_easy_error_exception(rbce->last_result);
   }
 
@@ -2026,7 +2112,7 @@ static VALUE ruby_curl_easy_class_perform_put(VALUE klass, VALUE url, VALUE data
  * your own body handler, this string will be empty.
  */
 static VALUE ruby_curl_easy_body_str_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, body_data);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, body_data);
 }
 
 /*
@@ -2038,7 +2124,7 @@ static VALUE ruby_curl_easy_body_str_get(VALUE self) {
  * your own header handler, this string will be empty.
  */
 static VALUE ruby_curl_easy_header_str_get(VALUE self) {
-  CURB_OBJECT_GETTER(ruby_curl_easy, header_data);
+  CURB_OBJECT_HGETTER(ruby_curl_easy, header_data);
 }
 
 
@@ -2583,11 +2669,12 @@ static VALUE ruby_curl_easy_inspect(VALUE self) {
   ruby_curl_easy *rbce;
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   /* if we don't have a url set... we'll crash... */
-  if(rbce->url != Qnil && rb_type(rbce->url) == T_STRING) {
-    size_t len = 13+((RSTRING_LEN(rbce->url) > 50) ? 50 : RSTRING_LEN(rbce->url));
+  if( !rb_easy_nil("url") && rb_easy_type_check("url", T_STRING)) {
+    VALUE url = rb_easy_get("url");
+    size_t len = 13+((RSTRING_LEN(url) > 50) ? 50 : RSTRING_LEN(url));
     /* "#<Net::HTTP http://www.google.com/:80 open=false>" */
     memcpy(buf,"#<Curl::Easy ", 13);
-    memcpy(buf+13,RSTRING_PTR(rbce->url), (len - 13));
+    memcpy(buf+13,RSTRING_PTR(url), (len - 13));
     buf[len-1] = '>';
     return rb_str_new(buf,len);
   }
@@ -2832,7 +2919,7 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "proxy_port", ruby_curl_easy_proxy_port_get, 0);
   rb_define_method(cCurlEasy, "proxy_type=", ruby_curl_easy_proxy_type_set, 1);
   rb_define_method(cCurlEasy, "proxy_type", ruby_curl_easy_proxy_type_get, 0);
-  rb_define_method(cCurlEasy, "http_auth_types=", ruby_curl_easy_http_auth_types_set, 1);
+  rb_define_method(cCurlEasy, "http_auth_types=", ruby_curl_easy_http_auth_types_set, -1);
   rb_define_method(cCurlEasy, "http_auth_types", ruby_curl_easy_http_auth_types_get, 0);
   rb_define_method(cCurlEasy, "proxy_auth_types=", ruby_curl_easy_proxy_auth_types_set, 1);
   rb_define_method(cCurlEasy, "proxy_auth_types", ruby_curl_easy_proxy_auth_types_get, 0);
@@ -2847,6 +2934,11 @@ void init_curb_easy() {
   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, "username=", ruby_curl_easy_username_set, 1);
+  rb_define_method(cCurlEasy, "username", ruby_curl_easy_username_get, 0);
+  rb_define_method(cCurlEasy, "password=", ruby_curl_easy_password_set, 1);
+  rb_define_method(cCurlEasy, "password", ruby_curl_easy_password_get, 0);
+
   rb_define_method(cCurlEasy, "proxy_tunnel=", ruby_curl_easy_proxy_tunnel_set, 1);
   rb_define_method(cCurlEasy, "proxy_tunnel?", ruby_curl_easy_proxy_tunnel_q, 0);
   rb_define_method(cCurlEasy, "fetch_file_time=", ruby_curl_easy_fetch_file_time_set, 1);

data/ext/curb_easy.h

@@ -18,33 +18,7 @@ typedef struct {
   /* The handler */
   CURL *curl;
 
-  /* Objects we associate */
-  VALUE url;
-  VALUE proxy_url;
-
-  VALUE body_proc;
-  VALUE header_proc;
-  VALUE body_data;      /* Holds the response body from the last call to curl_easy_perform */
-  VALUE header_data;    /* unless a block is supplied (they'll be nil)      */
-  VALUE progress_proc;
-  VALUE debug_proc;
-  VALUE interface_hm;
-  VALUE userpwd;
-  VALUE proxypwd;
-  VALUE headers;        /* ruby array of strings with headers to set */
-  VALUE cookies;        /* string */
-  VALUE cookiefile;     /* filename */
-  VALUE cookiejar;      /* filename */
-  VALUE cert;
-  VALUE cacert;
-  VALUE certpassword;
-  VALUE certtype;
-  VALUE encoding;
-  VALUE useragent;
-
-  VALUE success_proc;
-  VALUE failure_proc;
-  VALUE complete_proc;
+  VALUE opts; /* rather then allocate everything we might need to store, allocate a Hash and only store objects we actually use... */
 
   /* Other opts */
   unsigned short local_port;       // 0 is no port
@@ -71,32 +45,16 @@ typedef struct {
   char verbose;
   char multipart_form_post;
   char enable_cookies;
-
-  /* this is sometimes used as a buffer for a form data string,
-   * which we alloc in C and need to hang around for the call,
-   * and in case it's asked for before the next call.
-   */
-  VALUE postdata_buffer;
-
-  /* when added to a multi handle these buffers are needed
-   * when the easy handle isn't supplied the body proc
-   * or a custom http header is passed.
-   */
-  VALUE bodybuf;
-  VALUE headerbuf;
   struct curl_slist *curl_headers;
 
-//  VALUE self; /* pointer to self, used by multi interface */
-  VALUE upload; /* pointer to an active upload otherwise Qnil */
-
   int last_result; /* last result code from multi loop */
 
 } ruby_curl_easy;
 
 extern VALUE cCurlEasy;
 
-VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce, VALUE *bodybuf, VALUE *headerbuf, struct curl_slist **headers);
-VALUE ruby_curl_easy_cleanup(VALUE self, ruby_curl_easy *rbce, VALUE bodybuf, VALUE headerbuf, struct curl_slist *headers);
+VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce, struct curl_slist **headers);
+VALUE ruby_curl_easy_cleanup(VALUE self, ruby_curl_easy *rbce, struct curl_slist *headers);
 
 void init_curb_easy();
 

data/ext/curb_errors.c

@@ -23,6 +23,7 @@ VALUE eCurlErrTelnetError;
 VALUE eCurlErrTFTPError;
 
 /* Specific libcurl errors */
+VALUE eCurlErrOK; /* not really an error but a return code */
 VALUE eCurlErrUnsupportedProtocol;
 VALUE eCurlErrFailedInit;
 VALUE eCurlErrMalformedURL;
@@ -127,6 +128,9 @@ VALUE rb_curl_easy_error(CURLcode code) {
   VALUE results;
 
   switch (code) {
+    case CURLE_OK:                      /* 0 */
+      exclz = eCurlErrOK;
+      break;
     case CURLE_UNSUPPORTED_PROTOCOL:    /* 1 */
       exclz = eCurlErrUnsupportedProtocol;
       break;
@@ -509,6 +513,7 @@ void init_curb_errors() {
   eCurlErrTelnetError = rb_define_class_under(mCurlErr, "TelnetError", eCurlErrError);
   eCurlErrTFTPError = rb_define_class_under(mCurlErr, "TFTPError", eCurlErrError);
 
+  eCurlErrOK = rb_define_class_under(mCurlErr, "CurlOK", eCurlErrError);
   eCurlErrUnsupportedProtocol = rb_define_class_under(mCurlErr, "UnsupportedProtocolError", eCurlErrError);
   eCurlErrFailedInit = rb_define_class_under(mCurlErr, "FailedInitError", eCurlErrError);
   eCurlErrMalformedURL = rb_define_class_under(mCurlErr, "MalformedURLError", eCurlErrError);

data/ext/curb_macros.h

@@ -8,6 +8,17 @@
 #ifndef __CURB_MACROS_H
 #define __CURB_MACROS_H
 
+#define rb_easy_hkey(key) ID2SYM(rb_intern(key))
+#define rb_easy_set(key,val) rb_hash_aset(rbce->opts, rb_easy_hkey(key) , val)
+#define rb_easy_get(key) rb_hash_aref(rbce->opts, rb_easy_hkey(key))
+#define rb_easy_del(key) rb_hash_delete(rbce->opts, rb_easy_hkey(key))
+#define rb_easy_nil(key) (rb_hash_lookup(rbce->opts, rb_easy_hkey(key)) == Qnil)
+#define rb_easy_type_check(key,type) (rb_type(rb_hash_aref(rbce->opts, rb_easy_hkey(key))) == type)
+
+// TODO: rb_sym_to_s may not be defined?
+#define rb_easy_get_str(key) \
+  RSTRING_PTR((rb_easy_type_check(key,T_STRING) ? rb_easy_get(key) : rb_str_to_str(rb_easy_get(key))))
+
 /* getter/setter macros for various things */
 /* setter for anything that stores a ruby VALUE in the struct */
 #define CURB_OBJECT_SETTER(type, attr)                              \
@@ -25,6 +36,22 @@
             Data_Get_Struct(self, type, ptr);                       \
             return ptr->attr; 
 
+/* setter for anything that stores a ruby VALUE in the struct opts hash */
+#define CURB_OBJECT_HSETTER(type, attr)                             \
+            type *ptr;                                              \
+                                                                    \
+            Data_Get_Struct(self, type, ptr);                       \
+            rb_hash_aset(ptr->opts, rb_easy_hkey(#attr), attr);       \
+                                                                    \
+            return attr;
+
+/* getter for anything that stores a ruby VALUE in the struct opts hash */
+#define CURB_OBJECT_HGETTER(type, attr)                              \
+            type *ptr;                                              \
+                                                                    \
+            Data_Get_Struct(self, type, ptr);                       \
+            return rb_hash_aref(ptr->opts, rb_easy_hkey(#attr)); 
+
 /* setter for bool flags */
 #define CURB_BOOLEAN_SETTER(type, attr)                             \
             type *ptr;                                              \
@@ -57,6 +84,20 @@
                                                                     \
             return oldproc;                                         \
 
+/* special setter for on_event handlers that take a block, same as above but stores int he opts hash */
+#define CURB_HANDLER_PROC_HSETTER(type, handler)                        \
+            type *ptr;                                                  \
+            VALUE oldproc, newproc;                                     \
+                                                                        \
+            Data_Get_Struct(self, type, ptr);                           \
+                                                                        \
+            oldproc = rb_hash_aref(ptr->opts, rb_easy_hkey(#handler));   \
+            rb_scan_args(argc, argv, "0&", &newproc);                   \
+                                                                        \
+            rb_hash_aset(ptr->opts, rb_easy_hkey(#handler), newproc);    \
+                                                                        \
+            return oldproc;
+
 /* setter for numerics that are kept in c ints */
 #define CURB_IMMED_SETTER(type, attr, nilval)                       \
             type *ptr;                                              \

data/ext/curb_multi.c

@@ -200,7 +200,7 @@ VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
   }
 
   /* setup the easy handle */
-  ruby_curl_easy_setup( rbce, &(rbce->bodybuf), &(rbce->headerbuf), &(rbce->curl_headers) );
+  ruby_curl_easy_setup( rbce, &(rbce->curl_headers) );
 
   rbcm->active++;
 
@@ -253,14 +253,12 @@ static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy) {
 
   rbcm->active--;
 
-  ruby_curl_easy_cleanup( easy, rbce, rbce->bodybuf, rbce->headerbuf, rbce->curl_headers );
-  rbce->headerbuf = Qnil;
-  rbce->bodybuf = Qnil;
+  ruby_curl_easy_cleanup( easy, rbce, rbce->curl_headers );
 
   // active should equal INT2FIX(RHASH(rbcm->requests)->tbl->num_entries)
   r = rb_hash_delete( rbcm->requests, easy );
   if( r != easy || r == Qnil ) {
-    rb_warn("Possibly lost tack of Curl::Easy VALUE, it may not be reclaimed by GC");
+    rb_warn("Possibly lost track of Curl::Easy VALUE, it may not be reclaimed by GC");
   }
 }
 
@@ -306,25 +304,25 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
 
   ruby_curl_multi_remove( self, easy );
 
-  if (rbce->complete_proc != Qnil) {
-    rb_funcall( rbce->complete_proc, idCall, 1, easy );
+  if (!rb_easy_nil("complete_proc")) {
+    rb_funcall( rb_easy_get("complete_proc"), idCall, 1, easy );
   }
 
   curl_easy_getinfo(rbce->curl, CURLINFO_RESPONSE_CODE, &response_code);
 
   if (result != 0) {
-    if (rbce->failure_proc != Qnil) {
-      rb_funcall( rbce->failure_proc, idCall, 2, easy, rb_curl_easy_error(result) );
+    if (!rb_easy_nil("failure_proc")) {
+      rb_funcall( rb_easy_get("failure_proc"), idCall, 2, easy, rb_curl_easy_error(result) );
     }
   }
-  else if (rbce->success_proc != Qnil &&
+  else if (!rb_easy_nil("success_proc") &&
           ((response_code >= 200 && response_code < 300) || response_code == 0)) {
     /* NOTE: we allow response_code == 0, in the case of non http requests e.g. reading from disk */
-    rb_funcall( rbce->success_proc, idCall, 1, easy );
+    rb_funcall( rb_easy_get("success_proc"), idCall, 1, easy );
   }
-  else if (rbce->failure_proc != Qnil &&
+  else if (!rb_easy_nil("failure_proc") &&
           (response_code >= 300 && response_code <= 999)) {
-    rb_funcall( rbce->failure_proc, idCall, 2, easy, rb_curl_easy_error(result) );
+    rb_funcall( rb_easy_get("failure_proc"), idCall, 2, easy, rb_curl_easy_error(result) );
   }
 }
 

data/ext/curb_postfield.c

@@ -41,7 +41,7 @@ void append_to_form(VALUE self,
       // is a file upload field
       if (rbcpf->content_proc != Qnil) {
         // with content proc
-        rbcpf->buffer_str = rb_funcall(rbcpf->content_proc, idCall, self);
+        rbcpf->buffer_str = rb_funcall(rbcpf->content_proc, idCall, 1, self);
         
         if (rbcpf->remote_file == Qnil) {
           rb_raise(eCurlErrInvalidPostField, "Cannot post file upload field with no filename");
@@ -468,10 +468,10 @@ static VALUE ruby_curl_postfield_to_str(VALUE self) {
         }            
       }
     } else {
-      rb_raise(eCurlErrInvalidPostField, "Cannot convert unnamed field to string");
+      rb_raise(eCurlErrInvalidPostField, "Cannot convert unnamed field to string %s:%d", __FILE__, __LINE__);
     }      
   } else {
-    rb_raise(eCurlErrInvalidPostField, "Cannot convert non-content field to string");
+    rb_raise(eCurlErrInvalidPostField, "Cannot convert non-content field to string %s:%d", __FILE__, __LINE__);
   }  
   
   return result;

data/ext/extconf.rb

@@ -111,6 +111,13 @@ have_constant "curle_again"
 have_constant "curle_ssl_crl_badfile"
 have_constant "curle_ssl_issuer_error"
 
+# username/password added in 7.19.1
+have_constant "curlopt_username"
+have_constant "curlopt_password"
+
+# ie quirk added in 7.19.3
+have_constant "curlauth_digest_ie"
+
 # centos 4.5 build of libcurl
 have_constant "curlm_bad_socket"
 have_constant "curlm_unknown_option"

data/tests/helper.rb

@@ -59,6 +59,7 @@ class TestServlet < WEBrick::HTTPServlet::AbstractServlet
 
   def respond_with(method,req,res)
     res.body = method.to_s
+    $auth_header = req['Authorization']
     res['Content-Type'] = "text/plain"
   end
 

data/tests/tc_curl_easy.rb

@@ -655,6 +655,35 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert /ScrubDog$/,curl.useragent
   end
 
+  def test_username_password
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.username = "foo"
+    curl.password = "bar"
+    if !curl.username.nil?
+      assert_equal "foo", curl.username
+      assert_equal "bar", curl.password
+    else
+      curl.userpwd = "foo:bar"
+    end
+    curl.http_auth_types = :basic
+    #curl.verbose = true
+    curl.perform
+    assert_equal 'Basic Zm9vOmJhcg==', $auth_header
+
+    # curl checks the auth type supported by the server, so we have to create a 
+    # new easy handle if we're going to change the auth type...
+
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.username = "foo"
+    curl.password = "bar"
+    if curl.username.nil?
+      curl.userpwd = "foo:bar"
+    end
+    curl.http_auth_types = :ntlm
+    curl.perform
+    assert_equal 'NTLM TlRMTVNTUAABAAAABoIIAAAAAAAAAAAAAAAAAAAAAAA=', $auth_header
+  end
+
   include TestServerMethods 
 
   def setup

data/tests/tc_curl_multi.rb

@@ -44,7 +44,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
 
     m.perform do
       # idle
-      puts "idling..."
+      #puts "idling..."
     end
 
     assert_match(/^# DO NOT REMOVE THIS COMMENT/, c1.body_str)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ghazel-curb
 version: !ruby/object:Gem::Version 
-  version: 0.6.1.0
+  version: 0.6.2.1
 platform: ruby
 authors: 
 - Ross Bamford
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-06 00:00:00 -08:00
+date: 2009-12-26 00:00:00 -08:00
 default_executable: 
 dependencies: []