curb 1.3.7 → 1.4.1

data/ext/curb_easy.c

@@ -66,6 +66,17 @@ static struct curl_slist *duplicate_curl_slist(struct curl_slist *list);
 static size_t proc_data_handler(char *stream, size_t size, size_t nmemb, VALUE proc);
 static int curb_array_includes_string(VALUE list, VALUE value);
 
+static void curb_easy_apply_thread_defaults(ruby_curl_easy *rbce) {
+#ifdef HAVE_CURLOPT_NOSIGNAL
+  CURLcode ecode = curl_easy_setopt(rbce->curl, CURLOPT_NOSIGNAL, 1L);
+  if (ecode != CURLE_OK) {
+    raise_curl_easy_error_exception(ecode);
+  }
+#else
+  (void)rbce;
+#endif
+}
+
 /* ================== CURL HANDLER FUNCS ==============*/
 
 static int curb_ipv4_is_unsafe_destination(const unsigned char *ip) {
@@ -736,7 +747,7 @@ VALUE rb_curl_easy_take_callback_error(ruby_curl_easy *rbce) {
 static VALUE ruby_curl_easy_take_callback_error(VALUE self) {
   ruby_curl_easy *rbce = NULL;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
   return rb_curl_easy_take_callback_error(rbce);
 }
 
@@ -1292,6 +1303,19 @@ static ruby_curl_multi *ruby_curl_multi_pointer_if_compatible(VALUE multi_val) {
 #endif
 }
 
+/* Explicit lifecycle operations can update Ruby bookkeeping; the GC free
+ * path below must remain allocation-free. */
+static void ruby_curl_easy_detach(VALUE self, ruby_curl_easy *rbce) {
+  VALUE multi = rbce->multi;
+  ruby_curl_multi *rbcm = ruby_curl_multi_pointer_if_compatible(multi);
+  if (rbcm) {
+    CURLMcode result = rb_curl_multi_detach_easy(rbcm, rbce);
+    if (result != CURLM_OK) raise_curl_multi_error_exception(result);
+    rb_curl_multi_remove_request_reference(multi, self);
+  }
+  rbce->multi = Qnil;
+}
+
 static void ruby_curl_easy_free(ruby_curl_easy *rbce) {
   if (!rbce) {
     return;
@@ -1308,10 +1332,7 @@ static void ruby_curl_easy_free(ruby_curl_easy *rbce) {
        * libcurl retaining a dangling pointer to a soon-to-be cleaned-up easy
        * handle. This path runs during GC, so it must not invoke Ruby APIs that
        * can allocate or raise. */
-      if (rbcm->handle && rbce->curl) {
-        curl_multi_remove_handle(rbcm->handle, rbce->curl);
-      }
-      rb_curl_multi_forget_easy(rbcm, rbce);
+      rb_curl_multi_detach_easy(rbcm, rbce);
     }
   }
 
@@ -1385,6 +1406,39 @@ const rb_data_type_t ruby_curl_easy_data_type = {
 };
 
 
+void ruby_curl_easy_check_access(ruby_curl_easy *rbce) {
+  if (rbce->multipart_building) {
+    rb_raise(rb_eRuntimeError, "Cannot access an active curl handle during multipart construction");
+  }
+  rb_curl_multi_check_easy_thread(rbce);
+}
+
+static void ruby_curl_easy_check_idle(ruby_curl_easy *rbce) {
+  ruby_curl_easy_check_access(rbce);
+  if (rb_curl_multi_easy_performing(rbce)) {
+    rb_raise(rb_eRuntimeError, "Cannot modify an active curl handle during perform");
+  }
+}
+
+/* Public entry points must not pass an uninitialized handle to libcurl. */
+ruby_curl_easy *ruby_curl_easy_get_handle(VALUE self) {
+  ruby_curl_easy *rbce;
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  if (!rbce->curl) {
+    rb_raise(eCurlErrFailedInit, "Curl::Easy handle is not initialized");
+  }
+  ruby_curl_easy_check_access(rbce);
+  return rbce;
+}
+
+/* Keep libcurl's typed getinfo arguments while checking every result. */
+#define CURB_GETINFO(handle, info, output) do { \
+  CURLcode info_result = curl_easy_getinfo(handle, info, output); \
+  if (info_result != CURLE_OK) { \
+    raise_curl_easy_error_exception(info_result); \
+  } \
+} while (0)
+
 /* ================= ALLOC METHODS ====================*/
 
 static void ruby_curl_easy_zero(ruby_curl_easy *rbce) {
@@ -1440,6 +1494,8 @@ static void ruby_curl_easy_zero(ruby_curl_easy *rbce) {
   rbce->unrestricted_auth = 0;
   rbce->verbose = 0;
   rbce->multipart_form_post = 0;
+  rbce->multipart_form_active = 0;
+  rbce->multipart_building = 0;
   rbce->enable_cookies = 0;
   rbce->cookielist_engine_enabled = 0;
   rbce->ignore_content_length = 0;
@@ -1489,6 +1545,16 @@ static VALUE ruby_curl_easy_initialize(int argc, VALUE *argv, VALUE self) {
 
   TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 
+  if (rbce->callback_active || rbce->native_active) {
+    rb_raise(rb_eRuntimeError, "Cannot initialize an active curl handle");
+  }
+
+  ruby_curl_easy_check_idle(rbce);
+  ruby_curl_easy_detach(self, rbce);
+
+  /* Detach and release any previous handle and its owned option lists. */
+  ruby_curl_easy_free(rbce);
+
   /* handler */
   rbce->curl = curl_easy_init();
   if (!rbce->curl) {
@@ -1501,6 +1567,7 @@ static VALUE ruby_curl_easy_initialize(int argc, VALUE *argv, VALUE self) {
   ruby_curl_easy_zero(rbce);
   rbce->self = self;
 
+  curb_easy_apply_thread_defaults(rbce);
   curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, &rbce->err_buf);
 
   rb_easy_set("url", url);
@@ -1559,11 +1626,13 @@ static VALUE duplicate_upload(VALUE upload) {
  *
  * Clone this Curl::Easy instance, creating a new instance.
  * This method duplicates the underlying CURL* handle.
+ * A temporary multipart form attached during a request is not copied;
+ * supply new PostFields to send a multipart request with the clone.
  */
 static VALUE ruby_curl_easy_clone(VALUE self) {
   ruby_curl_easy *rbce, *newrbce;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
   newrbce = ALLOC(ruby_curl_easy);
   if (!newrbce) {
@@ -1578,6 +1647,18 @@ static VALUE ruby_curl_easy_clone(VALUE self) {
     free(newrbce);
     rb_raise(rb_eNoMemError, "Failed to duplicate Curl::Easy handle");
   }
+  /* duphandle borrows HTTPPOST, whose form is freed when the original
+   * perform unwinds. Only reset it when attached: setting HTTPPOST also
+   * changes request options and must not affect ordinary POST/upload clones. */
+  if (newrbce->multipart_form_active) {
+    CURLcode ecode = curl_easy_setopt(newrbce->curl, CURLOPT_HTTPPOST, NULL);
+    if (ecode != CURLE_OK) {
+      curl_easy_cleanup(newrbce->curl);
+      free(newrbce);
+      raise_curl_easy_error_exception(ecode);
+    }
+    newrbce->multipart_form_active = 0;
+  }
   newrbce->curl_headers = (rbce->curl_headers) ? duplicate_curl_slist(rbce->curl_headers) : NULL;
   newrbce->curl_proxy_headers = (rbce->curl_proxy_headers) ? duplicate_curl_slist(rbce->curl_proxy_headers) : NULL;
   newrbce->curl_ftp_commands = (rbce->curl_ftp_commands) ? duplicate_curl_slist(rbce->curl_ftp_commands) : NULL;
@@ -1591,6 +1672,7 @@ static VALUE ruby_curl_easy_clone(VALUE self) {
   /* A cloned easy should not retain ownership reference to the original multi. */
   newrbce->multi = Qnil;
   newrbce->callback_error = Qnil;
+  newrbce->callback_active = 0;
   newrbce->unsafe_destination_blocked = 0;
   memset(newrbce->unsafe_destination_error, 0, CURL_ERROR_SIZE);
   newrbce->native_active = 0;
@@ -1636,7 +1718,7 @@ static VALUE ruby_curl_easy_close(VALUE self) {
   CURLcode ecode;
   ruby_curl_easy *rbce;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
   if (rbce->callback_active) {
     rb_raise(rb_eRuntimeError, "Cannot close an active curl handle within a callback");
@@ -1646,6 +1728,9 @@ static VALUE ruby_curl_easy_close(VALUE self) {
     rb_raise(rb_eRuntimeError, "Cannot close an active curl handle during native operation");
   }
 
+  ruby_curl_easy_check_idle(rbce);
+  ruby_curl_easy_detach(self, rbce);
+
   ruby_curl_easy_free(rbce);
 
   /* reinit the handle */
@@ -1659,6 +1744,7 @@ static VALUE ruby_curl_easy_close(VALUE self) {
   ruby_curl_easy_zero(rbce);
   rbce->self = self;
 
+  curb_easy_apply_thread_defaults(rbce);
   curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, rbce->err_buf);
 
   /* give the new curl handle a reference back to the ruby object */
@@ -1686,7 +1772,7 @@ static VALUE ruby_curl_easy_reset(VALUE self) {
   CURLcode ecode;
   ruby_curl_easy *rbce;
   VALUE opts_dup;
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
   if (rbce->callback_active) {
     rb_raise(rb_eRuntimeError, "Cannot close an active curl handle within a callback");
@@ -1696,6 +1782,9 @@ static VALUE ruby_curl_easy_reset(VALUE self) {
     rb_raise(rb_eRuntimeError, "Cannot reset an active curl handle during native operation");
   }
 
+  ruby_curl_easy_check_idle(rbce);
+  ruby_curl_easy_detach(self, rbce);
+
   opts_dup = rb_funcall(rbce->opts, rb_intern("dup"), 0);
 
   ruby_curl_easy_cleanup(self, rbce);
@@ -1703,6 +1792,7 @@ static VALUE ruby_curl_easy_reset(VALUE self) {
   ruby_curl_easy_zero(rbce);
   rbce->self = self;
 
+  curb_easy_apply_thread_defaults(rbce);
   curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, &rbce->err_buf);
 
   /* reset clobbers the private setting, so reset it to self */
@@ -1776,7 +1866,7 @@ static VALUE ruby_curl_easy_proxy_headers_set(VALUE self, VALUE proxy_headers) {
 static VALUE ruby_curl_easy_headers_get(VALUE self) {
   ruby_curl_easy *rbce;
   VALUE headers;
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
   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;
@@ -1811,7 +1901,7 @@ static VALUE ruby_curl_easy_headers_get(VALUE self) {
 static VALUE ruby_curl_easy_proxy_headers_get(VALUE self) {
   ruby_curl_easy *rbce;
   VALUE proxy_headers;
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
   proxy_headers = rb_easy_get("proxy_headers");//rb_hash_aref(rbce->opts, rb_intern("proxy_headers"));
   if (proxy_headers == Qnil) { proxy_headers = rb_easy_set("proxy_headers", rb_hash_new()); }
   return proxy_headers;
@@ -2061,7 +2151,7 @@ static VALUE ruby_curl_easy_post_body_set_with_mode_body(VALUE argp) {
   char *data;
   long len;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
   curl = rbce->curl;
 
@@ -2120,7 +2210,7 @@ static VALUE ruby_curl_easy_post_body_set_with_mode(VALUE self, VALUE post_body,
   ruby_curl_easy *rbce;
   struct post_body_set_args args = { self, post_body, force_http_get_on_nil };
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
   ruby_curl_easy_enter_native(rbce);
 
   return rb_ensure(ruby_curl_easy_post_body_set_with_mode_body, (VALUE)&args,
@@ -2157,7 +2247,7 @@ static VALUE ruby_curl_easy_put_data_set(VALUE self, VALUE data) {
   VALUE headers;
   VALUE infile_size = Qnil;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
   /*
    * Validate and prepare Ruby-visible state before mutating the CURL handle.
@@ -2342,7 +2432,7 @@ static VALUE ruby_curl_easy_dns_servers_get(VALUE self) {
 static VALUE ruby_curl_easy_allow_unix_socket_set(VALUE self, VALUE allow) {
   ruby_curl_easy *rbce;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
   rbce->allow_unix_socket = RTEST(allow) ? 1 : 0;
 
   return allow;
@@ -2351,7 +2441,7 @@ static VALUE ruby_curl_easy_allow_unix_socket_set(VALUE self, VALUE allow) {
 static VALUE ruby_curl_easy_allow_proxy_set(VALUE self, VALUE allow) {
   ruby_curl_easy *rbce;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
   rbce->allow_proxy = RTEST(allow) ? 1 : 0;
 
   return allow;
@@ -2370,7 +2460,7 @@ static VALUE ruby_curl_easy_allowed_cidrs_set(VALUE self, VALUE cidrs) {
   VALUE normalized;
   VALUE stored;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
   normalized = curb_normalize_cidr_list(cidrs);
   stored = curb_dup_string_array(normalized);
   rb_hash_aset(rbce->opts, rb_easy_hkey("allowed_cidrs"), stored);
@@ -2391,7 +2481,7 @@ static VALUE ruby_curl_easy_allowed_cidrs_get(VALUE self) {
   ruby_curl_easy *rbce;
   VALUE cidrs;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
   cidrs = rb_hash_aref(rbce->opts, rb_easy_hkey("allowed_cidrs"));
 
   return curb_dup_string_array(cidrs);
@@ -2410,7 +2500,7 @@ static VALUE ruby_curl_easy_allowed_hosts_set(VALUE self, VALUE hosts) {
   VALUE normalized;
   VALUE stored;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
   normalized = curb_normalize_host_list(hosts);
   stored = curb_dup_string_array(normalized);
   rb_hash_aset(rbce->opts, rb_easy_hkey("allowed_hosts"), stored);
@@ -2427,7 +2517,7 @@ static VALUE ruby_curl_easy_allowed_hosts_get(VALUE self) {
   ruby_curl_easy *rbce;
   VALUE hosts;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
   hosts = rb_hash_aref(rbce->opts, rb_easy_hkey("allowed_hosts"));
 
   return curb_dup_string_array(hosts);
@@ -2552,6 +2642,41 @@ static VALUE ruby_curl_easy_proxy_type_get(VALUE self) {
   (!strncmp("anysafe",node,7)) ? CURLAUTH_ANYSAFE : \
   (!strncmp("any",node,3)) ? CURLAUTH_ANY : 0
 #endif
+/*
+ * Convert the arguments to http_auth_types= / proxy_auth_types= into a
+ * CURLAUTH bitmask. Accepts nil, an Integer mask, or one or more auth type
+ * names (symbols/strings), either as separate args or as a single Array.
+ */
+static long ruby_curl_easy_auth_types_to_mask(VALUE args_ary) {
+  long i, len;
+  char* node = NULL;
+  long mask = 0;
+  VALUE first;
+
+  /* easy.http_auth_types = [:basic, :digest] arrives as a single Array arg */
+  if (RARRAY_LEN(args_ary) == 1 && RB_TYPE_P(rb_ary_entry(args_ary,0), T_ARRAY)) {
+    args_ary = rb_ary_entry(args_ary,0);
+  }
+
+  len = RARRAY_LEN(args_ary);
+  first = rb_ary_entry(args_ary,0);
+
+  if (len == 1 && (first == Qnil || TYPE(first) == T_FIXNUM || TYPE(first) == T_BIGNUM)) {
+    return first == Qnil ? 0 : NUM2LONG(first);
+  }
+
+  // we could have multiple values, but they should be symbols
+  // rb_obj_as_string always yields a String, even if to_s misbehaves;
+  // RSTRING_PTR on a raw rb_funcall result would crash if #to_s returned
+  // a non-String (e.g. a Fixnum, whose VALUE isn't a real pointer).
+  for( i = 0; i < len; ++i ) {
+    VALUE node_str = rb_obj_as_string(rb_ary_entry(args_ary,i));
+    node = StringValuePtr(node_str);
+    mask |= CURL_HTTPAUTH_STR_TO_NUM(node);
+  }
+  return mask;
+}
+
 /*
  * call-seq:
  *   easy.http_auth_types = fixnum or nil             => fixnum or nil
@@ -2561,37 +2686,14 @@ static VALUE ruby_curl_easy_proxy_type_get(VALUE self) {
  * +perform+ calls. This is a bitmap made by ORing together the
  * Curl::CURLAUTH constants.
  */
-static VALUE ruby_curl_easy_http_auth_types_set(int argc, VALUE *argv, VALUE self) {//VALUE self, VALUE http_auth_types) {
+static VALUE ruby_curl_easy_http_auth_types_set(int argc, VALUE *argv, VALUE self) {
   ruby_curl_easy *rbce;
   VALUE args_ary;
-  long i, len;
-  char* node = NULL;
-  long mask = 0;
 
   rb_scan_args(argc, argv, "*", &args_ary);
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
-  len = RARRAY_LEN(args_ary);
-
-  if (len == 1 && (rb_ary_entry(args_ary,0) == Qnil || TYPE(rb_ary_entry(args_ary,0)) == T_FIXNUM ||
-        TYPE(rb_ary_entry(args_ary,0)) == T_BIGNUM)) {
-    if (rb_ary_entry(args_ary,0) == Qnil) {
-      rbce->http_auth_types = 0;
-    }
-    else {
-      rbce->http_auth_types = NUM2LONG(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;
-  }
+  rbce->http_auth_types = ruby_curl_easy_auth_types_to_mask(args_ary);
   return LONG2NUM(rbce->http_auth_types);
 }
 
@@ -2609,13 +2711,21 @@ static VALUE ruby_curl_easy_http_auth_types_get(VALUE self) {
 /*
  * call-seq:
  *   easy.proxy_auth_types = fixnum or nil            => fixnum or nil
+ *   easy.proxy_auth_types = [:basic,:digest,:digest_ie,:gssnegotiate, :ntlm, :any, :anysafe]
  *
  * Set the proxy authentication types that may be used for the following
  * +perform+ calls. This is a bitmap made by ORing together the
  * Curl::CURLAUTH constants.
  */
-static VALUE ruby_curl_easy_proxy_auth_types_set(VALUE self, VALUE proxy_auth_types) {
-  CURB_IMMED_SETTER(ruby_curl_easy, proxy_auth_types, 0);
+static VALUE ruby_curl_easy_proxy_auth_types_set(int argc, VALUE *argv, VALUE self) {
+  ruby_curl_easy *rbce;
+  VALUE args_ary;
+
+  rb_scan_args(argc, argv, "*", &args_ary);
+  rbce = ruby_curl_easy_get_handle(self);
+
+  rbce->proxy_auth_types = ruby_curl_easy_auth_types_to_mask(args_ary);
+  return LONG2NUM(rbce->proxy_auth_types);
 }
 
 /*
@@ -2674,7 +2784,7 @@ static VALUE ruby_curl_easy_max_redirects_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_timeout_set(VALUE self, VALUE timeout_s) {
   ruby_curl_easy *rbce;
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
   if (Qnil == timeout_s || NUM2DBL(timeout_s) <= 0.0) {
     rbce->timeout_ms = 0;
@@ -2697,7 +2807,7 @@ static VALUE ruby_curl_easy_timeout_set(VALUE self, VALUE timeout_s) {
  */
 static VALUE ruby_curl_easy_timeout_get(VALUE self) {
   ruby_curl_easy *rbce;
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
   return DBL2NUM(rbce->timeout_ms / 1000.0);
 }
 
@@ -2715,7 +2825,7 @@ static VALUE ruby_curl_easy_timeout_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_timeout_ms_set(VALUE self, VALUE timeout_ms) {
   ruby_curl_easy *rbce;
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
   if (Qnil == timeout_ms || NUM2DBL(timeout_ms) <= 0.0) {
     rbce->timeout_ms = 0;
@@ -2735,7 +2845,7 @@ static VALUE ruby_curl_easy_timeout_ms_set(VALUE self, VALUE timeout_ms) {
  */
 static VALUE ruby_curl_easy_timeout_ms_get(VALUE self) {
   ruby_curl_easy *rbce;
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
   return LONG2NUM(rbce->timeout_ms);
 }
 
@@ -3208,7 +3318,7 @@ static VALUE ruby_curl_easy_use_netrc_q(VALUE self) {
  */
 static VALUE ruby_curl_easy_autoreferer_set(VALUE self, VALUE autoreferer) {
   ruby_curl_easy *rbce;
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
   if (Qtrue == autoreferer) {
     curl_easy_setopt(rbce->curl, CURLOPT_AUTOREFERER, 1);
@@ -3365,7 +3475,7 @@ static VALUE ruby_curl_easy_ignore_content_length_q(VALUE self) {
 static VALUE ruby_curl_easy_resolve_mode(VALUE self) {
   ruby_curl_easy *rbce;
   unsigned short rm;
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
   rm = rbce->resolve_mode;
 
@@ -3397,7 +3507,7 @@ static VALUE ruby_curl_easy_resolve_mode_set(VALUE self, VALUE resolve_mode) {
   } else {
     ruby_curl_easy *rbce;
     ID resolve_mode_id;
-    TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+    rbce = ruby_curl_easy_get_handle(self);
 
     resolve_mode_id = rb_to_id(resolve_mode);
 
@@ -3426,7 +3536,7 @@ static VALUE ruby_curl_easy_resolve_mode_set(VALUE self, VALUE resolve_mode) {
  */
 static VALUE ruby_curl_easy_network_policy_get(VALUE self) {
   ruby_curl_easy *rbce;
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
   switch (rbce->network_policy) {
   case CURB_NETWORK_POLICY_PUBLIC:
@@ -3450,7 +3560,7 @@ static VALUE ruby_curl_easy_network_policy_set(VALUE self, VALUE network_policy)
   ruby_curl_easy *rbce;
   ID network_policy_id;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
   if (NIL_P(network_policy)) {
     rbce->network_policy = CURB_NETWORK_POLICY_NONE;
@@ -3488,7 +3598,7 @@ static VALUE ruby_curl_easy_network_policy_set(VALUE self, VALUE network_policy)
  */
 static VALUE ruby_curl_easy_unsafe_destination_error_get(VALUE self) {
   ruby_curl_easy *rbce;
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
   if (rbce->unsafe_destination_blocked && rbce->unsafe_destination_error[0]) {
     return rb_str_new2(rbce->unsafe_destination_error);
@@ -3506,7 +3616,7 @@ static VALUE ruby_curl_easy_unsafe_destination_error_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_unix_socket_path_get(VALUE self) {
   ruby_curl_easy *rbce;
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
   return rb_easy_get("unix_socket_path");
 }
@@ -3525,7 +3635,7 @@ static VALUE ruby_curl_easy_http_version_set(VALUE self, VALUE version) {
   ruby_curl_easy *rbce;
   long http_version;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
   if (NIL_P(version)) {
     http_version = CURL_HTTP_VERSION_NONE;
@@ -3547,7 +3657,7 @@ static VALUE ruby_curl_easy_http_version_set(VALUE self, VALUE version) {
 static VALUE ruby_curl_easy_http_version_get(VALUE self) {
   ruby_curl_easy *rbce;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
   return LONG2NUM(rbce->http_version);
 }
@@ -4330,7 +4440,7 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
 static VALUE ruby_curl_easy_setup_self(VALUE self) {
   ruby_curl_easy *rbce;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
   ruby_curl_easy_setup(rbce);
 
   return self;
@@ -4436,7 +4546,7 @@ static VALUE ruby_curl_easy_perform_verb_str(VALUE self, const char *verb) {
   CURL *curl;
   VALUE retval;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
   curl = rbce->curl;
 
   memset(rbce->err_buf, 0, CURL_ERROR_SIZE);
@@ -4501,6 +4611,8 @@ struct easy_form_perform_args {
   struct curl_httppost *last;
   int clear_customrequest;
   int form_set_on_curl;
+  ruby_curl_form_string *strings;
+  ruby_curl_easy *rbce;
 };
 
 struct easy_join_args {
@@ -4522,15 +4634,16 @@ static VALUE join_easy_arguments(ruby_curl_easy *rbce, VALUE args_ary) {
 
 static void append_multipart_form_argument(VALUE arg,
                                            struct curl_httppost **first,
-                                           struct curl_httppost **last) {
+                                           struct curl_httppost **last,
+                                           ruby_curl_form_string **strings) {
   if (rb_obj_is_instance_of(arg, cCurlPostField)) {
-    append_to_form(arg, first, last);
+    append_to_form(arg, first, last, strings);
   } else if (rb_type(arg) == T_ARRAY) {
     long j, argv_len = RARRAY_LEN(arg);
     for (j = 0; j < argv_len; ++j) {
       VALUE field = rb_ary_entry(arg, j);
       if (rb_obj_is_instance_of(field, cCurlPostField)) {
-        append_to_form(field, first, last);
+        append_to_form(field, first, last, strings);
       } else {
         rb_raise(eCurlErrInvalidPostField,
                  "You must use PostFields only with multipart form posts");
@@ -4545,23 +4658,35 @@ static void append_multipart_form_argument(VALUE arg,
 static VALUE build_and_perform_multipart_form(VALUE argp) {
   struct easy_form_perform_args *args = (struct easy_form_perform_args *)argp;
   int i;
+  ruby_curl_easy *rbce;
+
+  rbce = ruby_curl_easy_get_handle(args->self);
+  args->rbce = rbce;
+  ruby_curl_easy_enter_native(rbce);
+  rbce->multipart_building = 1;
 
   for (i = 0; i < args->argc; i++) {
-    append_multipart_form_argument(args->argv[i], &args->first, &args->last);
+    append_multipart_form_argument(args->argv[i], &args->first, &args->last, &args->strings);
   }
 
   curl_easy_setopt(args->curl, CURLOPT_POST, 0);
   curl_easy_setopt(args->curl, CURLOPT_HTTPPOST, args->first);
   args->form_set_on_curl = 1;
+  rbce->multipart_form_active = 1;
 
+  rbce->multipart_building = 0;
   return call_easy_perform(args->self);
 }
 
 static VALUE ensure_free_form_post(VALUE argp) {
   struct easy_form_perform_args *args = (struct easy_form_perform_args *)argp;
+  if (args->rbce) args->rbce->multipart_building = 0;
   if (args->curl) {
     if (args->form_set_on_curl) {
+      ruby_curl_easy *rbce;
+      rbce = ruby_curl_easy_get_handle(args->self);
       curl_easy_setopt(args->curl, CURLOPT_HTTPPOST, NULL);
+      rbce->multipart_form_active = 0;
     }
     if (args->clear_customrequest) {
       curl_easy_setopt(args->curl, CURLOPT_CUSTOMREQUEST, NULL);
@@ -4572,6 +4697,9 @@ static VALUE ensure_free_form_post(VALUE argp) {
     args->first = NULL;
   }
   args->last = NULL;
+  free_form_strings(args->strings);
+  args->strings = NULL;
+  if (args->rbce) ruby_curl_easy_leave_native((VALUE)args->rbce);
   return Qnil;
 }
 
@@ -4606,7 +4734,7 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
 
   rb_scan_args(argc, argv, "*", &args_ary);
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
   curl = rbce->curl;
 
   memset(rbce->err_buf, 0, CURL_ERROR_SIZE);
@@ -4615,7 +4743,7 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
 
   if (rbce->multipart_form_post) {
     VALUE ret;
-    struct easy_form_perform_args perform_args = { self, curl, argc, argv, NULL, NULL, 0, 0 };
+    struct easy_form_perform_args perform_args = { self, curl, argc, argv, NULL, NULL, 0, 0, NULL, NULL };
     ret = rb_ensure(build_and_perform_multipart_form, (VALUE)&perform_args, ensure_free_form_post, (VALUE)&perform_args);
 
     return ret;
@@ -4665,7 +4793,7 @@ static VALUE ruby_curl_easy_perform_patch(int argc, VALUE *argv, VALUE self) {
   VALUE args_ary;
 
   rb_scan_args(argc, argv, "*", &args_ary);
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
   curl = rbce->curl;
 
   /* Clear the error buffer */
@@ -4676,7 +4804,7 @@ static VALUE ruby_curl_easy_perform_patch(int argc, VALUE *argv, VALUE self) {
 
   if (rbce->multipart_form_post) {
     VALUE ret;
-    struct easy_form_perform_args perform_args = { self, curl, argc, argv, NULL, NULL, 1, 0 };
+    struct easy_form_perform_args perform_args = { self, curl, argc, argv, NULL, NULL, 1, 0, NULL, NULL };
     ret = rb_ensure(build_and_perform_multipart_form, (VALUE)&perform_args, ensure_free_form_post, (VALUE)&perform_args);
     return ret;
   } else {
@@ -4714,7 +4842,7 @@ static VALUE ruby_curl_easy_perform_put(int argc, VALUE *argv, VALUE self) {
   VALUE args_ary;
 
   rb_scan_args(argc, argv, "*", &args_ary);
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
   curl = rbce->curl;
 
   memset(rbce->err_buf, 0, CURL_ERROR_SIZE);
@@ -4734,7 +4862,7 @@ static VALUE ruby_curl_easy_perform_put(int argc, VALUE *argv, VALUE self) {
   /* Otherwise, if multipart_form_post is true, use multipart logic */
   else if (rbce->multipart_form_post) {
     VALUE ret;
-    struct easy_form_perform_args perform_args = { self, curl, argc, argv, NULL, NULL, 1, 0 };
+    struct easy_form_perform_args perform_args = { self, curl, argc, argv, NULL, NULL, 1, 0, NULL, NULL };
     ret = rb_ensure(build_and_perform_multipart_form, (VALUE)&perform_args, ensure_free_form_post, (VALUE)&perform_args);
     return ret;
   }
@@ -4781,7 +4909,7 @@ static VALUE ruby_curl_easy_max_body_bytes_set(VALUE self, VALUE val) {
   ruby_curl_easy *rbce;
   long long limit;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
   if (NIL_P(val)) {
     rb_hash_delete(rbce->opts, rb_easy_hkey("max_body_bytes"));
@@ -4836,10 +4964,10 @@ static VALUE ruby_curl_easy_header_str_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_last_effective_url_get(VALUE self) {
   ruby_curl_easy *rbce;
-  char* url;
+  char* url = NULL;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
-  curl_easy_getinfo(rbce->curl, CURLINFO_EFFECTIVE_URL, &url);
+  rbce = ruby_curl_easy_get_handle(self);
+  CURB_GETINFO(rbce->curl, CURLINFO_EFFECTIVE_URL, &url);
 
   if (url && url[0]) {    // curl returns empty string if none
     return rb_str_new2(url);
@@ -4859,14 +4987,14 @@ static VALUE ruby_curl_easy_last_effective_url_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_response_code_get(VALUE self) {
   ruby_curl_easy *rbce;
-  long code;
+  long code = 0;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 #ifdef HAVE_CURLINFO_RESPONSE_CODE
-  curl_easy_getinfo(rbce->curl, CURLINFO_RESPONSE_CODE, &code);
+  CURB_GETINFO(rbce->curl, CURLINFO_RESPONSE_CODE, &code);
 #else
   // old libcurl
-  curl_easy_getinfo(rbce->curl, CURLINFO_HTTP_CODE, &code);
+  CURB_GETINFO(rbce->curl, CURLINFO_HTTP_CODE, &code);
 #endif
 
   return LONG2NUM(code);
@@ -4883,10 +5011,10 @@ static VALUE ruby_curl_easy_response_code_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_primary_ip_get(VALUE self) {
   ruby_curl_easy *rbce;
-  char* ip;
+  char* ip = NULL;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
-  curl_easy_getinfo(rbce->curl, CURLINFO_PRIMARY_IP, &ip);
+  rbce = ruby_curl_easy_get_handle(self);
+  CURB_GETINFO(rbce->curl, CURLINFO_PRIMARY_IP, &ip);
 
   if (ip && ip[0]) {    // curl returns empty string if none
     return rb_str_new2(ip);
@@ -4904,10 +5032,10 @@ static VALUE ruby_curl_easy_primary_ip_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_http_connect_code_get(VALUE self) {
   ruby_curl_easy *rbce;
-  long code;
+  long code = 0;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
-  curl_easy_getinfo(rbce->curl, CURLINFO_HTTP_CONNECTCODE, &code);
+  rbce = ruby_curl_easy_get_handle(self);
+  CURB_GETINFO(rbce->curl, CURLINFO_HTTP_CONNECTCODE, &code);
 
   return LONG2NUM(code);
 }
@@ -4932,10 +5060,10 @@ static VALUE ruby_curl_easy_http_connect_code_get(VALUE self) {
 static VALUE ruby_curl_easy_file_time_get(VALUE self) {
 #ifdef HAVE_CURLINFO_FILETIME
   ruby_curl_easy *rbce;
-  long time;
+  long time = 0;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
-  curl_easy_getinfo(rbce->curl, CURLINFO_FILETIME, &time);
+  rbce = ruby_curl_easy_get_handle(self);
+  CURB_GETINFO(rbce->curl, CURLINFO_FILETIME, &time);
 
   return LONG2NUM(time);
 #else
@@ -4953,10 +5081,10 @@ static VALUE ruby_curl_easy_file_time_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_total_time_get(VALUE self) {
   ruby_curl_easy *rbce;
-  double time;
+  double time = 0;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
-  curl_easy_getinfo(rbce->curl, CURLINFO_TOTAL_TIME, &time);
+  rbce = ruby_curl_easy_get_handle(self);
+  CURB_GETINFO(rbce->curl, CURLINFO_TOTAL_TIME, &time);
 
   return rb_float_new(time);
 }
@@ -4970,10 +5098,10 @@ static VALUE ruby_curl_easy_total_time_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_name_lookup_time_get(VALUE self) {
   ruby_curl_easy *rbce;
-  double time;
+  double time = 0;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
-  curl_easy_getinfo(rbce->curl, CURLINFO_NAMELOOKUP_TIME, &time);
+  rbce = ruby_curl_easy_get_handle(self);
+  CURB_GETINFO(rbce->curl, CURLINFO_NAMELOOKUP_TIME, &time);
 
   return rb_float_new(time);
 }
@@ -4987,10 +5115,10 @@ static VALUE ruby_curl_easy_name_lookup_time_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_connect_time_get(VALUE self) {
   ruby_curl_easy *rbce;
-  double time;
+  double time = 0;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
-  curl_easy_getinfo(rbce->curl, CURLINFO_CONNECT_TIME, &time);
+  rbce = ruby_curl_easy_get_handle(self);
+  CURB_GETINFO(rbce->curl, CURLINFO_CONNECT_TIME, &time);
 
   return rb_float_new(time);
 }
@@ -5008,10 +5136,10 @@ static VALUE ruby_curl_easy_connect_time_get(VALUE self) {
 #if defined(HAVE_CURLINFO_APPCONNECT_TIME)
 static VALUE ruby_curl_easy_app_connect_time_get(VALUE self) {
   ruby_curl_easy *rbce;
-  double time;
+  double time = 0;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
-  curl_easy_getinfo(rbce->curl, CURLINFO_APPCONNECT_TIME, &time);
+  rbce = ruby_curl_easy_get_handle(self);
+  CURB_GETINFO(rbce->curl, CURLINFO_APPCONNECT_TIME, &time);
 
   return rb_float_new(time);
 }
@@ -5029,10 +5157,10 @@ static VALUE ruby_curl_easy_app_connect_time_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_pre_transfer_time_get(VALUE self) {
   ruby_curl_easy *rbce;
-  double time;
+  double time = 0;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
-  curl_easy_getinfo(rbce->curl, CURLINFO_PRETRANSFER_TIME, &time);
+  rbce = ruby_curl_easy_get_handle(self);
+  CURB_GETINFO(rbce->curl, CURLINFO_PRETRANSFER_TIME, &time);
 
   return rb_float_new(time);
 }
@@ -5047,10 +5175,10 @@ static VALUE ruby_curl_easy_pre_transfer_time_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_start_transfer_time_get(VALUE self) {
   ruby_curl_easy *rbce;
-  double time;
+  double time = 0;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
-  curl_easy_getinfo(rbce->curl, CURLINFO_STARTTRANSFER_TIME, &time);
+  rbce = ruby_curl_easy_get_handle(self);
+  CURB_GETINFO(rbce->curl, CURLINFO_STARTTRANSFER_TIME, &time);
 
   return rb_float_new(time);
 }
@@ -5069,10 +5197,10 @@ static VALUE ruby_curl_easy_start_transfer_time_get(VALUE self) {
 static VALUE ruby_curl_easy_redirect_time_get(VALUE self) {
 #ifdef HAVE_CURLINFO_REDIRECT_TIME
   ruby_curl_easy *rbce;
-  double time;
+  double time = 0;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
-  curl_easy_getinfo(rbce->curl, CURLINFO_REDIRECT_TIME, &time);
+  rbce = ruby_curl_easy_get_handle(self);
+  CURB_GETINFO(rbce->curl, CURLINFO_REDIRECT_TIME, &time);
 
   return rb_float_new(time);
 #else
@@ -5092,10 +5220,10 @@ static VALUE ruby_curl_easy_redirect_time_get(VALUE self) {
 static VALUE ruby_curl_easy_redirect_count_get(VALUE self) {
 #ifdef HAVE_CURLINFO_REDIRECT_COUNT
   ruby_curl_easy *rbce;
-  long count;
+  long count = 0;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
-  curl_easy_getinfo(rbce->curl, CURLINFO_REDIRECT_COUNT, &count);
+  rbce = ruby_curl_easy_get_handle(self);
+  CURB_GETINFO(rbce->curl, CURLINFO_REDIRECT_COUNT, &count);
 
   return LONG2NUM(count);
 #else
@@ -5117,10 +5245,10 @@ static VALUE ruby_curl_easy_redirect_count_get(VALUE self) {
 static VALUE ruby_curl_easy_redirect_url_get(VALUE self) {
 #ifdef HAVE_CURLINFO_REDIRECT_URL
   ruby_curl_easy *rbce;
-  char* url;
+  char* url = NULL;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
-  curl_easy_getinfo(rbce->curl, CURLINFO_REDIRECT_URL, &url);
+  rbce = ruby_curl_easy_get_handle(self);
+  CURB_GETINFO(rbce->curl, CURLINFO_REDIRECT_URL, &url);
 
   if (url && url[0]) {    // curl returns empty string if none
     return rb_str_new2(url);
@@ -5144,15 +5272,15 @@ static VALUE ruby_curl_easy_redirect_url_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_uploaded_bytes_get(VALUE self) {
   ruby_curl_easy *rbce;
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
 #ifdef HAVE_CURLINFO_SIZE_UPLOAD_T
-  curl_off_t bytes;
-  curl_easy_getinfo(rbce->curl, CURLINFO_SIZE_UPLOAD_T, &bytes);
+  curl_off_t bytes = 0;
+  CURB_GETINFO(rbce->curl, CURLINFO_SIZE_UPLOAD_T, &bytes);
   return LL2NUM(bytes);
 #else
-  double bytes;
-  curl_easy_getinfo(rbce->curl, CURLINFO_SIZE_UPLOAD, &bytes);
+  double bytes = 0;
+  CURB_GETINFO(rbce->curl, CURLINFO_SIZE_UPLOAD, &bytes);
   return rb_float_new(bytes);
 #endif
 }
@@ -5166,15 +5294,15 @@ static VALUE ruby_curl_easy_uploaded_bytes_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_downloaded_bytes_get(VALUE self) {
   ruby_curl_easy *rbce;
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
 #ifdef HAVE_CURLINFO_SIZE_DOWNLOAD_T
-  curl_off_t bytes;
-  curl_easy_getinfo(rbce->curl, CURLINFO_SIZE_DOWNLOAD_T, &bytes);
+  curl_off_t bytes = 0;
+  CURB_GETINFO(rbce->curl, CURLINFO_SIZE_DOWNLOAD_T, &bytes);
   return LL2NUM(bytes);
 #else
-  double bytes;
-  curl_easy_getinfo(rbce->curl, CURLINFO_SIZE_DOWNLOAD, &bytes);
+  double bytes = 0;
+  CURB_GETINFO(rbce->curl, CURLINFO_SIZE_DOWNLOAD, &bytes);
   return rb_float_new(bytes);
 #endif
 }
@@ -5188,15 +5316,15 @@ static VALUE ruby_curl_easy_downloaded_bytes_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_upload_speed_get(VALUE self) {
   ruby_curl_easy *rbce;
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
 #ifdef HAVE_CURLINFO_SPEED_UPLOAD_T
-  curl_off_t bytes;
-  curl_easy_getinfo(rbce->curl, CURLINFO_SPEED_UPLOAD_T, &bytes);
+  curl_off_t bytes = 0;
+  CURB_GETINFO(rbce->curl, CURLINFO_SPEED_UPLOAD_T, &bytes);
   return LL2NUM(bytes);
 #else
-  double bytes;
-  curl_easy_getinfo(rbce->curl, CURLINFO_SPEED_UPLOAD, &bytes);
+  double bytes = 0;
+  CURB_GETINFO(rbce->curl, CURLINFO_SPEED_UPLOAD, &bytes);
   return rb_float_new(bytes);
 #endif
 }
@@ -5210,15 +5338,15 @@ static VALUE ruby_curl_easy_upload_speed_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_download_speed_get(VALUE self) {
   ruby_curl_easy *rbce;
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
 #ifdef HAVE_CURLINFO_SPEED_DOWNLOAD_T
-  curl_off_t bytes;
-  curl_easy_getinfo(rbce->curl, CURLINFO_SPEED_DOWNLOAD_T, &bytes);
+  curl_off_t bytes = 0;
+  CURB_GETINFO(rbce->curl, CURLINFO_SPEED_DOWNLOAD_T, &bytes);
   return LL2NUM(bytes);
 #else
-  double bytes;
-  curl_easy_getinfo(rbce->curl, CURLINFO_SPEED_DOWNLOAD, &bytes);
+  double bytes = 0;
+  CURB_GETINFO(rbce->curl, CURLINFO_SPEED_DOWNLOAD, &bytes);
   return rb_float_new(bytes);
 #endif
 }
@@ -5232,10 +5360,10 @@ static VALUE ruby_curl_easy_download_speed_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_header_size_get(VALUE self) {
   ruby_curl_easy *rbce;
-  long size;
+  long size = 0;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
-  curl_easy_getinfo(rbce->curl, CURLINFO_HEADER_SIZE, &size);
+  rbce = ruby_curl_easy_get_handle(self);
+  CURB_GETINFO(rbce->curl, CURLINFO_HEADER_SIZE, &size);
 
   return LONG2NUM(size);
 }
@@ -5250,10 +5378,10 @@ static VALUE ruby_curl_easy_header_size_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_request_size_get(VALUE self) {
   ruby_curl_easy *rbce;
-  long size;
+  long size = 0;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
-  curl_easy_getinfo(rbce->curl, CURLINFO_REQUEST_SIZE, &size);
+  rbce = ruby_curl_easy_get_handle(self);
+  CURB_GETINFO(rbce->curl, CURLINFO_REQUEST_SIZE, &size);
 
   return LONG2NUM(size);
 }
@@ -5267,10 +5395,10 @@ static VALUE ruby_curl_easy_request_size_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_ssl_verify_result_get(VALUE self) {
   ruby_curl_easy *rbce;
-  long result;
+  long result = 0;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
-  curl_easy_getinfo(rbce->curl, CURLINFO_SSL_VERIFYRESULT, &result);
+  rbce = ruby_curl_easy_get_handle(self);
+  CURB_GETINFO(rbce->curl, CURLINFO_SSL_VERIFYRESULT, &result);
 
   return LONG2NUM(result);
 }
@@ -5292,15 +5420,15 @@ NOTE: you must call curl_slist_free_all(3) on the list pointer once you're done
  */
 static VALUE ruby_curl_easy_downloaded_content_length_get(VALUE self) {
   ruby_curl_easy *rbce;
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
 #ifdef HAVE_CURLINFO_CONTENT_LENGTH_DOWNLOAD_T
-  curl_off_t bytes;
-  curl_easy_getinfo(rbce->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T, &bytes);
+  curl_off_t bytes = 0;
+  CURB_GETINFO(rbce->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T, &bytes);
   return LL2NUM(bytes);
 #else
-  double bytes;
-  curl_easy_getinfo(rbce->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &bytes);
+  double bytes = 0;
+  CURB_GETINFO(rbce->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &bytes);
   return rb_float_new(bytes);
 #endif
 }
@@ -5313,15 +5441,15 @@ static VALUE ruby_curl_easy_downloaded_content_length_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_uploaded_content_length_get(VALUE self) {
   ruby_curl_easy *rbce;
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
 #ifdef HAVE_CURLINFO_CONTENT_LENGTH_UPLOAD_T
-  curl_off_t bytes;
-  curl_easy_getinfo(rbce->curl, CURLINFO_CONTENT_LENGTH_UPLOAD_T, &bytes);
+  curl_off_t bytes = 0;
+  CURB_GETINFO(rbce->curl, CURLINFO_CONTENT_LENGTH_UPLOAD_T, &bytes);
   return LL2NUM(bytes);
 #else
-  double bytes;
-  curl_easy_getinfo(rbce->curl, CURLINFO_CONTENT_LENGTH_UPLOAD, &bytes);
+  double bytes = 0;
+  CURB_GETINFO(rbce->curl, CURLINFO_CONTENT_LENGTH_UPLOAD, &bytes);
   return rb_float_new(bytes);
 #endif
 }
@@ -5337,10 +5465,10 @@ static VALUE ruby_curl_easy_uploaded_content_length_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_content_type_get(VALUE self) {
   ruby_curl_easy *rbce;
-  char* type;
+  char* type = NULL;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
-  curl_easy_getinfo(rbce->curl, CURLINFO_CONTENT_TYPE, &type);
+  rbce = ruby_curl_easy_get_handle(self);
+  CURB_GETINFO(rbce->curl, CURLINFO_CONTENT_TYPE, &type);
 
   if (type && type[0]) {    // curl returns empty string if none
     return rb_str_new2(type);
@@ -5380,10 +5508,10 @@ Pass a pointer to a long to receive a bitmask indicating the authentication meth
 static VALUE ruby_curl_easy_os_errno_get(VALUE self) {
 #ifdef HAVE_CURLINFO_OS_ERRNO
   ruby_curl_easy *rbce;
-  long result;
+  long result = 0;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
-  curl_easy_getinfo(rbce->curl, CURLINFO_OS_ERRNO, &result);
+  rbce = ruby_curl_easy_get_handle(self);
+  CURB_GETINFO(rbce->curl, CURLINFO_OS_ERRNO, &result);
 
   return LONG2NUM(result);
 #else
@@ -5409,10 +5537,10 @@ static VALUE ruby_curl_easy_os_errno_get(VALUE self) {
 static VALUE ruby_curl_easy_num_connects_get(VALUE self) {
 #ifdef HAVE_CURLINFO_NUM_CONNECTS
   ruby_curl_easy *rbce;
-  long result;
+  long result = 0;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
-  curl_easy_getinfo(rbce->curl, CURLINFO_NUM_CONNECTS, &result);
+  rbce = ruby_curl_easy_get_handle(self);
+  CURB_GETINFO(rbce->curl, CURLINFO_NUM_CONNECTS, &result);
 
   return LONG2NUM(result);
 #else
@@ -5444,12 +5572,12 @@ static VALUE ruby_curl_easy_num_connects_get(VALUE self) {
 static VALUE ruby_curl_easy_cookielist_get(VALUE self) {
 #ifdef HAVE_CURLINFO_COOKIELIST
   ruby_curl_easy *rbce;
-  struct curl_slist *cookies;
+  struct curl_slist *cookies = NULL;
   struct curl_slist *cookie;
   VALUE rb_cookies;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
-  curl_easy_getinfo(rbce->curl, CURLINFO_COOKIELIST, &cookies);
+  rbce = ruby_curl_easy_get_handle(self);
+  CURB_GETINFO(rbce->curl, CURLINFO_COOKIELIST, &cookies);
   if (!cookies)
     return Qnil;
   rb_cookies = rb_ary_new();
@@ -5488,8 +5616,8 @@ static VALUE ruby_curl_easy_ftp_entry_path_get(VALUE self) {
   ruby_curl_easy *rbce;
   char* path = NULL;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
-  curl_easy_getinfo(rbce->curl, CURLINFO_FTP_ENTRY_PATH, &path);
+  rbce = ruby_curl_easy_get_handle(self);
+  CURB_GETINFO(rbce->curl, CURLINFO_FTP_ENTRY_PATH, &path);
 
   if (path && path[0]) {    // curl returns NULL or empty string if none
     return rb_str_new2(path);
@@ -5508,7 +5636,7 @@ static VALUE ruby_curl_easy_ftp_entry_path_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_multi_get(VALUE self) {
   ruby_curl_easy *rbce;
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
   return rbce->multi;
 }
 
@@ -5521,7 +5649,7 @@ static VALUE ruby_curl_easy_multi_set(VALUE self, VALUE multi) {
   VALUE old_multi;
   ruby_curl_multi *old_rbcm;
   CURLMcode result;
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
   if (!NIL_P(multi) && rb_obj_is_kind_of(multi, cCurlMulti) != Qtrue) {
     rb_raise(rb_eTypeError, "expected Curl::Multi or nil");
@@ -5550,7 +5678,7 @@ static VALUE ruby_curl_easy_multi_set(VALUE self, VALUE multi) {
  */
 static VALUE ruby_curl_easy_last_result(VALUE self) {
   ruby_curl_easy *rbce;
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
   return LONG2NUM(rbce->last_result);
 }
 
@@ -5560,7 +5688,7 @@ static VALUE ruby_curl_easy_last_result(VALUE self) {
  */
 static VALUE ruby_curl_easy_last_error(VALUE self) {
   ruby_curl_easy *rbce;
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
   if (rbce->err_buf[0]) {    // curl returns NULL or empty string if none
     return rb_str_new2(rbce->err_buf);
@@ -5598,7 +5726,8 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
   long option = NUM2LONG(opt);
   rb_io_t *open_f_ptr;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
+  ruby_curl_easy_check_idle(rbce);
 
   switch (option) {
   /* BEHAVIOR OPTIONS */
@@ -6050,6 +6179,28 @@ static VALUE ruby_curl_easy_inspect(VALUE self) {
 
 /* ================== ESCAPING FUNCS ==============*/
 
+struct curl_string_result {
+  char *data;
+  long length;
+};
+
+static VALUE curl_string_result_body(VALUE argp) {
+  struct curl_string_result *args = (struct curl_string_result *)argp;
+  return rb_str_new(args->data, args->length);
+}
+
+static VALUE curl_string_result_free(VALUE argp) {
+  struct curl_string_result *args = (struct curl_string_result *)argp;
+  curl_free(args->data);
+  return Qnil;
+}
+
+static VALUE curl_string_result_to_ruby(char *data, long length) {
+  struct curl_string_result args = { data, length };
+  return rb_ensure(curl_string_result_body, (VALUE)&args,
+                   curl_string_result_free, (VALUE)&args);
+}
+
 /*
  * call-seq:
  *   easy.escape("some text")                         => "some%20text"
@@ -6062,13 +6213,13 @@ static VALUE ruby_curl_easy_inspect(VALUE self) {
 static VALUE ruby_curl_easy_escape(VALUE self, VALUE svalue) {
   ruby_curl_easy *rbce;
   char *result;
-  VALUE rresult;
   VALUE str = svalue;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
 
-  /* NOTE: make sure the value is a string, if not call to_s */
-  if( rb_type(str) != T_STRING ) { str = rb_funcall(str,rb_intern("to_s"),0); }
+  /* NOTE: make sure the value is a string; rb_obj_as_string always yields a
+   * String, even if the object's to_s misbehaves and returns a non-String. */
+  if( rb_type(str) != T_STRING ) { str = rb_obj_as_string(str); }
 
 #if (LIBCURL_VERSION_NUM >= 0x070f04)
   result = (char*)curl_easy_escape(rbce->curl, StringValuePtr(str), (int)RSTRING_LEN(str));
@@ -6076,10 +6227,8 @@ static VALUE ruby_curl_easy_escape(VALUE self, VALUE svalue) {
   result = (char*)curl_escape(StringValuePtr(str), (int)RSTRING_LEN(str));
 #endif
 
-  rresult = rb_str_new2(result);
-  curl_free(result);
-
-  return rresult;
+  if (!result) rb_raise(eCurlErrError, "Failed to URL-encode string");
+  return curl_string_result_to_ruby(result, (long)strlen(result));
 }
 
 /*
@@ -6094,21 +6243,25 @@ static VALUE ruby_curl_easy_unescape(VALUE self, VALUE str) {
   ruby_curl_easy *rbce;
   int rlen;
   char *result;
-  VALUE rresult;
 
-  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(self);
+
+  /* Coerce as its own statement before use below - StringValuePtr and
+   * RSTRING_LEN are sibling args to the same call and C does not guarantee
+   * left-to-right evaluation order between them. */
+  StringValue(str);
 
 #if (LIBCURL_VERSION_NUM >= 0x070f04)
   result = (char*)curl_easy_unescape(rbce->curl, StringValuePtr(str), (int)RSTRING_LEN(str), &rlen);
 #else
   result = (char*)curl_unescape(StringValuePtr(str), (int)RSTRING_LEN(str));
-  rlen = strlen(result);
 #endif
 
-  rresult = rb_str_new(result, rlen);
-  curl_free(result);
-
-  return rresult;
+  if (!result) rb_raise(eCurlErrError, "Failed to URL-decode string");
+#if (LIBCURL_VERSION_NUM < 0x070f04)
+  rlen = (int)strlen(result);
+#endif
+  return curl_string_result_to_ruby(result, rlen);
 }
 
 
@@ -6132,7 +6285,7 @@ void init_curb_easy() {
   idNetworkPolicyNone = rb_intern("none");
   idNetworkPolicyPublic = rb_intern("public");
 
-  rbstrAmp = rb_str_new2("&");
+  rbstrAmp = rb_obj_freeze(rb_str_new2("&"));
   rb_global_variable(&rbstrAmp);
 
   cCurlEasy = rb_define_class_under(mCurl, "Easy", rb_cObject);
@@ -6203,7 +6356,7 @@ void init_curb_easy() {
   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_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_set, -1);
   rb_define_method(cCurlEasy, "proxy_auth_types", ruby_curl_easy_proxy_auth_types_get, 0);
   rb_define_method(cCurlEasy, "max_redirects=", ruby_curl_easy_max_redirects_set, 1);
   rb_define_method(cCurlEasy, "max_redirects", ruby_curl_easy_max_redirects_get, 0);