curb 1.4.0 → 1.5.0

data/ext/curb_easy.h

@@ -65,6 +65,8 @@ typedef struct {
   long http_auth_types;
   long proxy_auth_types;
   long max_redirs;
+  char max_redirs_set; /* user configured max_redirs (nil = libcurl-style default) */
+  char protocols_set; /* CURLOPT_PROTOCOLS(_STR) allowlist configured */
   unsigned long timeout;
   unsigned long timeout_ms;
   unsigned long connect_timeout;
@@ -93,6 +95,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;
@@ -111,6 +115,9 @@ typedef struct {
   struct curl_slist *curl_connect_to;
   curb_cidr_rule *network_allowed_cidr_rules;
   char **network_allowed_hosts;
+  /* CURLOPT_STDERR target. curb owns this FILE* (on a duplicated descriptor)
+   * so closing or collecting the caller's IO cannot free it under libcurl. */
+  FILE *stderr_file;
 
   /* attachment_sequence of the multi at the time this easy was last added. */
   unsigned long multi_attachment_generation;
@@ -124,6 +131,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);
@@ -879,20 +908,29 @@ static VALUE call_status_handler2(VALUE ary) {
   return rb_funcall(rb_ary_entry(ary, 0), idCall, 2, rb_ary_entry(ary, 1), rb_ary_entry(ary, 2));
 }
 
+/* The default body/header buffers grow geometrically, leaving up to half
+ * their capacity unused. Once the transfer is complete, give that back so a
+ * retained body_str/header_str is exact-fit. rb_str_resize only reallocates
+ * when the excess is significant. */
+static void trim_default_buffers(ruby_curl_easy *rbce) {
+  VALUE body = rb_easy_get("body_data");
+  VALUE header = rb_easy_get("header_data");
+  if (RB_TYPE_P(body, T_STRING) && !OBJ_FROZEN(body)) {
+    rb_str_resize(body, RSTRING_LEN(body));
+  }
+  if (RB_TYPE_P(header, T_STRING) && !OBJ_FROZEN(header)) {
+    rb_str_resize(header, RSTRING_LEN(header));
+  }
+}
+
 static void flush_stderr_if_any(ruby_curl_easy *rbce) {
   VALUE stderr_io = rb_easy_get("stderr_io");
-  if (stderr_io != Qnil) {
-    /* Flush via Ruby IO API */
+  /* The caller may have closed their IO; curb's own stream stays valid. */
+  if (stderr_io != Qnil && !RTEST(rb_funcall(stderr_io, rb_intern("closed?"), 0))) {
     rb_funcall(stderr_io, rb_intern("flush"), 0);
-#ifdef HAVE_RUBY_IO_H
-    /* Additionally flush underlying FILE* to be extra safe. */
-    rb_io_t *open_f_ptr;
-    if (RB_TYPE_P(stderr_io, T_FILE)) {
-      GetOpenFile(stderr_io, open_f_ptr);
-      FILE *fp = rb_io_stdio_file(open_f_ptr);
-      if (fp) fflush(fp);
-    }
-#endif
+  }
+  if (rbce->stderr_file) {
+    fflush(rbce->stderr_file);
   }
 }
 
@@ -1022,7 +1060,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 +1079,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")) {
@@ -1167,6 +1212,7 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
 
   /* Flush again after removal to cover any last buffered data. */
   flush_stderr_if_any(rbce);
+  trim_default_buffers(rbce);
 
   struct multi_complete_callback_args args = {
     self,
@@ -1752,6 +1798,9 @@ static int collect_io_select_ready_i(st_data_t key, st_data_t val, st_data_t arg
 
 static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_socket_ctx *ctx, VALUE block) {
   CURLMcode mrc;
+  /* Looking up the Ractor-local default costs two method calls; read it once
+   * per drive rather than on every wait. */
+  const long default_timeout_ms = curb_multi_default_timeout();
 
   do {
     /* Prime the state: let libcurl act on timeouts to set up sockets. */
@@ -1763,7 +1812,7 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
 
     while (rbcm->running) {
     struct timeval tv = {0, 0};
-    long wait_ms = curb_multi_default_timeout();
+    long wait_ms = default_timeout_ms;
 
     if (multi_socket_timer_due(ctx)) {
       ctx->timeout_deadline_ms = -1;
@@ -2253,6 +2302,7 @@ static VALUE ruby_curl_multi_perform_impl(int argc, VALUE *argv, VALUE self) {
   CURLMcode mcode;
   ruby_curl_multi *rbcm;
   long timeout_milliseconds;
+  long default_timeout_ms;
   VALUE block = Qnil;
 #ifndef CURB_USE_MULTI_POLL
   int maxfd, rc = -1;
@@ -2275,7 +2325,10 @@ static VALUE ruby_curl_multi_perform_impl(int argc, VALUE *argv, VALUE self) {
     clear_multi_deferred_exception_source_id_if_any(self);
   }
 
-  timeout_milliseconds = curb_multi_default_timeout();
+  /* Looking up the Ractor-local default costs two method calls; read it once
+   * per perform rather than up to twice per wait-loop iteration. */
+  default_timeout_ms = curb_multi_default_timeout();
+  timeout_milliseconds = default_timeout_ms;
 
   // Run curl_multi_perform for the first time to get the ball rolling
   rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
@@ -2315,8 +2368,8 @@ static VALUE ruby_curl_multi_perform_impl(int argc, VALUE *argv, VALUE self) {
         continue;
       }
 
-      if (timeout_milliseconds < 0 || timeout_milliseconds > curb_multi_default_timeout()) {
-        timeout_milliseconds = curb_multi_default_timeout(); /* libcurl doesn't know how long to wait, use a default timeout */
+      if (timeout_milliseconds < 0 || timeout_milliseconds > default_timeout_ms) {
+        timeout_milliseconds = default_timeout_ms; /* libcurl doesn't know how long to wait, use a default timeout */
                                                         /* or buggy versions libcurl sometimes reports huge timeouts... let's cap it */
       }
 
@@ -2507,6 +2560,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 +2575,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 +2636,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 +2674,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();