curb 1.0.6 → 1.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 18ca81b9cb8fd33720ab17ba3eff9e9ae4fa1a10542feb60897ac94d7cd801ac
-  data.tar.gz: e8747cc63a63ca1561288dd9480b6c30c9dda0a371a6909eb1e2ad2a9a8b6947
+  metadata.gz: 26faca47e47561b5ab762a32f58e2771db9a39c2482152fa1116a7082a27de91
+  data.tar.gz: a138509513b023f12537a1bff7fa11e6ef563cc5c59af860b73f119705ee1023
 SHA512:
-  metadata.gz: 112d4c34fd70b3b77a58e133b9c873d5ac7f850d2644fe02a9713771b47be636cfbc2c66b44bbf59e047cc84d83aa496c2e67cbfd8f2987509577589a87d20f0
-  data.tar.gz: a593f46d71b17af90cb9244ee7a92c133eca76024146d9097806f91ec70f34b4611988141063a7624fd51ea103d872495e1efa94b2b6d718ee0a700ca86ef325
+  metadata.gz: 4686d9ad528ba0f1931c95fa95d25266c8ffcc2214c3a5f527e437f30977f94bde4a48b38d27ad6342cc868c620e2fd4bd214baeae435725a1746d0c93a22aef
+  data.tar.gz: 2e4ba49a5906448e0ad381dad6017cf01140166ee78f1b025b9245cc79c6ff20b37ffd18abc61a56289e8bdeee0750a68f3d84369da36d360f7a61775da10566

data/ext/curb.h

@@ -28,11 +28,11 @@
 #include "curb_macros.h"
 
 // These should be managed from the Rake 'release' task.
-#define CURB_VERSION   "1.0.6"
-#define CURB_VER_NUM   1006
+#define CURB_VERSION   "1.0.8"
+#define CURB_VER_NUM   1008
 #define CURB_VER_MAJ   1
 #define CURB_VER_MIN   0
-#define CURB_VER_MIC   6
+#define CURB_VER_MIC   8
 #define CURB_VER_PATCH 0
 
 

data/ext/curb_easy.c

@@ -31,6 +31,7 @@ static FILE * rb_io_stdio_file(rb_io_t *fptr) {
   return fptr->f;
 }
 #endif
+static struct curl_slist *duplicate_curl_slist(struct curl_slist *list);
 
 /* ================== CURL HANDLER FUNCS ==============*/
 
@@ -264,7 +265,7 @@ void curl_easy_free(ruby_curl_easy *rbce) {
 static void ruby_curl_easy_zero(ruby_curl_easy *rbce) {
   rbce->opts = rb_hash_new();
 
-  memset(rbce->err_buf, 0, sizeof(rbce->err_buf));
+  memset(rbce->err_buf, 0, CURL_ERROR_SIZE);
 
   rbce->curl_headers = NULL;
   rbce->curl_proxy_headers = NULL;
@@ -370,6 +371,16 @@ static VALUE ruby_curl_easy_initialize(int argc, VALUE *argv, VALUE self) {
   return self;
 }
 
+/* Helper to duplicate a curl_slist */
+static struct curl_slist *duplicate_curl_slist(struct curl_slist *list) {
+    struct curl_slist *dup = NULL;
+    struct curl_slist *tmp;
+    for (tmp = list; tmp; tmp = tmp->next) {
+        dup = curl_slist_append(dup, tmp->data);
+    }
+    return dup;
+}
+
 /*
  * call-seq:
  *   easy.clone                                       => <easy clone>
@@ -384,14 +395,22 @@ static VALUE ruby_curl_easy_clone(VALUE self) {
   Data_Get_Struct(self, ruby_curl_easy, rbce);
 
   newrbce = ALLOC(ruby_curl_easy);
+  /* shallow copy */
   memcpy(newrbce, rbce, sizeof(ruby_curl_easy));
+
+  /* now deep copy */
   newrbce->curl = curl_easy_duphandle(rbce->curl);
-  newrbce->curl_headers = NULL;
-  newrbce->curl_proxy_headers = NULL;
-  newrbce->curl_ftp_commands = NULL;
-  newrbce->curl_resolve = NULL;
+  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;
+  newrbce->curl_resolve = (rbce->curl_resolve) ? duplicate_curl_slist(rbce->curl_resolve) : NULL;
 
-  curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, &rbce->err_buf);
+  if (rbce->opts != Qnil) {
+    newrbce->opts = rb_funcall(rbce->opts, rb_intern("dup"), 0);
+  }
+
+  /* Set the error buffer on the new curl handle using the new err_buf */
+  curl_easy_setopt(newrbce->curl, CURLOPT_ERRORBUFFER, newrbce->err_buf);
 
   return Data_Wrap_Struct(cCurlEasy, curl_easy_mark, curl_easy_free, newrbce);
 }
@@ -2614,7 +2633,7 @@ static VALUE ruby_curl_easy_perform_verb_str(VALUE self, const char *verb) {
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl = rbce->curl;
 
-  memset(rbce->err_buf, 0, sizeof(rbce->err_buf));
+  memset(rbce->err_buf, 0, CURL_ERROR_SIZE);
 
   curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, verb);
 
@@ -2681,7 +2700,7 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl = rbce->curl;
 
-  memset(rbce->err_buf, 0, sizeof(rbce->err_buf));
+  memset(rbce->err_buf, 0, CURL_ERROR_SIZE);
 
   curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, NULL);
 
@@ -2739,6 +2758,88 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
   }
 }
 
