curb 1.4.0 → 1.5.0

data/ext/curb_easy.c

@@ -650,6 +650,93 @@ static int curb_host_allowlist_prereq(void *clientp,
 }
 #endif
 
+#if defined(CURB_HAVE_OPENSOCKET_NETWORK_POLICY) && defined(HAVE_CURLOPT_DOH_URL)
+/* libcurl's DoH probe transfers do not inherit the socket policy callback,
+ * so under :public the DoH endpoint must be vetted before the transfer.
+ * Only public IP literals are accepted: a hostname would be resolved outside
+ * the policy, leaving a DNS-rebinding window. The host is taken from
+ * libcurl's own URL parser so it matches what libcurl will connect to. */
+static void curb_check_public_doh_url(ruby_curl_easy *rbce, const char *doh_url) {
+  CURLU *parsed_url;
+  char *host = NULL;
+  char literal[INET6_ADDRSTRLEN + 3];
+  char *address = literal;
+  size_t len;
+  unsigned char ip[16];
+  int parsed = 0;
+
+  parsed_url = curl_url();
+  if (!parsed_url) {
+    rb_raise(rb_eNoMemError, "Failed to allocate URL parser for DoH URL check");
+  }
+  if (curl_url_set(parsed_url, CURLUPART_URL, doh_url, 0) == CURLUE_OK &&
+      curl_url_get(parsed_url, CURLUPART_HOST, &host, 0) == CURLUE_OK && host) {
+    len = strlen(host);
+    if (len < sizeof(literal)) {
+      memcpy(literal, host, len + 1);
+      parsed = 1;
+    }
+  }
+  if (host) curl_free(host);
+  curl_url_cleanup(parsed_url);
+
+  if (!parsed) {
+    rb_raise(eCurlErrUnsafeDestination,
+             "DoH URL must use a public IP address under public network policy");
+  }
+
+  len = strlen(address);
+  if (len >= 2 && address[0] == '[' && address[len - 1] == ']') {
+    address[len - 1] = '\0';
+    address++;
+  }
+
+  if (inet_pton(AF_INET, address, ip) == 1) {
+    if (curb_ipv4_is_unsafe_destination(ip) || !curb_cidr_rules_match(rbce, CURB_CIDR_FAMILY_IPV4, ip)) {
+      rb_raise(eCurlErrUnsafeDestination,
+               "DoH URL address %s is not allowed by public network policy", address);
+    }
+  } else if (inet_pton(AF_INET6, address, ip) == 1) {
+    if (curb_ipv6_is_unsafe_destination(ip) || !curb_cidr_rules_match(rbce, CURB_CIDR_FAMILY_IPV6, ip)) {
+      rb_raise(eCurlErrUnsafeDestination,
+               "DoH URL address %s is not allowed by public network policy", address);
+    }
+  } else {
+    rb_raise(eCurlErrUnsafeDestination,
+             "DoH URL must use a public IP address under public network policy (got host %s)", address);
+  }
+}
+#endif
+
+#ifdef CURB_HAVE_OPENSOCKET_NETWORK_POLICY
+/* file:// opens no socket, so the public policy's socket check never sees
+ * it. Without a protocol allowlist, reject it up front; libcurl's default
+ * redirect protocols already exclude file. The scheme comes from libcurl's
+ * parser when available. */
+static void curb_check_public_url_scheme(const char *url) {
+  int is_file = 0;
+#if LIBCURL_VERSION_NUM >= 0x073e00
+  CURLU *parsed_url = curl_url();
+  char *scheme = NULL;
+  if (!parsed_url) {
+    rb_raise(rb_eNoMemError, "Failed to allocate URL parser for scheme check");
+  }
+  if (curl_url_set(parsed_url, CURLUPART_URL, url, CURLU_GUESS_SCHEME | CURLU_NON_SUPPORT_SCHEME) == CURLUE_OK &&
+      curl_url_get(parsed_url, CURLUPART_SCHEME, &scheme, 0) == CURLUE_OK && scheme) {
+    is_file = STRCASECMP(scheme, "file") == 0;
+  }
+  if (scheme) curl_free(scheme);
+  curl_url_cleanup(parsed_url);
+#else
+  while (*url == ' ' || *url == '\t') url++;
+  is_file = STRNCASECMP(url, "file:", 5) == 0;
+#endif
+  if (is_file) {
+    rb_raise(eCurlErrUnsafeDestination, "file:// URLs are not allowed by public network policy");
+  }
+}
+#endif
+
 #ifdef CURB_HAVE_OPENSOCKET_NETWORK_POLICY
 static curl_socket_t curb_public_network_opensocket(void *clientp, curlsocktype purpose, struct curl_sockaddr *address) {
   ruby_curl_easy *rbce = (ruby_curl_easy *)clientp;
@@ -704,6 +791,14 @@ static curl_socket_t curb_public_network_opensocket(void *clientp, curlsocktype
   }
 #endif
 
+  /* Anything other than an IP socket (e.g. a Unix domain socket configured
+   * after the policy was applied) has no address to vet. Refuse it unless
+   * Unix sockets were explicitly allowed. */
+  if (!checked_destination_address && rbce && !rbce->allow_unix_socket) {
+    curb_store_destination_error(rbce, "(non-IP socket)", "is not allowed");
+    return CURL_SOCKET_BAD;
+  }
+
   if (!checked_destination_address && rbce && rbce->network_allowed_cidr_rule_count > 0) {
     curb_store_destination_error(rbce, "unknown", "outside allowed CIDR ranges");
     return CURL_SOCKET_BAD;
@@ -747,7 +842,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);
 }
 
