curb 1.4.0 → 1.4.1

data/ext/curb_easy.c

@@ -747,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);
 }
 
@@ -1303,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;
@@ -1319,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);
     }
   }
 
@@ -1396,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) {
@@ -1451,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;
@@ -1500,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) {
@@ -1571,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) {
@@ -1590,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;
@@ -1603,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;
@@ -1648,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");
@@ -1658,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 */
@@ -1699,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");
@@ -1709,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);
@@ -1790,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;
@@ -1825,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;
@@ -2075,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;
 
@@ -2134,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,
@@ -2171,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.
@@ -2356,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;
@@ -2365,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;
@@ -2384,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);
@@ -2405,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);
@@ -2424,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);
@@ -2441,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);
@@ -2615,7 +2691,7 @@ static VALUE ruby_curl_easy_http_auth_types_set(int argc, VALUE *argv, VALUE sel
   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);
 
   rbce->http_auth_types = ruby_curl_easy_auth_types_to_mask(args_ary);
   return LONG2NUM(rbce->http_auth_types);
@@ -2646,7 +2722,7 @@ static VALUE ruby_curl_easy_proxy_auth_types_set(int argc, VALUE *argv, VALUE se
   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);
 
   rbce->proxy_auth_types = ruby_curl_easy_auth_types_to_mask(args_ary);
   return LONG2NUM(rbce->proxy_auth_types);
@@ -2708,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;
@@ -2731,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);
 }
 
@@ -2749,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;
@@ -2769,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);
 }
 
@@ -3242,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);
@@ -3399,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;
 
@@ -3431,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);
 
@@ -3460,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:
@@ -3484,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;
@@ -3522,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);
@@ -3540,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");
 }
@@ -3559,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;
@@ -3581,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);
 }
@@ -4364,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;
@@ -4470,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);
@@ -4535,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 {
@@ -4556,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");
@@ -4579,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);
@@ -4606,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;
 }
 
@@ -4640,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);
@@ -4649,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;
@@ -4699,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 */
@@ -4710,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 {
@@ -4748,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);
@@ -4768,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;
   }
@@ -4815,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"));
@@ -4870,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);
@@ -4893,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);
@@ -4917,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);
@@ -4938,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);
 }
@@ -4966,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
@@ -4987,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);
 }
@@ -5004,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);
 }
@@ -5021,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);
 }
@@ -5042,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);
 }
@@ -5063,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);
 }
@@ -5081,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);
 }
@@ -5103,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
@@ -5126,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
@@ -5151,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);
@@ -5178,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
 }
@@ -5200,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
 }
@@ -5222,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
 }
@@ -5244,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
 }
@@ -5266,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);
 }
@@ -5284,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);
 }
@@ -5301,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);
 }
@@ -5326,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
 }
@@ -5347,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
 }
@@ -5371,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);
@@ -5414,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
@@ -5443,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
@@ -5478,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();
@@ -5522,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);
@@ -5542,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;
 }
 
@@ -5555,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");
@@ -5584,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);
 }
 
@@ -5594,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);
@@ -5632,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 */
@@ -6084,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"
@@ -6096,10 +6213,9 @@ 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; rb_obj_as_string always yields a
    * String, even if the object's to_s misbehaves and returns a non-String. */
@@ -6111,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));
 }
 
 /*
@@ -6129,9 +6243,8 @@ 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
@@ -6142,13 +6255,13 @@ static VALUE ruby_curl_easy_unescape(VALUE self, VALUE str) {
   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);
 }