curb 1.4.0 → 1.4.1

data/ext/curb_easy.h

@@ -93,6 +93,8 @@ typedef struct {
   char unrestricted_auth;
   char verbose;
   char multipart_form_post;
+  char multipart_building; /* Disallow reentry while Ruby builds the form. */
+  char multipart_form_active; /* Temporary CURLOPT_HTTPPOST owned by perform. */
   char enable_cookies;
   char cookielist_engine_enabled; /* track if CURLOPT_COOKIELIST was used with a non-command to enable engine */
   char ignore_content_length;
@@ -124,6 +126,9 @@ typedef struct {
 extern VALUE cCurlEasy;
 extern const rb_data_type_t ruby_curl_easy_data_type;
 
+ruby_curl_easy *ruby_curl_easy_get_handle(VALUE self);
+void ruby_curl_easy_check_access(ruby_curl_easy *rbce);
+
 VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce);
 VALUE ruby_curl_easy_cleanup(VALUE self, ruby_curl_easy *rbce);
 VALUE rb_curl_easy_take_callback_error(ruby_curl_easy *rbce);

data/ext/curb_macros.h

@@ -20,12 +20,17 @@
 #define rb_easy_get_str(key) \
   RSTRING_PTR((rb_easy_type_check(key,T_STRING) ? rb_easy_get(key) : rb_str_to_str(rb_easy_get(key))))
 
+/* Easy attribute macros also participate in the native access guard. */
+#define CURB_CHECK_ACCESS_ruby_curl_easy(ptr) ruby_curl_easy_check_access(ptr)
+#define CURB_CHECK_ACCESS_ruby_curl_postfield(ptr) ((void)0)
+
 /* getter/setter macros for various things */
 /* setter for anything that stores a ruby VALUE in the struct */
 #define CURB_OBJECT_SETTER(type, attr)                              \
             type *ptr;                                              \
                                                                     \
             TypedData_Get_Struct(self, type, &type##_data_type, ptr); \
+            CURB_CHECK_ACCESS_##type(ptr);                          \
             ptr->attr = attr;                                       \
                                                                     \
             return attr;
@@ -35,6 +40,7 @@
             type *ptr;                                              \
                                                                     \
             TypedData_Get_Struct(self, type, &type##_data_type, ptr); \
+            CURB_CHECK_ACCESS_##type(ptr);                          \
             return ptr->attr;
 
 /* setter for anything that stores a ruby VALUE in the struct opts hash */
@@ -42,6 +48,7 @@
             type *ptr;                                              \
                                                                     \
             TypedData_Get_Struct(self, type, &type##_data_type, ptr); \
+            CURB_CHECK_ACCESS_##type(ptr);                          \
             rb_hash_aset(ptr->opts, rb_easy_hkey(#attr), attr);       \
                                                                     \
             return attr;
@@ -51,12 +58,14 @@
             type *ptr;                                              \
                                                                     \
             TypedData_Get_Struct(self, type, &type##_data_type, ptr); \
+            CURB_CHECK_ACCESS_##type(ptr);                          \
             return rb_hash_aref(ptr->opts, rb_easy_hkey(#attr));
 
 /* setter for bool flags */
 #define CURB_BOOLEAN_SETTER(type, attr)                             \
             type *ptr;                                              \
             TypedData_Get_Struct(self, type, &type##_data_type, ptr); \
+            CURB_CHECK_ACCESS_##type(ptr);                          \
                                                                     \
             if (attr == Qnil || attr == Qfalse) {                   \
               ptr->attr = 0;                                        \
@@ -70,6 +79,7 @@
 #define CURB_BOOLEAN_GETTER(type, attr)                             \
             type *ptr;                                              \
             TypedData_Get_Struct(self, type, &type##_data_type, ptr); \
+            CURB_CHECK_ACCESS_##type(ptr);                          \
                                                                     \
             return((ptr->attr) ? Qtrue : Qfalse);
 
@@ -79,6 +89,7 @@
             VALUE oldproc;                                          \
                                                                     \
             TypedData_Get_Struct(self, type, &type##_data_type, ptr); \
+            CURB_CHECK_ACCESS_##type(ptr);                          \
                                                                     \
             oldproc = ptr->handler;                                 \
             rb_scan_args(argc, argv, "0&", &ptr->handler);          \
@@ -91,6 +102,7 @@
             VALUE oldproc, newproc;                                     \
                                                                         \
             TypedData_Get_Struct(self, type, &type##_data_type, ptr);   \
+            CURB_CHECK_ACCESS_##type(ptr);                          \
                                                                         \
             oldproc = rb_hash_aref(ptr->opts, rb_easy_hkey(#handler));   \
             rb_scan_args(argc, argv, "0&", &newproc);                   \
@@ -104,6 +116,7 @@
             type *ptr;                                              \
                                                                     \
             TypedData_Get_Struct(self, type, &type##_data_type, ptr); \
+            CURB_CHECK_ACCESS_##type(ptr);                          \
             if (attr == Qnil) {                                     \
               ptr->attr = nilval;                                   \
             } else {                                                \
@@ -117,6 +130,7 @@
             type *ptr;                                              \
                                                                     \
             TypedData_Get_Struct(self, type, &type##_data_type, ptr); \
+            CURB_CHECK_ACCESS_##type(ptr);                          \
             if (ptr->attr == nilval) {                              \
               return Qnil;                                          \
             } else {                                                \
@@ -128,6 +142,7 @@
             type *ptr;                                              \
                                                                     \
             TypedData_Get_Struct(self, type, &type##_data_type, ptr); \
+            CURB_CHECK_ACCESS_##type(ptr);                          \
             if (attr == Qnil) {                                     \
               ptr->attr = 0;                                        \
             } else {                                                \
@@ -147,6 +162,7 @@
             type *ptr;                                              \
                                                                     \
             TypedData_Get_Struct(self, type, &type##_data_type, ptr); \
+            CURB_CHECK_ACCESS_##type(ptr);                          \
             if (ptr->attr == 0) {                                   \
               return Qnil;                                          \
             } else {                                                \

data/ext/curb_multi.c

@@ -250,7 +250,7 @@ static void rb_curl_multi_detach_all(ruby_curl_multi *rbcm);
 static void curl_multi_mark(void *ptr);
 static void ruby_curl_multi_ensure_handle(ruby_curl_multi *rbcm);
 static int rb_curl_multi_has_easy(ruby_curl_multi *rbcm, ruby_curl_easy *rbce);
-static void rb_curl_multi_remove_request_reference(VALUE self, VALUE easy);
+void rb_curl_multi_remove_request_reference(VALUE self, VALUE easy);
 static VALUE ruby_curl_multi_mark_closed(VALUE self);
 static VALUE ruby_curl_multi_alloc(VALUE klass);
 static VALUE ruby_curl_multi_initialize(VALUE self);
@@ -494,7 +494,29 @@ static int rb_curl_multi_has_easy(ruby_curl_multi *rbcm, ruby_curl_easy *rbce) {
   return st_lookup(rbcm->attached, (st_data_t)rbce, &value);
 }
 
-static void rb_curl_multi_remove_request_reference(VALUE self, VALUE easy) {
+/* Attachment, rather than easy.multi alone, distinguishes a live transfer
+ * from a completed easy whose status callback still sees its former multi. */
+int rb_curl_multi_easy_performing(void *rbce_ptr) {
+  ruby_curl_easy *rbce = (ruby_curl_easy *)rbce_ptr;
+  ruby_curl_multi *rbcm = ruby_curl_multi_pointer_if_compatible(rbce->multi);
+  return rbcm && rbcm->perform_active && rb_curl_multi_has_easy(rbcm, rbce);
+}
+
+static void ruby_curl_multi_check_thread(ruby_curl_multi *rbcm) {
+  if (rbcm->perform_active && rbcm->perform_thread != rb_thread_current()) {
+    rb_raise(rb_eRuntimeError, "Cannot access a Curl::Multi handle performing on another thread");
+  }
+}
+
+void rb_curl_multi_check_easy_thread(void *rbce_ptr) {
+  ruby_curl_easy *rbce = (ruby_curl_easy *)rbce_ptr;
+  ruby_curl_multi *rbcm = ruby_curl_multi_pointer_if_compatible(rbce->multi);
+  if (rbcm && rb_curl_multi_has_easy(rbcm, rbce)) {
+    ruby_curl_multi_check_thread(rbcm);
+  }
+}
+
+void rb_curl_multi_remove_request_reference(VALUE self, VALUE easy) {
   VALUE requests;
   VALUE object_id;
   VALUE safety_signatures;
@@ -569,6 +591,7 @@ static void ruby_curl_multi_init(ruby_curl_multi *rbcm) {
   rbcm->running = 0;
   rbcm->closed = 0;
   rbcm->perform_active = 0;
+  rbcm->perform_thread = Qnil;
   rbcm->callback_active = 0;
   rbcm->allow_close_during_perform = 0;
 
@@ -586,6 +609,7 @@ static void ruby_curl_multi_init(ruby_curl_multi *rbcm) {
 }
 
 static void ruby_curl_multi_ensure_handle(ruby_curl_multi *rbcm) {
+  ruby_curl_multi_check_thread(rbcm);
   if (!rbcm->handle) {
     if (rbcm->closed) {
       raise_curl_multi_error_exception(CURLM_BAD_HANDLE);
@@ -615,6 +639,10 @@ static VALUE ruby_curl_multi_initialize(VALUE self) {
 
   TypedData_Get_Struct(self, ruby_curl_multi, &ruby_curl_multi_data_type, rbcm);
 
+  if (rbcm->perform_active) {
+    rb_raise(rb_eRuntimeError, "Cannot initialize an active Curl::Multi handle during perform");
+  }
+
   ruby_curl_multi_init(rbcm);
 
   /*
@@ -781,7 +809,7 @@ VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
   ruby_curl_multi *existing_rbcm;
 
   TypedData_Get_Struct(self, ruby_curl_multi, &ruby_curl_multi_data_type, rbcm);
-  TypedData_Get_Struct(easy, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(easy);
   ruby_curl_multi_ensure_handle(rbcm);
 
   if (rb_curl_multi_has_easy(rbcm, rbce)) {
@@ -846,6 +874,7 @@ VALUE ruby_curl_multi_remove(VALUE self, VALUE rb_easy_handle) {
 
   TypedData_Get_Struct(self, ruby_curl_multi, &ruby_curl_multi_data_type, rbcm);
 
+  ruby_curl_multi_check_thread(rbcm);
   rb_curl_multi_remove(rbcm, rb_easy_handle);
 
   return self;
@@ -855,7 +884,7 @@ static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy) {
   CURLMcode result;
   ruby_curl_easy *rbce;
 
-  TypedData_Get_Struct(easy, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  rbce = ruby_curl_easy_get_handle(easy);
   result = curl_multi_remove_handle(rbcm->handle, rbce->curl);
   if (result != 0) {
     raise_curl_multi_error_exception(result);
@@ -1022,7 +1051,8 @@ static VALUE rb_curl_multi_run_completion_callbacks(VALUE argp) {
   VALUE easy_callback_error = Qnil;
   VALUE callargs;
   VALUE did_raise = rb_hash_new();
-  long redirect_count;
+  long redirect_count = 0;
+  CURLcode info_result;
 
   args->rbcm->callback_active = 1;
 
@@ -1040,12 +1070,18 @@ static VALUE rb_curl_multi_run_completion_callbacks(VALUE argp) {
   }
 
 #ifdef HAVE_CURLINFO_RESPONSE_CODE
-  curl_easy_getinfo(args->rbce->curl, CURLINFO_RESPONSE_CODE, &response_code);
+  info_result = curl_easy_getinfo(args->rbce->curl, CURLINFO_RESPONSE_CODE, &response_code);
 #else /* use fdsets path for waiting */
   // old libcurl
-  curl_easy_getinfo(args->rbce->curl, CURLINFO_HTTP_CODE, &response_code);
+  info_result = curl_easy_getinfo(args->rbce->curl, CURLINFO_HTTP_CODE, &response_code);
 #endif
-  curl_easy_getinfo(args->rbce->curl, CURLINFO_REDIRECT_COUNT, &redirect_count);
+  if (info_result != CURLE_OK) {
+    raise_curl_easy_error_exception(info_result);
+  }
+  info_result = curl_easy_getinfo(args->rbce->curl, CURLINFO_REDIRECT_COUNT, &redirect_count);
+  if (info_result != CURLE_OK) {
+    raise_curl_easy_error_exception(info_result);
+  }
 
   if (args->result != 0) {
     if (!rb_easy_nil("failure_proc")) {
@@ -2507,6 +2543,7 @@ static VALUE ruby_curl_multi_perform_guard_ensure(VALUE self) {
   ruby_curl_multi *rbcm;
   TypedData_Get_Struct(self, ruby_curl_multi, &ruby_curl_multi_data_type, rbcm);
   rbcm->perform_active = 0;
+  rbcm->perform_thread = Qnil;
   rbcm->callback_active = 0;
   rbcm->allow_close_during_perform = 0;
   return Qnil;
@@ -2521,7 +2558,11 @@ static VALUE ruby_curl_multi_with_perform_guard(int argc, VALUE *argv, VALUE sel
     rb_raise(rb_eRuntimeError, "Cannot recursively perform an active Curl::Multi handle");
   }
 
+  /* Reopening an autoclosed multi initializes its guard fields. Do this before
+   * claiming ownership so repeated performs retain the full-lifetime guard. */
+  ruby_curl_multi_ensure_handle(rbcm);
   rbcm->perform_active = 1;
+  rbcm->perform_thread = rb_thread_current();
   args.argc = argc;
   args.argv = argv;
   args.self = self;
@@ -2578,6 +2619,7 @@ VALUE ruby_curl_multi_close(VALUE self) {
   ruby_curl_multi *rbcm;
   TypedData_Get_Struct(self, ruby_curl_multi, &ruby_curl_multi_data_type, rbcm);
 
+  ruby_curl_multi_check_thread(rbcm);
   if ((rbcm->perform_active || rbcm->callback_active) && !rbcm->allow_close_during_perform) {
     rb_raise(rb_eRuntimeError, "Cannot close an active Curl::Multi handle during perform");
   }
@@ -2615,6 +2657,7 @@ static int mark_attached_i(st_data_t key, st_data_t val, st_data_t arg) {
 static void curl_multi_mark(void *ptr) {
   ruby_curl_multi *rbcm = (ruby_curl_multi *)ptr;
   if (!rbcm) return;
+  rb_gc_mark(rbcm->perform_thread);
   if (rbcm->attached) {
     st_foreach(rbcm->attached, mark_attached_i, (st_data_t)0);
   }

data/ext/curb_multi.h

@@ -17,6 +17,7 @@ typedef struct {
   int running;
   char closed;
   char perform_active;
+  VALUE perform_thread; /* Owner while a drive loop may release the GVL. */
   char callback_active;
   char allow_close_during_perform;
   CURLM *handle;
@@ -31,6 +32,9 @@ extern VALUE cCurlMulti;
 extern const rb_data_type_t ruby_curl_multi_data_type;
 
 void init_curb_multi();
+int rb_curl_multi_easy_performing(void *rbce_ptr);
+void rb_curl_multi_check_easy_thread(void *rbce_ptr);
+void rb_curl_multi_remove_request_reference(VALUE self, VALUE easy);
 void rb_curl_multi_forget_easy(ruby_curl_multi *rbcm, void *rbce_ptr);
 CURLMcode rb_curl_multi_detach_easy(ruby_curl_multi *rbcm, void *rbce_ptr);
 

data/ext/curb_postfield.c

@@ -20,128 +20,117 @@ VALUE cCurlPostField;
 
 /* ================= APPEND FORM FUNC ================ */
 
-/* This gets called by the post method on Curl::Easy for each postfield
- * supplied in the arguments. It's job is to add the supplied field to
- * the list that's being built for a perform.
- * 
- * THIS FUNC MODIFIES ITS ARGUMENTS. See curl_formadd(3) for details.
- */
-void append_to_form(VALUE self, 
-                    struct curl_httppost **first, 
-                    struct curl_httppost **last) {                               
+/* Snapshot before invoking further Ruby coercions. Native storage is private
+ * to this request and cannot move under GC or require VM-global GC roots. */
+static ruby_curl_form_string *form_string_snapshot(VALUE value, ruby_curl_form_string **strings) {
+  ruby_curl_form_string *entry;
+  long length;
+  StringValue(value);
+  length = RSTRING_LEN(value);
+  /* One allocation for the list entry, payload and terminating NUL. */
+  entry = ruby_xmalloc(sizeof(*entry) + (size_t)length + 1);
+  entry->data = (char *)(entry + 1);
+  entry->length = length;
+  memcpy(entry->data, RSTRING_PTR(value), (size_t)length);
+  entry->data[length] = '\0';
+  entry->next = *strings;
+  *strings = entry;
+  RB_GC_GUARD(value);
+  return entry;
+}
+
+static void free_form_strings_until(ruby_curl_form_string **strings,
+                                    ruby_curl_form_string *stop) {
+  while (*strings != stop) {
+    ruby_curl_form_string *next = (*strings)->next;
+    xfree(*strings);
+    *strings = next;
+  }
+}
+
+void free_form_strings(ruby_curl_form_string *strings) {
+  free_form_strings_until(&strings, NULL);
+}
+
+void append_to_form(VALUE self,
+                    struct curl_httppost **first,
+                    struct curl_httppost **last,
+                    ruby_curl_form_string **strings) {
   ruby_curl_postfield *rbcpf;
   CURLFORMcode result = -1;
-  
+  ruby_curl_form_string *name, *content = NULL, *remote = NULL, *local = NULL, *type = NULL;
+  ruby_curl_form_string *previous_strings = *strings;
+  int is_file;
+  struct curl_forms form[8];
+  int n = 0;
+
   TypedData_Get_Struct(self, ruby_curl_postfield, &ruby_curl_postfield_data_type, rbcpf);
-  
-  if (rbcpf->name == Qnil) {
+  if (NIL_P(rbcpf->name)) {
     rb_raise(eCurlErrInvalidPostField, "Cannot post unnamed field");
-  } else {
-    if ((rbcpf->local_file != Qnil) || (rbcpf->remote_file != Qnil)) {
-      // is a file upload field
-      if (rbcpf->content_proc != Qnil) {
-        // with content proc
-        rbcpf->buffer_str = rb_funcall(rbcpf->content_proc, idCall, 1, self);
-        
-        if (rbcpf->remote_file == Qnil) {
-          rb_raise(eCurlErrInvalidPostField, "Cannot post file upload field with no filename");
-        } else {
-          if (rbcpf->content_type == Qnil) {
-            result = curl_formadd(first, last, CURLFORM_PTRNAME, StringValuePtr(rbcpf->name), 
-                                               CURLFORM_BUFFER, StringValuePtr(rbcpf->remote_file),
-                                               CURLFORM_BUFFERPTR, StringValuePtr(rbcpf->buffer_str),
-                                               CURLFORM_BUFFERLENGTH, RSTRING_LEN(rbcpf->buffer_str),
-                                               CURLFORM_END);
-          } else {
-            result = curl_formadd(first, last, CURLFORM_PTRNAME, StringValuePtr(rbcpf->name), 
-                                               CURLFORM_BUFFER, StringValuePtr(rbcpf->remote_file),
-                                               CURLFORM_BUFFERPTR, StringValuePtr(rbcpf->buffer_str),
-                                               CURLFORM_BUFFERLENGTH, RSTRING_LEN(rbcpf->buffer_str),
-                                               CURLFORM_CONTENTTYPE, StringValuePtr(rbcpf->content_type),
-                                               CURLFORM_END);
-          }
-        }
-      } else if (rbcpf->content != Qnil) {
-        // with content
-        if (rbcpf->remote_file == Qnil) {
-          rb_raise(eCurlErrInvalidPostField, "Cannot post file upload field with no filename");
-        } else {
-          if (rbcpf->content_type == Qnil) {
-            result = curl_formadd(first, last, CURLFORM_PTRNAME, StringValuePtr(rbcpf->name), 
-                                               CURLFORM_BUFFER, StringValuePtr(rbcpf->remote_file),
-                                               CURLFORM_BUFFERPTR, StringValuePtr(rbcpf->content),
-                                               CURLFORM_BUFFERLENGTH, RSTRING_LEN(rbcpf->content),
-                                               CURLFORM_END);
-          } else {
-            result = curl_formadd(first, last, CURLFORM_PTRNAME, StringValuePtr(rbcpf->name), 
-                                               CURLFORM_BUFFER, StringValuePtr(rbcpf->remote_file),
-                                               CURLFORM_BUFFERPTR, StringValuePtr(rbcpf->content),
-                                               CURLFORM_BUFFERLENGTH, RSTRING_LEN(rbcpf->content),
-                                               CURLFORM_CONTENTTYPE, StringValuePtr(rbcpf->content_type),
-                                               CURLFORM_END);
-          }
-        }
-      } else if (rbcpf->local_file != Qnil) {
-        // with local filename
-        if (rbcpf->local_file == Qnil) {
-          rb_raise(eCurlErrInvalidPostField, "Cannot post file upload field no filename");
-        } else {
-          if (rbcpf->remote_file == Qnil) {
-            rbcpf->remote_file = rbcpf->local_file;
-          }
-          
-          if (rbcpf->content_type == Qnil) {
-            result = curl_formadd(first, last, CURLFORM_PTRNAME, StringValuePtr(rbcpf->name), 
-                                               CURLFORM_FILE, StringValuePtr(rbcpf->local_file),
-                                               CURLFORM_FILENAME, StringValuePtr(rbcpf->remote_file),
-                                               CURLFORM_END);
-          } else {
-            result = curl_formadd(first, last, CURLFORM_PTRNAME, StringValuePtr(rbcpf->name), 
-                                               CURLFORM_FILE, StringValuePtr(rbcpf->local_file),
-                                               CURLFORM_FILENAME, StringValuePtr(rbcpf->remote_file),
-                                               CURLFORM_CONTENTTYPE, StringValuePtr(rbcpf->content_type),
-                                               CURLFORM_END);
-          }            
-        }
-      } else {
-        rb_raise(eCurlErrInvalidPostField, "Cannot post file upload field with no data");
+  }
+  is_file = !NIL_P(rbcpf->local_file) || !NIL_P(rbcpf->remote_file);
+  if (!NIL_P(rbcpf->content_proc)) {
+    rbcpf->buffer_str = rb_funcall(rbcpf->content_proc, idCall, 1, self);
+    StringValue(rbcpf->buffer_str);
+    content = form_string_snapshot(rbcpf->buffer_str, strings);
+  } else if (!NIL_P(rbcpf->content)) {
+    StringValue(rbcpf->content);
+    content = form_string_snapshot(rbcpf->content, strings);
+  }
+
+  name = form_string_snapshot(rbcpf->name, strings);
+  if (is_file) {
+    if (content != NULL) {
+      if (NIL_P(rbcpf->remote_file)) {
+        rb_raise(eCurlErrInvalidPostField, "Cannot post file upload field with no filename");
       }
+    } else if (!NIL_P(rbcpf->local_file)) {
+      local = form_string_snapshot(rbcpf->local_file, strings);
+      if (NIL_P(rbcpf->remote_file)) rbcpf->remote_file = rbcpf->local_file;
     } else {
-      // is a content field
-      if (rbcpf->content_proc != Qnil) {
-        rbcpf->buffer_str = rb_funcall(rbcpf->content_proc, idCall, 1, self);
-        
-        if (rbcpf->content_type == Qnil) {
-          result = curl_formadd(first, last, CURLFORM_PTRNAME, StringValuePtr(rbcpf->name), 
-                                             CURLFORM_PTRCONTENTS, StringValuePtr(rbcpf->buffer_str),
-                                             CURLFORM_CONTENTSLENGTH, RSTRING_LEN(rbcpf->buffer_str),
-                                             CURLFORM_END);
-        } else {
-          result = curl_formadd(first, last, CURLFORM_PTRNAME, StringValuePtr(rbcpf->name), 
-                                             CURLFORM_PTRCONTENTS, StringValuePtr(rbcpf->buffer_str),
-                                             CURLFORM_CONTENTSLENGTH, RSTRING_LEN(rbcpf->buffer_str),
-                                             CURLFORM_CONTENTTYPE, StringValuePtr(rbcpf->content_type),
-                                             CURLFORM_END);
-        }
-      } else if (rbcpf->content != Qnil) {
-        if (rbcpf->content_type == Qnil) {
-          result = curl_formadd(first, last, CURLFORM_PTRNAME, StringValuePtr(rbcpf->name), 
-                                             CURLFORM_PTRCONTENTS, StringValuePtr(rbcpf->content),
-                                             CURLFORM_CONTENTSLENGTH, RSTRING_LEN(rbcpf->content),
-                                             CURLFORM_END);
-        } else {
-          result = curl_formadd(first, last, CURLFORM_PTRNAME, StringValuePtr(rbcpf->name), 
-                                             CURLFORM_PTRCONTENTS, StringValuePtr(rbcpf->content),
-                                             CURLFORM_CONTENTSLENGTH, RSTRING_LEN(rbcpf->content),
-                                             CURLFORM_CONTENTTYPE, StringValuePtr(rbcpf->content_type),
-                                             CURLFORM_END);
-        }
-      } else {
-        rb_raise(eCurlErrInvalidPostField, "Cannot post content field with no data");
-      }
+      rb_raise(eCurlErrInvalidPostField, "Cannot post file upload field with no data");
     }
+    remote = form_string_snapshot(rbcpf->remote_file, strings);
+  } else if (content == NULL) {
+    rb_raise(eCurlErrInvalidPostField, "Cannot post content field with no data");
   }
-  
+  if (!NIL_P(rbcpf->content_type)) {
+    type = form_string_snapshot(rbcpf->content_type, strings);
+  }
+
+  /* libcurl copies metadata but borrows the private payload for the request.
+   * This avoids a second form-owned copy of ordinary field contents. */
+  form[n].option = CURLFORM_COPYNAME;
+  form[n++].value = name->data;
+  if (is_file) {
+    form[n].option = content == NULL ? CURLFORM_FILE : CURLFORM_BUFFER;
+    form[n++].value = (content == NULL ? local : remote)->data;
+    if (content == NULL) {
+      form[n].option = CURLFORM_FILENAME;
+      form[n++].value = remote->data;
+    }
+  }
+  if (type != NULL) {
+    form[n].option = CURLFORM_CONTENTTYPE;
+    form[n++].value = type->data;
+  }
+  form[n].option = CURLFORM_END;
+  form[n].value = NULL;
+
+  if (content == NULL) {
+    result = curl_formadd(first, last, CURLFORM_ARRAY, form, CURLFORM_END);
+  } else {
+    result = curl_formadd(first, last, CURLFORM_ARRAY, form,
+                         is_file ? CURLFORM_BUFFERPTR : CURLFORM_PTRCONTENTS,
+                         content->data,
+                         is_file ? CURLFORM_BUFFERLENGTH : CURLFORM_CONTENTSLENGTH,
+                         content->length, CURLFORM_END);
+  }
+
+  /* Metadata was copied by curl_formadd. Retain only the payload, if any,
+   * which was the first snapshot allocated for this field. */
+  free_form_strings_until(strings, content ? content : previous_strings);
+
   if (result != 0) {
     const char *reason = NULL;
     

data/ext/curb_postfield.h

@@ -32,9 +32,18 @@ typedef struct {
 extern VALUE cCurlPostField;
 extern const rb_data_type_t ruby_curl_postfield_data_type;
 
+typedef struct ruby_curl_form_string {
+  struct ruby_curl_form_string *next;
+  long length;
+  char *data;
+} ruby_curl_form_string;
+
+void free_form_strings(ruby_curl_form_string *strings);
+
 void append_to_form(VALUE self, 
                     struct curl_httppost **first, 
-                    struct curl_httppost **last);
+                    struct curl_httppost **last,
+                    ruby_curl_form_string **strings);
 
 void init_curb_postfield();
 

data/lib/curl/easy.rb

@@ -184,10 +184,16 @@ module Curl
       set_protocol_allowlist('CURLOPT_REDIR_PROTOCOLS_STR', 'CURLOPT_REDIR_PROTOCOLS', protocols)
     end
 
-    def safe_http!
+    def safe_http!(options = {})
+      options = Curl.__send__(:safe_http_options, options)
+      config = Curl.__send__(:ractor_local_state)[:safety_config] || Curl::SafetyConfig.new
+      limit = Curl::SafetyConfig.new
+      limit.max_body_bytes = options.fetch(:max_body_bytes, config.max_body_bytes)
       __curb_set_safety_override!(
         :protocols => [:http, :https],
-        :redirect_protocols => [:http, :https]
+        :redirect_protocols => [:http, :https],
+        :network_policy => :public,
+        :max_body_bytes => limit.max_body_bytes
       )
     end
 
@@ -197,7 +203,8 @@ module Curl
       @__curb_safety_override = (defined?(@__curb_safety_override) && @__curb_safety_override) ? @__curb_safety_override.dup : {}
       @__curb_safety_override[:protocols] = Array(options[:protocols]).map { |protocol| protocol.to_s.downcase.to_sym } if options.key?(:protocols)
       @__curb_safety_override[:redirect_protocols] = Array(options[:redirect_protocols]).map { |protocol| protocol.to_s.downcase.to_sym } if options.key?(:redirect_protocols)
-      @__curb_safety_override[:max_body_bytes] = options[:max_body_bytes] if options.key?(:max_body_bytes) && options[:max_body_bytes]
+      @__curb_safety_override[:max_body_bytes] = options[:max_body_bytes] if options.key?(:max_body_bytes)
+      @__curb_safety_override[:network_policy] = options[:network_policy] if options.key?(:network_policy)
       @__curb_safety_override_generation = __curb_safety_override_generation + 1
       Curl.__send__(:apply_safety!, self) if Curl.respond_to?(:apply_safety!, true)
       self

data/lib/curl/multi.rb

@@ -454,9 +454,9 @@ module Curl
 
     def remove(easy)
       return self if !requests[easy.object_id]
+      _remove(easy)
       requests.delete(easy.object_id)
       __curb_native_safety_signatures.delete(easy.object_id)
-      _remove(easy)
       self
     end
 

data/lib/curl.rb

@@ -23,6 +23,7 @@ module Curl
 
   class SafetyConfig
     DEFAULT_PROTOCOLS = [:http, :https].freeze
+    DEFAULT_MAX_BODY_BYTES = 10 * 1024 * 1024
 
     attr_reader :max_body_bytes, :network_policy
     attr_accessor :allow_proxies, :allow_resolve, :allow_connect_to, :allow_doh, :allow_unix_socket
@@ -30,8 +31,8 @@ module Curl
     def initialize
       @protocols = DEFAULT_PROTOCOLS
       @redirect_protocols = nil
-      @max_body_bytes = nil
-      @network_policy = nil
+      @max_body_bytes = DEFAULT_MAX_BODY_BYTES
+      @network_policy = :public
       @allowed_hosts = nil
       @allowed_proxy_hosts = nil
       @allowed_cidrs = nil
@@ -217,9 +218,11 @@ module Curl
     apply_allowed_hosts!(easy, config.allowed_hosts) if config&.allowed_hosts
     apply_allowed_cidrs!(easy, config) if config&.allowed_cidrs
 
-    if config&.network_policy
-      easy.network_policy = config.network_policy
-      apply_public_network_policy_controls!(easy, config) if config.network_policy == :public
+    network_policy = config&.network_policy
+    network_policy = :public if override && override[:network_policy] == :public
+    if network_policy
+      easy.network_policy = network_policy
+      apply_public_network_policy_controls!(easy, config || SafetyConfig.new) if network_policy == :public
     end
 
     apply_max_body_bytes!(easy, config.max_body_bytes) if config&.max_body_bytes
@@ -653,8 +656,7 @@ module Curl
 
     http(verb, url, post_body, put_data) do |handle|
       yield handle if block
-      handle.safe_http!
-      handle.max_body_bytes = options[:max_body_bytes] if options.key?(:max_body_bytes)
+      handle.safe_http!(options)
     end
   end