@@ -879,6 +974,13 @@ static int ruby_curl_easy_body_limit_exceeded(ruby_curl_easy *rbce, size_t total
   return 0;
 }
 
+/* Initial capacity for the default body/header buffers. rb_str_buf_cat grows
+ * them geometrically, so starting small costs a few reallocations at most,
+ * while a large fixed reservation stays attached to every returned body_str
+ * (a 2 KB response used to keep 32 KB alive). */
+#define CURB_DEFAULT_BODY_BUFFER_CAPA 0
+#define CURB_DEFAULT_HEADER_BUFFER_CAPA 0
+
 /* Default body handler appends to easy.body_data buffer */
 static size_t default_body_handler(char *stream,
                                    size_t size,
@@ -893,7 +995,7 @@ static size_t default_body_handler(char *stream,
   }
 
   if (NIL_P(out)) {
-    out = rb_easy_set("body_data", rb_str_buf_new(32768));
+    out = rb_easy_set("body_data", rb_str_buf_new(CURB_DEFAULT_BODY_BUFFER_CAPA));
   }
   rb_str_buf_cat(out, stream, total);
   return total;
@@ -908,7 +1010,7 @@ static size_t default_header_handler(char *stream,
   size_t total = size * nmemb;
   VALUE out = rb_easy_get("header_data");
   if (NIL_P(out)) {
-    out = rb_easy_set("header_data", rb_str_buf_new(16384));
+    out = rb_easy_set("header_data", rb_str_buf_new(CURB_DEFAULT_HEADER_BUFFER_CAPA));
   }
   rb_str_buf_cat(out, stream, total);
   return total;
@@ -1303,6 +1405,49 @@ 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;
+}
+
+/* Release the curb-owned CURLOPT_STDERR stream. Callers must first stop
+ * libcurl from using it (cleanup, reset, or setopt of a replacement). */
+static void ruby_curl_easy_close_stderr_file(ruby_curl_easy *rbce) {
+  FILE *fp = rbce->stderr_file;
+  if (fp) {
+    rbce->stderr_file = NULL;
+    fclose(fp);
+  }
+}
+
+/* Open a stream curb owns on a duplicate of fd, so its lifetime is
+ * independent of the Ruby IO it came from. */
+static FILE *ruby_curl_easy_dup_stderr_file(int fd) {
+  FILE *fp;
+  int dup_fd = rb_cloexec_dup(fd);
+  if (dup_fd < 0) {
+    rb_sys_fail("dup(CURLOPT_STDERR)");
+  }
+  rb_update_max_fd(dup_fd);
+  /* "w" on an existing descriptor neither truncates nor changes O_APPEND. */
+  fp = fdopen(dup_fd, "w");
+  if (!fp) {
+    int saved_errno = errno;
+    close(dup_fd);
+    errno = saved_errno;
+    rb_sys_fail("fdopen(CURLOPT_STDERR)");
+  }
+  return fp;
+}
+
 static void ruby_curl_easy_free(ruby_curl_easy *rbce) {
   if (!rbce) {
     return;
@@ -1319,10 +1464,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);
     }
   }
 