+/*
+ * call-seq:
+ *   easy.http_patch("url=encoded%20form%20data;and=so%20on") => true
+ *   easy.http_patch("url=encoded%20form%20data", "and=so%20on", ...) => true
+ *   easy.http_patch("url=encoded%20form%20data", Curl::PostField, "and=so%20on", ...) => true
+ *   easy.http_patch(Curl::PostField, Curl::PostField ..., Curl::PostField) => true
+ *
+ * PATCH the specified formdata to the currently configured URL using
+ * the current options set for this Curl::Easy instance. This method
+ * always returns true, or raises an exception (defined under
+ * Curl::Err) on error.
+ *
+ * When multipart_form_post is true the multipart logic is used; otherwise,
+ * the arguments are joined into a raw PATCH body.
+ */
+static VALUE ruby_curl_easy_perform_patch(int argc, VALUE *argv, VALUE self) {
+  ruby_curl_easy *rbce;
+  CURL *curl;
+  int i;
+  VALUE args_ary;
+
+  rb_scan_args(argc, argv, "*", &args_ary);
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  curl = rbce->curl;
+
+  /* Clear the error buffer */
+  memset(rbce->err_buf, 0, CURL_ERROR_SIZE);
+
+  /* Set the custom HTTP method to PATCH */
+  curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PATCH");
+
+  if (rbce->multipart_form_post) {
+    VALUE ret;
+    struct curl_httppost *first = NULL, *last = NULL;
+
+    /* Build the multipart form (same logic as for POST) */
+    for (i = 0; i < argc; i++) {
+      if (rb_obj_is_instance_of(argv[i], cCurlPostField)) {
+        append_to_form(argv[i], &first, &last);
+      } else if (rb_type(argv[i]) == T_ARRAY) {
+        long j, argv_len = RARRAY_LEN(argv[i]);
+        for (j = 0; j < argv_len; ++j) {
+          if (rb_obj_is_instance_of(rb_ary_entry(argv[i], j), cCurlPostField)) {
+            append_to_form(rb_ary_entry(argv[i], j), &first, &last);
+          } else {
+            rb_raise(eCurlErrInvalidPostField,
+                     "You must use PostFields only with multipart form posts");
+            return Qnil;
+          }
+        }
+      } else {
+        rb_raise(eCurlErrInvalidPostField,
+                 "You must use PostFields only with multipart form posts");
+        return Qnil;
+      }
+    }
+    /* Disable the POST flag */
+    curl_easy_setopt(curl, CURLOPT_POST, 0);
+    /* Use the built multipart form as the request body */
+    curl_easy_setopt(curl, CURLOPT_HTTPPOST, first);
+    ret = rb_funcall(self, rb_intern("perform"), 0);
+    curl_formfree(first);
+    return ret;
+  } else {
+    /* Join arguments into a raw PATCH body */
+    VALUE patch_body = rb_funcall(args_ary, idJoin, 1, rbstrAmp);
+    if (patch_body == Qnil) {
+      rb_raise(eCurlErrError, "Failed to join arguments");
+      return Qnil;
+    } else {
+      if (rb_type(patch_body) == T_STRING && RSTRING_LEN(patch_body) > 0) {
+        ruby_curl_easy_post_body_set(self, patch_body);
+      }
+      /* If postdata_buffer is still nil, set it so that the PATCH header is enabled */
+      if (rb_easy_nil("postdata_buffer")) {
+        ruby_curl_easy_post_body_set(self, patch_body);
+      }
+      return rb_funcall(self, rb_intern("perform"), 0);
+    }
+  }
+}
+
 /*
  * call-seq:
  *   easy.http_put(data)                              => true
@@ -2747,18 +2848,70 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
  * current options set for this Curl::Easy instance. This method always
  * returns true, or raises an exception (defined under Curl::Err) on error.
  */
-static VALUE ruby_curl_easy_perform_put(VALUE self, VALUE data) {
+static VALUE ruby_curl_easy_perform_put(int argc, VALUE *argv, VALUE self) {
   ruby_curl_easy *rbce;
   CURL *curl;
+  VALUE args_ary;
+  int i;
 
+  rb_scan_args(argc, argv, "*", &args_ary);
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl = rbce->curl;
 
-  memset(rbce->err_buf, 0, sizeof(rbce->err_buf));
-
-  curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, NULL);
-  ruby_curl_easy_put_data_set(self, data);
+  memset(rbce->err_buf, 0, CURL_ERROR_SIZE);
+  curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
 
+  /* New: if no arguments were provided, treat as an empty PUT */
+  if (RARRAY_LEN(args_ary) == 0) {
+    /* Option 1: explicitly set an empty body */
+    ruby_curl_easy_put_data_set(self, rb_str_new2(""));
+  }
+  /* If a single argument is given and it is a String or responds to read, use legacy behavior */
+  else if (RARRAY_LEN(args_ary) == 1 &&
+           (rb_type(rb_ary_entry(args_ary, 0)) == T_STRING ||
+            rb_respond_to(rb_ary_entry(args_ary, 0), rb_intern("read")))) {
+    ruby_curl_easy_put_data_set(self, rb_ary_entry(args_ary, 0));
+  }
+  /* Otherwise, if multipart_form_post is true, use multipart logic */
+  else if (rbce->multipart_form_post) {
+    VALUE ret;
+    struct curl_httppost *first = NULL, *last = NULL;
+    for (i = 0; i < RARRAY_LEN(args_ary); i++) {
+      VALUE field = rb_ary_entry(args_ary, i);
+      if (rb_obj_is_instance_of(field, cCurlPostField)) {
+        append_to_form(field, &first, &last);
+      } else if (rb_type(field) == T_ARRAY) {
+        long j;
+        for (j = 0; j < RARRAY_LEN(field); j++) {
+          VALUE subfield = rb_ary_entry(field, j);
+          if (rb_obj_is_instance_of(subfield, cCurlPostField)) {
+            append_to_form(subfield, &first, &last);
+          } else {
+            rb_raise(eCurlErrInvalidPostField,
+                     "You must use PostFields only with multipart form posts");
+          }
+        }
+      } else {
+        rb_raise(eCurlErrInvalidPostField,
+                 "You must use PostFields only with multipart form posts");
+      }
+    }
+    curl_easy_setopt(curl, CURLOPT_POST, 0);
+    curl_easy_setopt(curl, CURLOPT_HTTPPOST, first);
+    /* Set the method explicitly to PUT */
+    curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
+    ret = rb_funcall(self, rb_intern("perform"), 0);
+    curl_formfree(first);
+    return ret;
+  }
+  /* Fallback: join all arguments */
+  else {
+    VALUE post_body = rb_funcall(args_ary, idJoin, 1, rbstrAmp);
+    if (post_body != Qnil && rb_type(post_body) == T_STRING &&
+        RSTRING_LEN(post_body) > 0) {
+      ruby_curl_easy_put_data_set(self, post_body);
+    }
+  }
   return rb_funcall(self, rb_intern("perform"), 0);
 }
 