@@ -1352,6 +1494,8 @@ static void ruby_curl_easy_free(ruby_curl_easy *rbce) {
     curl_easy_cleanup(rbce->curl);
     rbce->curl = NULL;
   }
+  /* After cleanup: libcurl may log while closing connections. */
+  ruby_curl_easy_close_stderr_file(rbce);
 
   rbce->self = Qnil;
 }
@@ -1396,6 +1540,48 @@ 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;
+}
+
+/* Entry points that hand libcurl new request state (bodies, verbs, setup)
+ * must not run while libcurl is still using the old state: replacing it
+ * mid-transfer frees buffers libcurl is reading (use-after-free). */
+static ruby_curl_easy *ruby_curl_easy_get_idle_handle(VALUE self) {
+  ruby_curl_easy *rbce = ruby_curl_easy_get_handle(self);
+  ruby_curl_easy_check_idle(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) {
@@ -1414,6 +1600,8 @@ static void ruby_curl_easy_zero(ruby_curl_easy *rbce) {
   rbce->network_allowed_hosts = NULL;
   rbce->network_allowed_cidr_rule_count = 0;
   rbce->network_allowed_host_count = 0;
+  /* Callers that may hold a stream close it before zeroing. */
+  rbce->stderr_file = NULL;
 
   /* various-typed opts */
   rbce->local_port = 0;
@@ -1423,6 +1611,8 @@ static void ruby_curl_easy_zero(ruby_curl_easy *rbce) {
   rbce->http_auth_types = 0;
   rbce->proxy_auth_types = 0;
   rbce->max_redirs = -1;
+  rbce->max_redirs_set = 0;
+  rbce->protocols_set = 0;
   rbce->timeout = 0;
   rbce->timeout_ms = 0;
   rbce->connect_timeout = 0;
@@ -1451,6 +1641,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 +1692,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,25 +1773,45 @@ 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);
+  FILE *clone_stderr_file = NULL;
 
-  newrbce = ALLOC(ruby_curl_easy);
-  if (!newrbce) {
-    rb_raise(rb_eNoMemError, "Failed to allocate memory for Curl::Easy clone");
+  rbce = ruby_curl_easy_get_handle(self);
+
+  /* Duplicate first: this can raise, and nothing needs unwinding yet. */
+  if (rbce->stderr_file) {
+    clone_stderr_file = ruby_curl_easy_dup_stderr_file(fileno(rbce->stderr_file));
   }
+
+  newrbce = ALLOC(ruby_curl_easy);
   /* shallow copy */
   memcpy(newrbce, rbce, sizeof(ruby_curl_easy));
 
   /* now deep copy */
   newrbce->curl = curl_easy_duphandle(rbce->curl);
   if (!newrbce->curl) {
-    free(newrbce);
+    xfree(newrbce);
+    if (clone_stderr_file) fclose(clone_stderr_file);
     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);
+      xfree(newrbce);
+      if (clone_stderr_file) fclose(clone_stderr_file);
+      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;
@@ -1600,9 +1822,17 @@ static VALUE ruby_curl_easy_clone(VALUE self) {
   newrbce->network_allowed_hosts = NULL;
   newrbce->network_allowed_host_count = 0;
 
+  /* duphandle copied the original's CURLOPT_STDERR pointer; give the clone
+   * its own stream so neither handle can outlive the other's. */
+  newrbce->stderr_file = clone_stderr_file;
+  if (clone_stderr_file) {
+    curl_easy_setopt(newrbce->curl, CURLOPT_STDERR, clone_stderr_file);
+  }
+
   /* 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 +1878,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 +1888,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 +1932,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,10 +1942,15 @@ 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);
   curl_easy_reset(rbce->curl);
+  /* reset restored libcurl's default stderr, so ours is unused now. */
+  ruby_curl_easy_close_stderr_file(rbce);
   ruby_curl_easy_zero(rbce);
   rbce->self = self;
 
@@ -1790,7 +2028,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 +2063,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 +2313,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_idle_handle(self);
 
   curl = rbce->curl;
 
@@ -2134,7 +2372,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 +2409,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_idle_handle(self);
 
   /*
    * Validate and prepare Ruby-visible state before mutating the CURL handle.
@@ -2356,7 +2594,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 +2603,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 +2622,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 +2643,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 +2662,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 +2679,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 +2853,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 +2884,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);
@@ -2668,14 +2906,27 @@ static VALUE ruby_curl_easy_proxy_auth_types_get(VALUE self) {
  *   easy.max_redirects = fixnum or nil               => fixnum or nil
  *
  * Set the maximum number of redirections to follow in the following +perform+
- * calls. Set to nil or -1 allow an infinite number (the default). Setting this
- * option only makes sense if +follow_location+ is also set true.
+ * calls. Set to -1 to allow an infinite number. When nil (the default), at
+ * most 30 redirects are followed, matching libcurl 8.3+ on every libcurl
+ * version. Setting this option only makes sense if +follow_location+ is also
+ * set true.
  *
  * With libcurl >= 7.15.1, setting this to 0 will cause libcurl to refuse any
  * redirect.
  */
 static VALUE ruby_curl_easy_max_redirects_set(VALUE self, VALUE max_redirs) {
-  CURB_IMMED_SETTER(ruby_curl_easy, max_redirs, -1);
+  ruby_curl_easy *rbce;
+
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  ruby_curl_easy_check_access(rbce);
+  if (NIL_P(max_redirs)) {
+    rbce->max_redirs = -1;
+    rbce->max_redirs_set = 0;
+  } else {
+    rbce->max_redirs = NUM2LONG(max_redirs);
+    rbce->max_redirs_set = 1;
+  }
+  return max_redirs;
 }
 
 /*
@@ -2708,7 +2959,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 +2982,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 +3000,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 +3020,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 +3493,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_idle_handle(self);
 
   if (Qtrue == autoreferer) {
     curl_easy_setopt(rbce->curl, CURLOPT_AUTOREFERER, 1);
@@ -3399,7 +3650,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 +3682,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 +3711,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 +3735,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 +3773,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 +3791,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 +3810,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 +3832,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);
 }
@@ -3743,6 +3994,37 @@ static VALUE ruby_curl_easy_on_debug_set(int argc, VALUE *argv, VALUE self) {
 
 /* =================== PERFORM =====================*/
 
+/* CR or LF in a header line would let the value inject extra headers or
+ * split the request; libcurl sends header strings verbatim. NUL would
+ * silently truncate the line. */
+static void curb_check_header_line_len(const char *ptr, long len, const char *what) {
+  if (memchr(ptr, '\r', (size_t)len) || memchr(ptr, '\n', (size_t)len) || memchr(ptr, '\0', (size_t)len)) {
+    rb_raise(rb_eArgError, "%s must not contain CR, LF, or NUL characters", what);
+  }
+}
+
+static void curb_check_header_line(VALUE str, const char *what) {
+  curb_check_header_line_len(RSTRING_PTR(str), RSTRING_LEN(str), what);
+}
+
+/* A String for the option stored under key, converting like rb_easy_get_str. */
+static VALUE curb_easy_opt_string(ruby_curl_easy *rbce, const char *key) {
+  VALUE value = rb_hash_aref(rbce->opts, rb_easy_hkey(key));
+  return RB_TYPE_P(value, T_STRING) ? value : rb_str_to_str(value);
+}
+
+static int curb_slist_has_header(const struct curl_slist *list, const char *name) {
+  size_t name_len = strlen(name);
+  for (; list; list = list->next) {
+    const char *line = list->data;
+    if (line && STRNCASECMP(line, name, name_len) == 0 &&
+        (line[name_len] == ':' || line[name_len] == ';')) {
+      return 1;
+    }
+  }
+  return 0;
+}
+
 /***********************************************
  * This is an rb_iterate callback used to set up http headers.
  */
@@ -3774,6 +4056,8 @@ static VALUE cb_each_http_header(VALUE header, VALUE wrap, int _c, const VALUE *
 
   //rb_p(header_str);
 
+  StringValue(header_str);
+  curb_check_header_line(header_str, "HTTP header");
   struct curl_slist *new_list = curl_slist_append(*list, StringValuePtr(header_str));
   if (!new_list) {
     rb_raise(rb_eNoMemError, "Failed to append to header list");
@@ -3810,6 +4094,8 @@ static VALUE cb_each_http_proxy_header(VALUE proxy_header, VALUE wrap, int _c, c
 
   //rb_p(header_str);
 
+  StringValue(proxy_header_str);
+  curb_check_header_line(proxy_header_str, "HTTP proxy header");
   struct curl_slist *new_list = curl_slist_append(*list, StringValuePtr(proxy_header_str));
   if (!new_list) {
     rb_raise(rb_eNoMemError, "Failed to append to proxy header list");
@@ -3955,6 +4241,17 @@ static VALUE ruby_curl_easy_setup_body(VALUE arg) {
     curl_easy_setopt(curl, CURLOPT_FORBID_REUSE, rbce->forbid_reuse_set ? rbce->forbid_reuse : 0L);
 #endif
   }
+  /* With a protocol allowlist, libcurl enforces it (UnsupportedProtocolError)
+   * and an explicit :file entry is a deliberate opt-in. */
+  if (rbce->network_policy == CURB_NETWORK_POLICY_PUBLIC && !rbce->protocols_set) {
+    curb_check_public_url_scheme(StringValueCStr(url));
+  }
+#ifdef HAVE_CURLOPT_DOH_URL
+  /* After the CIDR rules above are prepared. */
+  if (rbce->network_policy == CURB_NETWORK_POLICY_PUBLIC && !rb_easy_nil("doh_url")) {
+    curb_check_public_doh_url(rbce, rb_easy_get_str("doh_url"));
+  }
+#endif
 #endif
 
   // network stuff and auth
@@ -4021,7 +4318,7 @@ static VALUE ruby_curl_easy_setup_body(VALUE arg) {
     /* clear out the body_data if it was set */
     rb_easy_del("body_data");
   } else {
-    rb_easy_set("body_data", rb_str_buf_new(32768));
+    rb_easy_set("body_data", rb_str_buf_new(CURB_DEFAULT_BODY_BUFFER_CAPA));
     curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)&default_body_handler);
     curl_easy_setopt(curl, CURLOPT_WRITEDATA, rbce);
   }
@@ -4032,7 +4329,7 @@ static VALUE ruby_curl_easy_setup_body(VALUE arg) {
     /* clear out the header_data if it was set */
     rb_easy_del("header_data");
   } else {
-    rb_easy_set("header_data", rb_str_buf_new(16384));
+    rb_easy_set("header_data", rb_str_buf_new(CURB_DEFAULT_HEADER_BUFFER_CAPA));
     curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, (curl_write_callback)&default_header_handler);
     curl_easy_setopt(curl, CURLOPT_HEADERDATA, rbce);
   }
@@ -4076,14 +4373,20 @@ static VALUE ruby_curl_easy_setup_body(VALUE arg) {
 
   curl_easy_setopt(curl, CURLOPT_HEADER, rbce->header_in_body);
   curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, rbce->follow_location);
+  /* Unset: cap at 30, libcurl's default since 8.3.0. Passing curb's old
+   * default of -1 made redirects unlimited on every libcurl version. */
+  if (!rbce->max_redirs_set) {
+    curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 30L);
+  } else {
 #if LIBCURL_VERSION_NUM == 0x081000
-  /* Work around 8.16.0 regression that clamps -1 (infinite) to zero */
-  if (rbce->max_redirs >= 0) {
-    curl_easy_setopt(curl, CURLOPT_MAXREDIRS, rbce->max_redirs);
-  }
+    /* Work around 8.16.0 regression that clamps -1 (infinite) to zero */
+    if (rbce->max_redirs >= 0) {
+      curl_easy_setopt(curl, CURLOPT_MAXREDIRS, rbce->max_redirs);
+    }
 #else
-  curl_easy_setopt(curl, CURLOPT_MAXREDIRS, rbce->max_redirs);
+    curl_easy_setopt(curl, CURLOPT_MAXREDIRS, rbce->max_redirs);
 #endif
+  }
 
   curl_easy_setopt(curl, CURLOPT_HTTPPROXYTUNNEL,
                    public_policy_disables_proxy ? 0L : rbce->proxy_tunnel);
@@ -4199,9 +4502,7 @@ static VALUE ruby_curl_easy_setup_body(VALUE arg) {
     curl_easy_setopt(curl, CURLOPT_COOKIEFILE, "");
   }
 
-  if (!rb_easy_nil("cookies")) {
-    curl_easy_setopt(curl, CURLOPT_COOKIE, rb_easy_get_str("cookies"));
-  }
+  /* cookies= is applied after the HTTP headers below. */
 
   /* Set up HTTPS cert handling if necessary */
   if (!rb_easy_nil("cert")) {
@@ -4246,7 +4547,9 @@ static VALUE ruby_curl_easy_setup_body(VALUE arg) {
 
   /* Set the user-agent string if specified */
   if (!rb_easy_nil("useragent")) {
-    curl_easy_setopt(curl, CURLOPT_USERAGENT, rb_easy_get_str("useragent"));
+    VALUE useragent = curb_easy_opt_string(rbce, "useragent");
+    curb_check_header_line(useragent, "useragent");
+    curl_easy_setopt(curl, CURLOPT_USERAGENT, RSTRING_PTR(useragent));
   }
 
   /* Setup can be rerun for safety-policy changes while a handle is attached.
@@ -4263,6 +4566,7 @@ static VALUE ruby_curl_easy_setup_body(VALUE arg) {
       rb_block_call(rb_easy_get("headers"), rb_intern("each"), 0, NULL, cb_each_http_header, wrap);
     } else {
       VALUE headers_str = rb_obj_as_string(rb_easy_get("headers"));
+      curb_check_header_line(headers_str, "HTTP header");
       struct curl_slist *new_list = curl_slist_append(*hdrs, StringValuePtr(headers_str));
       if (!new_list) {
         rb_raise(rb_eNoMemError, "Failed to append to headers list");
@@ -4275,6 +4579,28 @@ static VALUE ruby_curl_easy_setup_body(VALUE arg) {
     }
   }
 
+  /* cookies=: libcurl sends CURLOPT_COOKIE to every host a redirect reaches,
+   * but drops a custom Cookie header on cross-host redirects (7.83+). So
+   * send it as a header, unless the cookie engine is on: libcurl would then
+   * emit a second Cookie line, so CURLOPT_COOKIE is kept to merge them. */
+  curl_easy_setopt(curl, CURLOPT_COOKIE, NULL);
+  if (!rb_easy_nil("cookies")) {
+    VALUE cookies = curb_easy_opt_string(rbce, "cookies");
+    curb_check_header_line(cookies, "cookies");
+    if (rbce->enable_cookies || rbce->cookielist_engine_enabled) {
+      curl_easy_setopt(curl, CURLOPT_COOKIE, RSTRING_PTR(cookies));
+    } else if (RSTRING_LEN(cookies) > 0 && !curb_slist_has_header(*hdrs, "Cookie")) {
+      /* An explicit Cookie header already wins over cookies=, as before. */
+      VALUE cookie_header = rb_str_plus(rb_str_new_cstr("Cookie: "), cookies);
+      struct curl_slist *new_list = curl_slist_append(*hdrs, StringValueCStr(cookie_header));
+      if (!new_list) {
+        rb_raise(rb_eNoMemError, "Failed to append to headers list");
+      }
+      *hdrs = new_list;
+      curl_easy_setopt(curl, CURLOPT_HTTPHEADER, *hdrs);
+    }
+  }
+
 #ifdef HAVE_CURLOPT_PROXYHEADER
   /* Setup HTTP proxy headers if necessary */
   curl_easy_setopt(curl, CURLOPT_PROXYHEADER, NULL);   // XXX: maybe we shouldn't be clearing this?
@@ -4285,6 +4611,7 @@ static VALUE ruby_curl_easy_setup_body(VALUE arg) {
       rb_block_call(rb_easy_get("proxy_headers"), rb_intern("each"), 0, NULL, cb_each_http_proxy_header, wrap);
     } else {
       VALUE proxy_headers_str = rb_obj_as_string(rb_easy_get("proxy_headers"));
+      curb_check_header_line(proxy_headers_str, "HTTP proxy header");
       struct curl_slist *new_list = curl_slist_append(*phdrs, StringValuePtr(proxy_headers_str));
       if (!new_list) {
         rb_raise(rb_eNoMemError, "Failed to append to proxy headers list");
@@ -4364,7 +4691,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_idle_handle(self);
   ruby_curl_easy_setup(rbce);
 
   return self;
@@ -4470,11 +4797,13 @@ 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_idle_handle(self);
   curl = rbce->curl;
 
   memset(rbce->err_buf, 0, CURL_ERROR_SIZE);
 
+  if (verb) curb_check_header_line_len(verb, (long)strlen(verb), "HTTP verb");
+
   /* Use method override and adjust related options for special verbs. */
   curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, verb);
 
@@ -4535,6 +4864,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 +4887,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 +4911,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 +4950,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 +4987,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_idle_handle(self);
   curl = rbce->curl;
 
   memset(rbce->err_buf, 0, CURL_ERROR_SIZE);
@@ -4649,7 +4996,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 +5046,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_idle_handle(self);
   curl = rbce->curl;
 
   /* Clear the error buffer */
@@ -4710,7 +5057,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 +5095,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_idle_handle(self);
   curl = rbce->curl;
 
   memset(rbce->err_buf, 0, CURL_ERROR_SIZE);
@@ -4768,7 +5115,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 +5162,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 +5217,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 +5240,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 +5264,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 +5285,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 +5313,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 +5334,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 +5351,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 +5368,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 +5389,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 +5410,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 +5428,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 +5450,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 +5473,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 +5498,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 +5525,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 +5547,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 +5569,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 +5591,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 +5613,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 +5631,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 +5648,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 +5673,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 +5694,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 +5718,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 +5761,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 +5790,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 +5825,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 +5869,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 +5889,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 +5902,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 +5931,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 +5941,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 +5979,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 */
@@ -5652,6 +6000,7 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
     CURB_OBJECT_HSETTER(ruby_curl_easy, url);
     } break;
   case CURLOPT_CUSTOMREQUEST:
+    if (!NIL_P(val)) curb_check_header_line(StringValue(val), "custom request method");
     curl_easy_setopt(rbce->curl, CURLOPT_CUSTOMREQUEST, NIL_P(val) ? NULL : StringValueCStr(val));
     break;
   case CURLOPT_HTTP_VERSION: {
@@ -5727,6 +6076,7 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
 #ifdef HAVE_CURLOPT_REQUEST_TARGET
   case CURLOPT_REQUEST_TARGET: {
     /* Forward request-target directly to libcurl as a string. */
+    if (!NIL_P(val)) curb_check_header_line(StringValue(val), "request target");
     curl_easy_setopt(rbce->curl, CURLOPT_REQUEST_TARGET, NIL_P(val) ? NULL : StringValueCStr(val));
     } break;
 #endif
@@ -5883,23 +6233,36 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
     curl_easy_setopt(rbce->curl, CURLOPT_HAPROXYPROTOCOL, NUM2LONG(val));
     break;
 #endif
-  case CURLOPT_STDERR:
+  case CURLOPT_STDERR: {
     // libcurl requires raw FILE pointer and this should be IO object in Ruby.
     // Tempfile or StringIO won't work.
+    FILE *stderr_file;
     Check_Type(val, T_FILE);
     GetOpenFile(val, open_f_ptr);
-    curl_easy_setopt(rbce->curl, CURLOPT_STDERR, rb_io_stdio_file(open_f_ptr));
-    /* Retain a Ruby reference to the IO to prevent GC/finalization
-     * while libcurl still holds and writes to the underlying FILE*. */
+    rb_io_check_writable(open_f_ptr);
+    /* Hand libcurl a stream curb owns on a duplicate descriptor. Passing
+     * the IO's own FILE* left libcurl writing through freed memory once the
+     * caller closed the IO, including after Multi#add. */
+#ifdef HAVE_RB_IO_DESCRIPTOR
+    stderr_file = ruby_curl_easy_dup_stderr_file(rb_io_descriptor(val));
+#else
+    stderr_file = ruby_curl_easy_dup_stderr_file(open_f_ptr->fd);
+#endif
+    curl_easy_setopt(rbce->curl, CURLOPT_STDERR, stderr_file);
+    ruby_curl_easy_close_stderr_file(rbce);
+    rbce->stderr_file = stderr_file;
+    /* Kept so completion can flush the caller's own buffered output. */
     rb_easy_set("stderr_io", val);
-    break;
+    } break;
   case CURLOPT_PROTOCOLS:
   case CURLOPT_REDIR_PROTOCOLS:
     curl_easy_setopt(rbce->curl, option, NUM2LONG(val));
+    if (option == CURLOPT_PROTOCOLS) rbce->protocols_set = 1;
     break;
 #ifdef HAVE_CURLOPT_PROTOCOLS_STR
   case CURLOPT_PROTOCOLS_STR:
     curl_easy_setopt(rbce->curl, CURLOPT_PROTOCOLS_STR, NIL_P(val) ? NULL : StringValueCStr(val));
+    rbce->protocols_set = !NIL_P(val);
     break;
 #endif
 #ifdef HAVE_CURLOPT_REDIR_PROTOCOLS_STR
@@ -6084,6 +6447,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 +6481,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 +6495,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 +6511,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 +6523,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);
 }