@@ -3364,14 +3517,16 @@ static VALUE ruby_curl_easy_num_connects_get(VALUE self) {
 
 /*
  * call-seq:
- *   easy.cookielist                                => array
+ *   easy.cookielist                                => cookielist
  *
  * Retrieves the cookies curl knows in an array of strings.
  * Returned strings are in Netscape cookiejar format or in Set-Cookie format.
+ * Since 7.43.0 cookies in the Set-Cookie format without a domain name are not exported.
  *
- * See also option CURLINFO_COOKIELIST of curl_easy_getopt(3) to see how libcurl behaves.
- *
- * (requires libcurl 7.14.1 or higher, otherwise -1 is always returned).
+ * @see https://curl.se/libcurl/c/CURLINFO_COOKIELIST.html option <code>CURLINFO_COOKIELIST</code> of 
+ *   <code>curl_easy_getopt(3)</code> to see how libcurl behaves.
+ * @note requires libcurl 7.14.1 or higher, otherwise +-1+ is always returned
+ * @return [Array<String>, nil, -1] array of strings, or +nil+ if there are no cookies, or +-1+ if the libcurl version is too old
 */
 static VALUE ruby_curl_easy_cookielist_get(VALUE self) {
 #ifdef HAVE_CURLINFO_COOKIELIST
@@ -3482,9 +3637,16 @@ static VALUE ruby_curl_easy_last_error(VALUE self) {
 
 /*
  * call-seq:
- *   easy.setopt Fixnum, value  => value
+ *   easy.setopt(opt, val)  => val
  *
  * Initial access to libcurl curl_easy_setopt
+ *
+ * @param [Fixnum] opt The option to set, see +Curl::CURLOPT_*+ constants
+ * @param [Object] val
+ * @return [Object] val
+ * @raise [TypeError] if the option is not supported
+ * @note Some options - like url or cookie - aren't set directly throught +curl_easy_setopt+, but stored in the Ruby object state.
+ * @note When +curl_easy_setopt+ is called, return value is not checked here.
  */
 static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
   ruby_curl_easy *rbce;
@@ -3650,6 +3812,11 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
     curl_easy_setopt(rbce->curl, CURLOPT_SSL_SESSIONID_CACHE, NUM2LONG(val));
     break;
 #endif
+#if HAVE_CURLOPT_COOKIELIST
+  case CURLOPT_COOKIELIST: {
+	curl_easy_setopt(rbce->curl, CURLOPT_COOKIELIST, StringValueCStr(val));
+    } break;
+#endif
 #if HAVE_CURLOPT_PROXY_SSL_VERIFYHOST
   case CURLOPT_PROXY_SSL_VERIFYHOST:
     curl_easy_setopt(rbce->curl, CURLOPT_PROXY_SSL_VERIFYHOST, NUM2LONG(val));
@@ -3664,9 +3831,13 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
 
 /*
  * call-seq:
- *   easy.getinfo Fixnum => value
+ *   easy.getinfo(opt) => nil
  *
  * Iniital access to libcurl curl_easy_getinfo, remember getinfo doesn't return the same values as setopt
+ *
+ * @note This method is not implemented yet.
+ * @param [Fixnum] code Constant +CURLINFO_*+ from libcurl
+ * @return [nil]
  */
 static VALUE ruby_curl_easy_get_opt(VALUE self, VALUE opt) {
   return Qnil;
@@ -3909,7 +4080,8 @@ void init_curb_easy() {
 
   rb_define_method(cCurlEasy, "http", ruby_curl_easy_perform_verb, 1);
   rb_define_method(cCurlEasy, "http_post", ruby_curl_easy_perform_post, -1);
-  rb_define_method(cCurlEasy, "http_put", ruby_curl_easy_perform_put, 1);
+  rb_define_method(cCurlEasy, "http_put", ruby_curl_easy_perform_put, -1);
+  rb_define_method(cCurlEasy, "http_patch", ruby_curl_easy_perform_patch, -1);
 
   /* Post-perform info methods */
   rb_define_method(cCurlEasy, "body_str", ruby_curl_easy_body_str_get, 0);

data/ext/curb_multi.c

@@ -27,6 +27,21 @@
   #include <fcntl.h>
 #endif
 
+#ifdef HAVE_CURL_MULTI_WAIT
+#include <stdint.h>  /* for intptr_t */
+
+struct wait_args {
+  CURLM *handle;
+  long timeout_ms;
+  int numfds;
+};
+static void *curl_multi_wait_wrapper(void *p) {
+  struct wait_args *args = p;
+  CURLMcode code = curl_multi_wait(args->handle, NULL, 0, args->timeout_ms, &args->numfds);
+  return (void *)(intptr_t)code;
+}
+#endif
+
 extern VALUE mCurl;
 static VALUE idCall;
 
@@ -226,6 +241,8 @@ VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
 
   mcode = curl_multi_add_handle(rbcm->handle, rbce->curl);
   if (mcode != CURLM_CALL_MULTI_PERFORM && mcode != CURLM_OK) {
+    ruby_curl_easy_cleanup(easy, rbce);
+
     raise_curl_multi_error_exception(mcode);
   }
 
@@ -264,6 +281,7 @@ VALUE ruby_curl_multi_remove(VALUE self, VALUE rb_easy_handle) {
 
   return self;
 }
+
 static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy) {
   CURLMcode result;
   ruby_curl_easy *rbce;
@@ -528,7 +546,6 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
 
   do {
     while (rbcm->running) {
-
 #ifdef HAVE_CURL_MULTI_TIMEOUT
       /* get the curl suggested time out */
       mcode = curl_multi_timeout(rbcm->handle, &timeout_milliseconds);
@@ -552,6 +569,31 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
                                                         /* or buggy versions libcurl sometimes reports huge timeouts... let's cap it */
       }
 
+#ifdef HAVE_CURL_MULTI_WAIT
+      {
+        struct wait_args wait_args;
+        wait_args.handle     = rbcm->handle;
+        wait_args.timeout_ms = timeout_milliseconds;
+        wait_args.numfds     = 0;
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
+        CURLMcode wait_rc = (CURLMcode)(intptr_t)
+                            rb_thread_call_without_gvl(curl_multi_wait_wrapper, &wait_args, RUBY_UBF_IO, NULL);
+#else
+        CURLMcode wait_rc = curl_multi_wait(rbcm->handle, NULL, 0, timeout_milliseconds, &wait_args.numfds);
+#endif
+        if (wait_rc != CURLM_OK) {
+          raise_curl_multi_error_exception(wait_rc);
+        }
+        if (wait_args.numfds == 0) {
+          rb_thread_wait_for(tv_100ms);
+        }
+        /* Process pending transfers after waiting */
+        rb_curl_multi_run(self, rbcm->handle, &(rbcm->running));
+        rb_curl_multi_read_info(self, rbcm->handle);
+        if (block != Qnil) { rb_funcall(block, rb_intern("call"), 1, self); }
+      }
+#else
+
       tv.tv_sec  = 0; /* never wait longer than 1 second */
       tv.tv_usec = (int)(timeout_milliseconds * 1000); /* XXX: int is the right type for OSX, what about linux? */
 
@@ -618,6 +660,7 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
         if (block != Qnil) { rb_funcall(block, rb_intern("call"), 1, self);  }
         break;
       }
+#endif /* HAVE_CURL_MULTI_WAIT */
     }
 
   } while( rbcm->running );

data/ext/curb_postfield.c

@@ -421,71 +421,108 @@ static VALUE ruby_curl_postfield_content_proc_set(int argc, VALUE *argv, VALUE s
  * Only content fields may be converted to strings.
  */
 static VALUE ruby_curl_postfield_to_str(VALUE self) {
-  // FIXME This is using the deprecated curl_escape func
   ruby_curl_postfield *rbcpf;
   VALUE result = Qnil;
   VALUE name = Qnil;
   char *tmpchrs;
-  
+#ifdef HAVE_CURL_EASY_ESCAPE
+  CURL *curl_handle = NULL;
+#endif
+
   Data_Get_Struct(self, ruby_curl_postfield, rbcpf);
 
-    if (rbcpf->name != Qnil) {
-      name = rbcpf->name;
-      if (rb_type(name) == T_STRING) {
-        name = rbcpf->name;
-      } else if (rb_respond_to(name,rb_intern("to_s"))) {
+  if (rbcpf->name != Qnil) {
+    name = rbcpf->name;
+    if (TYPE(name) != T_STRING) {
+      if (rb_respond_to(name, rb_intern("to_s")))
         name = rb_funcall(name, rb_intern("to_s"), 0);
-      }
-      else {
-        name = Qnil; // we can't handle this object
-      }
-    }
-    if (name == Qnil) {
-      rb_raise(eCurlErrInvalidPostField, "Cannot convert unnamed field to string %s:%d, make sure your field name responds_to :to_s", __FILE__, __LINE__);
+      else
+        name = Qnil;
     }
+  }
+  if (name == Qnil) {
+    rb_raise(eCurlErrInvalidPostField,
+             "Cannot convert unnamed field to string %s:%d, make sure your field name responds_to :to_s",
+             __FILE__, __LINE__);
+  }
+  /* Force field name to UTF-8 before escaping */
+  VALUE name_utf8 = rb_str_export_to_enc(name, rb_utf8_encoding());
 
-    tmpchrs = curl_escape(StringValuePtr(name), (int)RSTRING_LEN(name));
-    
-    if (!tmpchrs) {
-      rb_raise(eCurlErrInvalidPostField, "Failed to url-encode name `%s'", tmpchrs);
-    } else {
-      VALUE tmpcontent = Qnil;
-      VALUE escd_name = rb_str_new2(tmpchrs);
-      curl_free(tmpchrs);
-      
-      if (rbcpf->content_proc != Qnil) {
-        tmpcontent = rb_funcall(rbcpf->content_proc, idCall, 1, self);
-      } else if (rbcpf->content != Qnil) {
-        tmpcontent = rbcpf->content;
-      } else if (rbcpf->local_file != Qnil) {
-        tmpcontent = rbcpf->local_file;
-      } else if (rbcpf->remote_file != Qnil) {
-        tmpcontent = rbcpf->remote_file;
-      } else {
-        tmpcontent = rb_str_new2("");
-      }
-      if (TYPE(tmpcontent) != T_STRING) {
-        if (rb_respond_to(tmpcontent, rb_intern("to_s"))) {
-          tmpcontent = rb_funcall(tmpcontent, rb_intern("to_s"), 0);
-        }
-        else {
-          rb_raise(rb_eRuntimeError, "postfield(%s) is not a string and does not respond_to to_s", RSTRING_PTR(escd_name) );
-        }
-      }
-      //fprintf(stderr, "encoding content: %ld - %s\n", RSTRING_LEN(tmpcontent), RSTRING_PTR(tmpcontent) );
-      tmpchrs = curl_escape(RSTRING_PTR(tmpcontent), (int)RSTRING_LEN(tmpcontent));
-      if (!tmpchrs) {
-        rb_raise(eCurlErrInvalidPostField, "Failed to url-encode content `%s'", tmpchrs);
-      } else {
-        VALUE escd_content = rb_str_new2(tmpchrs);
-        curl_free(tmpchrs);
-        
-        result = escd_name;
-        rb_str_cat(result, "=", 1);
-        rb_str_concat(result, escd_content); 
-      }
+#ifdef HAVE_CURL_EASY_ESCAPE
+  curl_handle = curl_easy_init();
+  if (!curl_handle) {
+    rb_raise(eCurlErrInvalidPostField, "Failed to initialize curl handle for escaping");
+  }
+  tmpchrs = curl_easy_escape(curl_handle, StringValuePtr(name_utf8), (int)RSTRING_LEN(name_utf8));
+  if (!tmpchrs) {
+    curl_easy_cleanup(curl_handle);
+    rb_raise(eCurlErrInvalidPostField, "Failed to url-encode name");
+  }
+#else
+  tmpchrs = curl_escape(StringValuePtr(name_utf8), (int)RSTRING_LEN(name_utf8));
+  if (!tmpchrs) {
+    rb_raise(eCurlErrInvalidPostField, "Failed to url-encode name");
+  }
+#endif
+
+  VALUE escd_name = rb_str_new2(tmpchrs);
+#ifdef HAVE_CURL_EASY_ESCAPE
+  curl_free(tmpchrs);
+#else
+  curl_free(tmpchrs);
+#endif
+
+  VALUE tmpcontent = Qnil;
+  if (rbcpf->content_proc != Qnil) {
+    tmpcontent = rb_funcall(rbcpf->content_proc, idCall, 1, self);
+  } else if (rbcpf->content != Qnil) {
+    tmpcontent = rbcpf->content;
+  } else if (rbcpf->local_file != Qnil) {
+    tmpcontent = rbcpf->local_file;
+  } else if (rbcpf->remote_file != Qnil) {
+    tmpcontent = rbcpf->remote_file;
+  } else {
+    tmpcontent = rb_str_new2("");
+  }
+  if (TYPE(tmpcontent) != T_STRING) {
+    if (rb_respond_to(tmpcontent, rb_intern("to_s")))
+      tmpcontent = rb_funcall(tmpcontent, rb_intern("to_s"), 0);
+    else {
+#ifdef HAVE_CURL_EASY_ESCAPE
+      curl_easy_cleanup(curl_handle);
+#endif
+      rb_raise(rb_eRuntimeError,
+               "postfield(%s) is not a string and does not respond_to to_s",
+               RSTRING_PTR(escd_name));
     }
-  
+  }
+  /* Force content to UTF-8 before escaping */
+  VALUE content_utf8 = rb_str_export_to_enc(tmpcontent, rb_utf8_encoding());
+#ifdef HAVE_CURL_EASY_ESCAPE
+  tmpchrs = curl_easy_escape(curl_handle, StringValuePtr(content_utf8), (int)RSTRING_LEN(content_utf8));
+  if (!tmpchrs) {
+    curl_easy_cleanup(curl_handle);
+    rb_raise(eCurlErrInvalidPostField, "Failed to url-encode content");
+  }
+#else
+  tmpchrs = curl_escape(StringValuePtr(content_utf8), (int)RSTRING_LEN(content_utf8));
+  if (!tmpchrs) {
+    rb_raise(eCurlErrInvalidPostField, "Failed to url-encode content");
+  }
+#endif
+
+  VALUE escd_content = rb_str_new2(tmpchrs);
+#ifdef HAVE_CURL_EASY_ESCAPE
+  curl_free(tmpchrs);
+  curl_easy_cleanup(curl_handle);
+#else
+  curl_free(tmpchrs);
+#endif
+
+  result = escd_name;
+  rb_str_cat(result, "=", 1);
+  rb_str_concat(result, escd_content);
+
   return result;
 }
 

data/ext/extconf.rb

@@ -467,6 +467,8 @@ have_func('rb_thread_blocking_region')
 have_header('ruby/thread.h') && have_func('rb_thread_call_without_gvl', 'ruby/thread.h')
 have_header('ruby/io.h')
 have_func('rb_io_stdio_file')
+have_func('curl_multi_wait')
+have_func('curl_easy_duphandle')
 
 create_header('curb_config.h')
 create_makefile('curb_core')

data/lib/curl/easy.rb

@@ -374,13 +374,36 @@ module Curl
       #
       # call-seq:
       #   Curl::Easy.http_put(url, data) {|c| ... }
+      #   Curl::Easy.http_put(url, "some=urlencoded%20form%20data&and=so%20on") => true
+      #   Curl::Easy.http_put(url, "some=urlencoded%20form%20data", "and=so%20on", ...) => true
+      #   Curl::Easy.http_put(url, "some=urlencoded%20form%20data", Curl::PostField, "and=so%20on", ...) => true
+      #   Curl::Easy.http_put(url, Curl::PostField, Curl::PostField ..., Curl::PostField) => true
       #
       # see easy.http_put
       #
-      def http_put(url, data)
-        c = Curl::Easy.new url
+      def http_put(*args)
+        url = args.shift
+        c = Curl::Easy.new(url)
+        yield c if block_given?
+        c.http_put(*args)
+        c
+      end
+
+      #
+      # call-seq:
+      #   Curl::Easy.http_patch(url, data) {|c| ... }
+      #   Curl::Easy.http_patch(url, "some=urlencoded%20form%20data&and=so%20on") => true
+      #   Curl::Easy.http_patch(url, "some=urlencoded%20form%20data", "and=so%20on", ...) => true
+      #   Curl::Easy.http_patch(url, "some=urlencoded%20form%20data", Curl::PostField, "and=so%20on", ...) => true
+      #   Curl::Easy.http_patch(url, Curl::PostField, Curl::PostField ..., Curl::PostField) => true
+      #
+      # see easy.http_patch
+      #
+      def http_patch(*args)
+        url = args.shift
+        c = Curl::Easy.new(url)
         yield c if block_given?
-        c.http_put data
+        c.http_patch(*args)
         c
       end
 

data/lib/curl/multi.rb

@@ -95,7 +95,7 @@ module Curl
 
         # configure the multi handle
         multi_options.each { |k,v| m.send("#{k}=", v) }
-        callbacks = [:on_progress,:on_debug,:on_failure,:on_success,:on_redirect,:on_body,:on_header]
+        callbacks = [:on_progress,:on_debug,:on_failure,:on_success,:on_redirect,:on_missing,:on_body,:on_header]
 
         add_free_handle = proc do|conf, easy|
           c       = conf.dup # avoid being destructive to input

data/tests/helper.rb

@@ -80,6 +80,10 @@ class TestServlet < WEBrick::HTTPServlet::AbstractServlet
       res.status = 404
     elsif req.path.match(/error$/)
       res.status = 500
+    elsif req.path.match(/get_cookies$/)
+      res['Content-Type'] = "text/plain"
+      res.body = req['Cookie']
+      return
     end
     respond_with("GET#{req.query_string}",req,res)
   end
@@ -90,7 +94,18 @@ class TestServlet < WEBrick::HTTPServlet::AbstractServlet
   end
 
   def do_POST(req,res)
-    if req.query['filename'].nil?
+    if req.path.match(/set_cookies$/)
+      JSON.parse(req.body || '[]', symbolize_names: true).each do |hash|
+        cookie = WEBrick::Cookie.new(hash.fetch(:name), hash.fetch(:value))
+        cookie.domain = hash[:domain] if hash.key?(:domain)
+        cookie.expires = hash[:expires] if hash.key?(:expires)
+        cookie.path = hash[:path] if hash.key?(:path)
+        cookie.secure = hash[:secure] if hash.key?(:secure)
+        cookie.max_age = hash[:max_age] if hash.key?(:max_age)
+        res.cookies.push(cookie)
+      end
+      respond_with('OK', req, res)
+    elsif req.query['filename'].nil?
       if req.body
         params = {}
         req.body.split('&').map{|s| k,v=s.split('='); params[k] = v }

data/tests/tc_curl_easy.rb

@@ -110,7 +110,7 @@ class TestCurbCurlEasy < Test::Unit::TestCase
   end    
 
   def test_class_perform_02
-    data = ""
+    data = String.new
     assert_instance_of Curl::Easy, c = Curl::Easy.perform($TEST_URL) { |curl| curl.on_body { |d| data << d; d.length } }    
 
     assert_nil c.body_str
@@ -211,7 +211,7 @@ class TestCurbCurlEasy < Test::Unit::TestCase
   end    
 
   def test_get_02
-    data = ""
+    data = String.new
     c = Curl::Easy.new($TEST_URL) do |curl|
       curl.on_body { |d| data << d; d.length }
     end
@@ -765,20 +765,27 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_equal 'GET', curl.body_str
   end
   
-  def test_post_remote
+  def test_remote
     curl = Curl::Easy.new(TestServlet.url)
     curl.http_post([Curl::PostField.content('document_id', 5)])
     assert_equal "POST\ndocument_id=5", curl.unescape(curl.body_str)
+
+    curl.http_put([Curl::PostField.content('document_id', 5)])
+    assert_equal "PUT\ndocument_id=5", curl.unescape(curl.body_str)
+
+    curl.http_patch([Curl::PostField.content('document_id', 5)])
+    assert_equal "PATCH\ndocument_id=5", curl.unescape(curl.body_str)
   end
 
-  def test_post_remote_is_easy_handle
+  def test_remote_is_easy_handle
     # see: http://pastie.org/560852 and
     # http://groups.google.com/group/curb---ruby-libcurl-bindings/browse_thread/thread/216bb2d9b037f347?hl=en
-    [:post, :get, :head, :delete].each do |method|
+    [:post, :patch, :put, :get, :head, :delete].each do |method|
       retries = 0
       begin
         count = 0
-        Curl::Easy.send("http_#{method}", TestServlet.url) do|c|
+        m = "http_#{method}".to_sym
+        Curl::Easy.send(m, TestServlet.url) do|c|
           count += 1
           assert_equal Curl::Easy, c.class
         end
@@ -787,12 +794,14 @@ class TestCurbCurlEasy < Test::Unit::TestCase
         retries+=1
         retry if retries < 3
         raise e
+      rescue ArgumentError => e
+        assert false, "#{m} - #{e.message}"
       end
     end
   end
 
   # see: https://github.com/rvanlieshout/curb/commit/8bcdefddc0162484681ebd1a92d52a642666a445
-  def test_post_multipart_array_remote
+  def test_multipart_array_remote
     curl = Curl::Easy.new(TestServlet.url)
     curl.multipart_form_post = true
     fields = [
@@ -802,9 +811,23 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     curl.http_post(fields)
     assert_match(/HTTP POST file upload/, curl.body_str)
     assert_match(/Content-Disposition: form-data/, curl.body_str)
+
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.multipart_form_post = true
+    fields = [
+      Curl::PostField.file('foo', File.expand_path(File.join(File.dirname(__FILE__),'..','README.markdown'))),
+      Curl::PostField.file('bar', File.expand_path(File.join(File.dirname(__FILE__),'..','README.markdown')))
+    ]
+    curl.http_put(fields)
+    assert_match(/HTTP POST file upload/, curl.body_str)
+    assert_match(/Content-Disposition: form-data/, curl.body_str)
+
+    curl.http_patch(fields)
+    assert_match(/HTTP POST file upload/, curl.body_str)
+    assert_match(/Content-Disposition: form-data/, curl.body_str)
   end
   
-  def test_post_with_body_remote
+  def test_with_body_remote
     curl = Curl::Easy.new(TestServlet.url)
     curl.post_body = 'foo=bar&encoded%20string=val'
     
@@ -812,23 +835,42 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     
     assert_equal "POST\nfoo=bar&encoded%20string=val", curl.body_str
     assert_equal 'foo=bar&encoded%20string=val', curl.post_body
+
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.put_data = 'foo=bar&encoded%20string=val'
+    
+    curl.perform
+    
+    assert_equal "PUT\nfoo=bar&encoded%20string=val", curl.body_str
   end
   
-  def test_form_post_body_remote
+  def test_form_body_remote
     curl = Curl::Easy.new(TestServlet.url)
     curl.http_post('foo=bar', 'encoded%20string=val')
     
     assert_equal "POST\nfoo=bar&encoded%20string=val", curl.body_str
     assert_equal 'foo=bar&encoded%20string=val', curl.post_body
-  end
 
-  def test_post_multipart_file_remote
     curl = Curl::Easy.new(TestServlet.url)
-    curl.multipart_form_post = true
-    pf = Curl::PostField.file('readme', File.expand_path(File.join(File.dirname(__FILE__),'..','README.markdown')))
-    curl.http_post(pf)
-    assert_match(/HTTP POST file upload/, curl.body_str)
-    assert_match(/Content-Disposition: form-data/, curl.body_str)
+    curl.http_put('foo=bar', 'encoded%20string=val')
+    
+    assert_equal "PUT\nfoo=bar&encoded%20string=val", curl.body_str
+
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.http_patch('foo=bar', 'encoded%20string=val')
+    
+    assert_equal "PATCH\nfoo=bar&encoded%20string=val", curl.body_str
+  end
+
+  def test_multipart_file_remote
+    [:put, :post, :patch].each {|method|
+      curl = Curl::Easy.new(TestServlet.url)
+      curl.multipart_form_post = true
+      pf = Curl::PostField.file('readme', File.expand_path(File.join(File.dirname(__FILE__),'..','README.markdown')))
+      curl.send("http_#{method}", pf)
+      assert_match(/HTTP POST file upload/, curl.body_str)
+      assert_match(/Content-Disposition: form-data/, curl.body_str)
+    }
   end
 
   def test_delete_remote
@@ -1065,16 +1107,22 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_equal "PUT\nhello", curl.body_str
     curl.http('COPY')
     assert_equal 'COPY', curl.body_str
+
+    curl.http_patch
+    assert_equal "PATCH\n", curl.body_str
+
+    curl.http_put
+    assert_equal "PUT\n", curl.body_str
   end
 
   def test_easy_http_verbs_must_respond_to_str
-    # issue http://github.com/taf2/curb/issues#issue/45
+    # issue http://github.com/taf2/curb/issues/45
     assert_nothing_raised do
-      c = Curl::Easy.new ; c.url = 'http://example.com' ; c.http(:get)
+      c = Curl::Easy.new ; c.url = TestServlet.url ; c.http(:get)
     end
 
     assert_raise RuntimeError do
-      c = Curl::Easy.new ; c.url = 'http://example.com' ; c.http(FooNoToS.new)
+      c = Curl::Easy.new ; c.url = TestServlet.url ; c.http(FooNoToS.new)
     end
 
   end

data/tests/tc_curl_easy_cookielist.rb

@@ -0,0 +1,277 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require 'json'
+
+class TestCurbCurlEasyCookielist < Test::Unit::TestCase
+  def test_setopt_cookielist
+    easy = Curl::Easy.new
+    # DateTime handles time zone correctly
+    expires = (Date.today + 2).to_datetime
+    easy.setopt(Curl::CURLOPT_COOKIELIST, "Set-Cookie: c1=v1; domain=localhost; expires=#{expires.httpdate};")
+    easy.setopt(Curl::CURLOPT_COOKIELIST, 'Set-Cookie: c2=v2; domain=localhost')
+    easy.setopt(Curl::CURLOPT_COOKIELIST, "Set-Cookie: c3=v3; expires=#{expires.httpdate};")
+    easy.setopt(Curl::CURLOPT_COOKIELIST, 'Set-Cookie: c4=v4;')
+    easy.setopt(Curl::CURLOPT_COOKIELIST, "Set-Cookie: c5=v5; domain=127.0.0.1; expires=#{expires.httpdate};")
+    easy.setopt(Curl::CURLOPT_COOKIELIST, 'Set-Cookie: c6=v6; domain=127.0.0.1;;')
+
+    # Since 7.43.0 cookies that were imported in the Set-Cookie format without a domain name are not exported by this option.
+    # So, before 7.43.0, c3 and c4 will be exported too; but that version is far too old for current curb version, so it's not handled here.
+    if Curl::CURL_VERSION.to_f > 8
+    expected_cookielist = [
+      ".127.0.0.1\tTRUE\t/\tFALSE\t#{expires.to_time.to_i}\tc5\tv5",
+      ".127.0.0.1\tTRUE\t/\tFALSE\t0\tc6\tv6",
+      ".localhost\tTRUE\t/\tFALSE\t#{expires.to_time.to_i}\tc1\tv1",
+      ".localhost\tTRUE\t/\tFALSE\t0\tc2\tv2",
+    ]
+    else
+    expected_cookielist = [
+      "127.0.0.1\tFALSE\t/\tFALSE\t#{expires.to_time.to_i}\tc5\tv5",
+      "127.0.0.1\tFALSE\t/\tFALSE\t0\tc6\tv6",
+      ".localhost\tTRUE\t/\tFALSE\t#{expires.to_time.to_i}\tc1\tv1",
+      ".localhost\tTRUE\t/\tFALSE\t0\tc2\tv2",
+    ]
+    end
+    assert_equal expected_cookielist, easy.cookielist
+
+    easy.url = "#{TestServlet.url}/get_cookies"
+    easy.perform
+    assert_equal 'c6=v6; c5=v5; c4=v4; c3=v3', easy.body_str
+    easy.url = "http://localhost:#{TestServlet.port}#{TestServlet.path}/get_cookies"
+    easy.perform
+    assert_equal 'c2=v2; c1=v1', easy.body_str
+  end
+
+  # libcurl documentation says: "This option also enables the cookie engine", but it's not tracked on the curb level
+  def test_setopt_cookielist_enables_cookie_engine
+    easy = Curl::Easy.new
+    expires = (Date.today + 2).to_datetime
+    easy.url = "http://localhost:#{TestServlet.port}#{TestServlet.path}/set_cookies"
+    easy.setopt(Curl::CURLOPT_COOKIELIST, "Set-Cookie: c1=v1; domain=localhost; expires=#{expires.httpdate};")
+    easy.post_body = JSON.generate([{ name: 'c2', value: 'v2', domain: 'localhost', expires: expires.httpdate, path: '/' }])
+    easy.perform
+    easy.url = "http://localhost:#{TestServlet.port}#{TestServlet.path}/get_cookies"
+    easy.post_body = nil
+    easy.perform
+
+    assert !easy.enable_cookies?
+    assert_equal [".localhost\tTRUE\t/\tFALSE\t#{expires.to_time.to_i}\tc1\tv1", ".localhost\tTRUE\t/\tFALSE\t#{expires.to_time.to_i}\tc2\tv2"], easy.cookielist
+    assert_equal 'c2=v2; c1=v1', easy.body_str
+  end
+
+  def test_setopt_cookielist_invalid_format
+    easy = Curl::Easy.new
+    easy.url = "http://localhost:#{TestServlet.port}#{TestServlet.path}/get_cookies"
+    easy.setopt(Curl::CURLOPT_COOKIELIST, 'Not a cookie')
+    assert_nil easy.cookielist
+    easy.perform
+    assert_equal '', easy.body_str
+  end
+
+  def test_setopt_cookielist_netscape_format
+    easy = Curl::Easy.new
+    expires = (Date.today + 2).to_datetime
+    easy.url = "http://localhost:#{TestServlet.port}#{TestServlet.path}/get_cookies"
+    # Note domain changes for include subdomains
+    [
+      ['localhost', 'FALSE', '/', 'TRUE', 0, 'session_http_only', '42'].join("\t"),
+      ['.localhost', 'TRUE', '/', 'FALSE', 0, 'session', '43'].join("\t"),
+      ['localhost', 'TRUE', '/', 'FALSE', expires.to_time.to_i, 'permanent', '44'].join("\t"),
+      ['.localhost', 'FALSE', '/', 'TRUE', expires.to_time.to_i, 'permanent_http_only', '45'].join("\t"),
+    ].each { |cookie| easy.setopt(Curl::CURLOPT_COOKIELIST, cookie) }
+
+    expected_cookielist = [
+      ['localhost', 'FALSE', '/', 'TRUE', 0, 'session_http_only', '42'].join("\t"),
+      ['.localhost', 'TRUE', '/', 'FALSE', 0, 'session', '43'].join("\t"),
+      ['.localhost', 'TRUE', '/', 'FALSE', expires.to_time.to_i, 'permanent', '44'].join("\t"),
+      ['localhost', 'FALSE', '/', 'TRUE', expires.to_time.to_i, 'permanent_http_only', '45'].join("\t"),
+    ]
+    assert_equal expected_cookielist, easy.cookielist
+    easy.perform
+    assert_equal 'permanent_http_only=45; session_http_only=42; permanent=44; session=43', easy.body_str
+  end
+
+  # Multiple cookies and comments are not supported
+  def test_setopt_cookielist_netscape_format_mutliline
+    easy = Curl::Easy.new
+    easy.url = "http://localhost:#{TestServlet.port}#{TestServlet.path}/get_cookies"
+    easy.setopt(
+      Curl::CURLOPT_COOKIELIST,
+      [
+        '# Netscape HTTP Cookie File',
+        ['.localhost', 'TRUE', '/', 'FALSE', 0, 'session', '42'].join("\t"),
+        '',
+      ].join("\n"),
+    )
+    assert_nil easy.cookielist
+    easy.perform
+    assert_equal '', easy.body_str
+
+    easy.setopt(
+      Curl::CURLOPT_COOKIELIST,
+      [
+        ['.localhost', 'TRUE', '/', 'FALSE', 0, 'session', '42'].join("\t"),
+        ['.localhost', 'TRUE', '/', 'FALSE', 0, 'session2', '84'].join("\t"),
+        '',
+      ].join("\n"),
+    )
+    # Only first cookie is set
+    assert_equal [".localhost\tTRUE\t/\tFALSE\t0\tsession\t42"], easy.cookielist
+    easy.perform
+    assert_equal 'session=42', easy.body_str
+  end
+
+  # ALL erases all cookies held in memory
+  # ALL was added in 7.14.1
+  def test_setopt_cookielist_command_all
+    expires = (Date.today + 2).to_datetime
+    with_permanent_and_session_cookies(expires) do |easy|
+      easy.setopt(Curl::CURLOPT_COOKIELIST, 'ALL')
+      assert_nil easy.cookielist
+      easy.perform
+      assert_equal '', easy.body_str
+    end
+  end
+
+  # SESS erases all session cookies held in memory
+  # SESS was added in 7.15.4
+  def test_setopt_cookielist_command_sess
+    expires = (Date.today + 2).to_datetime
+    with_permanent_and_session_cookies(expires) do |easy|
+      easy.setopt(Curl::CURLOPT_COOKIELIST, 'SESS')
+      assert_equal [".localhost\tTRUE\t/\tFALSE\t#{expires.to_time.to_i}\tpermanent\t42"], easy.cookielist
+      easy.perform
+      assert_equal 'permanent=42', easy.body_str
+    end
+  end
+
+  # FLUSH writes all known cookies to the file specified by CURLOPT_COOKIEJAR
+  # FLUSH was added in 7.17.1
+  def test_setopt_cookielist_command_flush
+    expires = (Date.today + 2).to_datetime
+    with_permanent_and_session_cookies(expires) do |easy|
+      cookiejar = File.join(Dir.tmpdir, 'curl_test_cookiejar')
+      assert !File.exist?(cookiejar)
+      begin
+        easy.cookiejar = cookiejar
+        # trick to actually set CURLOPT_COOKIEJAR
+        easy.enable_cookies = true
+        easy.perform
+        assert !File.exist?(cookiejar)
+        easy.setopt(Curl::CURLOPT_COOKIELIST, 'FLUSH')
+        expected_cookiejar = <<~COOKIEJAR
+          # Netscape HTTP Cookie File
+          # https://curl.se/docs/http-cookies.html
+          # This file was generated by libcurl! Edit at your own risk.
+          
+          .localhost	TRUE	/	FALSE	0	session	420
+          .localhost	TRUE	/	FALSE	#{expires.to_time.to_i}	permanent	42
+        COOKIEJAR
+        assert_equal expected_cookiejar, File.read(cookiejar)
+      ensure
+        # Otherwise it'll create this file again
+        easy.close
+        File.unlink(cookiejar) if File.exist?(cookiejar)
+      end
+    end
+  end
+
+  # RELOAD loads all cookies from the files specified by CURLOPT_COOKIEFILE
+  # RELOAD was added in 7.39.0
+  def test_setopt_cookielist_command_reload
+    expires = (Date.today + 2).to_datetime
+    expires_file = (Date.today + 4).to_datetime
+    with_permanent_and_session_cookies(expires) do |easy|
+      cookiefile = File.join(Dir.tmpdir, 'curl_test_cookiefile')
+      assert !File.exist?(cookiefile)
+      begin
+        cookielist = [
+          # Won't be updated, added instead
+          ".localhost\tTRUE\t/\tFALSE\t#{expires_file.to_time.to_i}\tpermanent\t84",
+          ".localhost\tTRUE\t/\tFALSE\t#{expires_file.to_time.to_i}\tpermanent_file\t84",
+          # Won't be updated, added instead
+          ".localhost\tTRUE\t/\tFALSE\t0\tsession\t840",
+          ".localhost\tTRUE\t/\tFALSE\t0\tsession_file\t840",
+          '',
+        ]
+        File.write(cookiefile, cookielist.join("\n"))
+        easy.cookiefile = cookiefile
+        # trick to actually set CURLOPT_COOKIEFILE
+        easy.enable_cookies = true
+        easy.perform
+        easy.setopt(Curl::CURLOPT_COOKIELIST, 'RELOAD')
+        expected_cookielist = [
+          ".localhost\tTRUE\t/\tFALSE\t#{expires.to_time.to_i}\tpermanent\t42",
+          ".localhost\tTRUE\t/\tFALSE\t0\tsession\t420",
+          ".localhost\tTRUE\t/\tFALSE\t#{expires_file.to_time.to_i}\tpermanent\t84",
+          ".localhost\tTRUE\t/\tFALSE\t#{expires_file.to_time.to_i}\tpermanent_file\t84",
+          ".localhost\tTRUE\t/\tFALSE\t0\tsession\t840",
+          ".localhost\tTRUE\t/\tFALSE\t0\tsession_file\t840",
+        ]
+        assert_equal expected_cookielist, easy.cookielist
+        easy.perform
+        # Be careful, duplicates are not removed
+        assert_equal 'permanent_file=84; session_file=840; permanent=84; session=840; permanent=42; session=420', easy.body_str
+      ensure
+        File.unlink(cookiefile) if File.exist?(cookiefile)
+      end
+    end
+  end
+
+  def test_commands_do_not_enable_cookie_engine
+    %w[ALL SESS FLUSH RELOAD].each do |command|
+      easy = Curl::Easy.new
+      expires = (Date.today + 2).to_datetime
+      easy.url = "http://localhost:#{TestServlet.port}#{TestServlet.path}/set_cookies"
+      easy.setopt(Curl::CURLOPT_COOKIELIST, command)
+      easy.post_body = JSON.generate([{ name: 'c2', value: 'v2', domain: 'localhost', expires: expires.httpdate, path: '/' }])
+      easy.perform
+      easy.url = "http://localhost:#{TestServlet.port}#{TestServlet.path}/get_cookies"
+      easy.post_body = nil
+      easy.perform
+
+      assert !easy.enable_cookies?
+      assert_nil easy.cookielist
+      assert_equal '', easy.body_str
+    end
+  end
+
+
+  def test_strings_without_cookie_enable_cookie_engine
+    [
+      '',
+      '# Netscape HTTP Cookie File',
+      'no_a_cookie',
+    ].each do |command|
+      easy = Curl::Easy.new
+      expires = (Date.today + 2).to_datetime
+      easy.url = "http://localhost:#{TestServlet.port}#{TestServlet.path}/set_cookies"
+      easy.setopt(Curl::CURLOPT_COOKIELIST, command)
+      easy.post_body = JSON.generate([{ name: 'c2', value: 'v2', domain: 'localhost', expires: expires.httpdate, path: '/' }])
+      easy.perform
+      easy.url = "http://localhost:#{TestServlet.port}#{TestServlet.path}/get_cookies"
+      easy.post_body = nil
+      easy.perform
+
+      assert !easy.enable_cookies?
+      assert_equal [".localhost\tTRUE\t/\tFALSE\t#{expires.to_time.to_i}\tc2\tv2"], easy.cookielist
+      assert_equal 'c2=v2', easy.body_str
+    end
+  end
+
+  def with_permanent_and_session_cookies(expires)
+    easy = Curl::Easy.new
+    easy.url = "http://localhost:#{TestServlet.port}#{TestServlet.path}/get_cookies"
+    easy.setopt(Curl::CURLOPT_COOKIELIST, "Set-Cookie: permanent=42; domain=localhost; expires=#{expires.httpdate};")
+    easy.setopt(Curl::CURLOPT_COOKIELIST, 'Set-Cookie: session=420; domain=localhost;')
+    assert_equal [".localhost\tTRUE\t/\tFALSE\t#{expires.to_time.to_i}\tpermanent\t42", ".localhost\tTRUE\t/\tFALSE\t0\tsession\t420"], easy.cookielist
+    easy.perform
+    assert_equal 'permanent=42; session=420', easy.body_str
+
+    yield easy
+  end
+
+  include TestServerMethods
+
+  def setup
+    server_setup
+  end
+end

data/tests/tc_curl_multi.rb

@@ -13,7 +13,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     # this test fails with libcurl 7.22.0. I didn't investigate, but it may be related
     # to CURLOPT_MAXCONNECTS bug fixed in 7.30.0:
     # https://github.com/curl/curl/commit/e87e76e2dc108efb1cae87df496416f49c55fca0
-    omit("Skip, libcurl too old (< 7.22.0)") if Curl::CURL_VERSION.split('.')[1].to_i <= 22
+    omit("Skip, libcurl too old (< 7.22.0)") if Curl::CURL_VERSION.to_f < 8 && Curl::CURL_VERSION.split('.')[1].to_i <= 22
 
     @server.shutdown if @server
     @test_thread.kill if @test_thread
@@ -114,13 +114,13 @@ class TestCurbCurlMulti < Test::Unit::TestCase
   end
 
   def test_new_multi_01
-    d1 = ""
+    d1 = String.new
     c1 = Curl::Easy.new($TEST_URL) do |curl|
       curl.headers["User-Agent"] = "myapp-0.0"
       curl.on_body {|d| d1 << d; d.length }
     end
 
-    d2 = ""
+    d2 = String.new
     c2 = Curl::Easy.new($TEST_URL) do |curl|
       curl.headers["User-Agent"] = "myapp-0.0"
       curl.on_body {|d| d2 << d; d.length }
@@ -186,7 +186,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     rescue Curl::Err::AbortedByCallbackError => e
       did_raise = true
       in_file = e.backtrace.detect {|err| err.match?(File.basename(__FILE__)) }
-      in_file_stack = e.backtrace.select {|err| err.match?(File.basename(__FILE__)) }
+      #in_file_stack = e.backtrace.select {|err| err.match?(File.basename(__FILE__)) }
       assert_match(__FILE__, in_file)
       in_file.gsub!(__FILE__)
       parts = in_file.split(':')
@@ -206,7 +206,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     m = Curl::Multi.new
     responses = []
     n.times do|i|
-      responses[i] = ""
+      responses[i] = String.new
       c = Curl::Easy.new($TEST_URL) do|curl|
         curl.on_body{|data| responses[i] << data; data.size }
       end
@@ -230,7 +230,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     5.times do|it|
       responses = []
       n.times do|i|
-        responses[i] = ""
+        responses[i] = String.new
         c = Curl::Easy.new($TEST_URL) do|curl|
           curl.on_body{|data| responses[i] << data; data.size }
         end
@@ -376,7 +376,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     attr_reader :buf
 
     def t_method
-      @buf = ""
+      @buf = String.new
       @m = Curl::Multi.new
       10.times do|i|
         c = Curl::Easy.new($TEST_URL)
@@ -422,8 +422,8 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     m = Curl::Multi.new
     # add a few easy handles
     requests.each do |url|
-      responses[url] = ""
-      responses["#{url}-header"] = ""
+      responses[url] = String.new
+      responses["#{url}-header"] = String.new
       c = Curl::Easy.new(url) do|curl|
         curl.follow_location = true
         curl.on_header{|data| responses["#{url}-header"] << data; data.size }

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: curb
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.0.8
 platform: ruby
 authors:
 - Ross Bamford
 - Todd A. Fisher
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-23 00:00:00.000000000 Z
+date: 2025-02-09 00:00:00.000000000 Z
 dependencies: []
 description: Curb (probably CUrl-RuBy or something) provides Ruby-language bindings
   for the libcurl(3), a fully-featured client-side URL transfer library. cURL and
@@ -67,6 +66,7 @@ files:
 - tests/tc_curl.rb
 - tests/tc_curl_download.rb
 - tests/tc_curl_easy.rb
+- tests/tc_curl_easy_cookielist.rb
 - tests/tc_curl_easy_resolve.rb
 - tests/tc_curl_easy_setopt.rb
 - tests/tc_curl_maxfilesize.rb
@@ -78,9 +78,8 @@ files:
 - tests/unittests.rb
 homepage: https://github.com/taf2/curb
 licenses:
-- MIT
+- Ruby
 metadata: {}
-post_install_message:
 rdoc_options:
 - "--main"
 - README.markdown
@@ -98,8 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Ruby libcurl bindings
 test_files:
@@ -125,6 +123,7 @@ test_files:
 - tests/tc_curl.rb
 - tests/tc_curl_download.rb
 - tests/tc_curl_easy.rb
+- tests/tc_curl_easy_cookielist.rb
 - tests/tc_curl_easy_resolve.rb
 - tests/tc_curl_easy_setopt.rb
 - tests/tc_curl_maxfilesize.rb