curb 0.8.4 → 1.3.5

data/ext/curb_easy.c

@@ -12,6 +12,9 @@
 
 #include <errno.h>
 #include <string.h>
+#ifndef _WIN32
+#include <strings.h>
+#endif
 
 extern VALUE mCurl;
 
@@ -25,20 +28,176 @@ static VALUE rbstrAmp;
 
 VALUE cCurlEasy;
 
+/* Internal wrapper type for passing pointers through rb_iterate callbacks.
+ * No mark/free needed - these are temporary wrappers that don't own memory. */
+static const rb_data_type_t curl_slist_ptr_type = {
+  "curl_slist_ptr_wrapper",
+  { NULL, NULL, NULL },
+  NULL, NULL, 0
+};
+
+// for Ruby 1.8
+#ifndef HAVE_RB_IO_STDIO_FILE
+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);
+static size_t proc_data_handler(char *stream, size_t size, size_t nmemb, VALUE proc);
 
 /* ================== CURL HANDLER FUNCS ==============*/
 
-static VALUE callback_exception(VALUE unused) {
+static VALUE callback_exception(VALUE unused, VALUE exception) {
   return Qfalse;
-} 
+}
+
+static VALUE callback_exception_store_on_easy(VALUE arg, VALUE exception) {
+  ruby_curl_easy *rbce = (ruby_curl_easy *)arg;
+
+  if (rbce && NIL_P(rbce->callback_error)) {
+    rbce->callback_error = exception;
+  }
+
+  return Qfalse;
+}
+
+VALUE rb_curl_easy_take_callback_error(ruby_curl_easy *rbce) {
+  VALUE exception = Qnil;
+
+  if (!rbce) {
+    return Qnil;
+  }
+
+  exception = rbce->callback_error;
+  rbce->callback_error = Qnil;
+  return exception;
+}
+
+static VALUE ruby_curl_easy_take_callback_error(VALUE self) {
+  ruby_curl_easy *rbce = NULL;
+
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  return rb_curl_easy_take_callback_error(rbce);
+}
+
+static VALUE ensure_clear_easy_callback_active(VALUE arg) {
+  ruby_curl_easy *rbce = (ruby_curl_easy *)arg;
+  if (rbce) {
+    rbce->callback_active = 0;
+  }
+  return Qnil;
+}
+
+static VALUE with_easy_callback_active(ruby_curl_easy *rbce, VALUE (*func)(VALUE), VALUE arg) {
+  rbce->callback_active = 1;
+  return rb_ensure(func, arg, ensure_clear_easy_callback_active, (VALUE)rbce);
+}
+
+struct stream_read_call_args {
+  VALUE stream;
+  size_t read_bytes;
+};
+
+static VALUE call_stream_read(VALUE argp) {
+  struct stream_read_call_args *args = (struct stream_read_call_args *)argp;
+  return rb_funcall(args->stream, rb_intern("read"), 1, ULONG2NUM((unsigned long)args->read_bytes));
+}
+
+static VALUE call_stream_to_s(VALUE stream) {
+  return rb_funcall(stream, rb_intern("to_s"), 0);
+}
+
+static VALUE call_string_value(VALUE str) {
+  StringValue(str);
+  return str;
+}
+
+struct stream_seek_call_args {
+  VALUE stream;
+  curl_off_t offset;
+  int origin;
+};
+
+static VALUE call_stream_seek(VALUE argp) {
+  struct stream_seek_call_args *args = (struct stream_seek_call_args *)argp;
+  return rb_funcall(args->stream, rb_intern("seek"), 2, LL2NUM(args->offset), INT2NUM(args->origin));
+}
+
+struct proc_data_call_args {
+  char *stream;
+  size_t size;
+  size_t nmemb;
+  VALUE proc;
+};
+
+static VALUE call_proc_data_handler_wrapped(VALUE argp) {
+  struct proc_data_call_args *args = (struct proc_data_call_args *)argp;
+  return ULONG2NUM((unsigned long)proc_data_handler(args->stream, args->size, args->nmemb, args->proc));
+}
+
+struct easy_callback_dispatch_args {
+  ruby_curl_easy *rbce;
+  VALUE (*func)(VALUE);
+  VALUE arg;
+};
 
-/* These handle both body and header data */
-static size_t default_data_handler(char *stream,
+static VALUE call_with_easy_callback_active(VALUE argp) {
+  struct easy_callback_dispatch_args *args = (struct easy_callback_dispatch_args *)argp;
+  return with_easy_callback_active(args->rbce, args->func, args->arg);
+}
+
+static VALUE rescue_easy_callback(ruby_curl_easy *rbce, VALUE (*func)(VALUE), VALUE arg) {
+  struct easy_callback_dispatch_args dispatch_args;
+  dispatch_args.rbce = rbce;
+  dispatch_args.func = func;
+  dispatch_args.arg = arg;
+  return rb_rescue(call_with_easy_callback_active, (VALUE)&dispatch_args, callback_exception_store_on_easy, (VALUE)rbce);
+}
+
+static size_t curl_read_abort_result(void) {
+#ifdef CURL_READFUNC_ABORT
+  return CURL_READFUNC_ABORT;
+#else
+  return 0;
+#endif
+}
+
+static int curl_seek_fail_result(void) {
+#ifdef CURL_SEEKFUNC_FAIL
+  return CURL_SEEKFUNC_FAIL;
+#else
+  return 1;
+#endif
+}
+
+/* Default body handler appends to easy.body_data buffer */
+static size_t default_body_handler(char *stream,
                                    size_t size,
                                    size_t nmemb,
-                                   VALUE out) {
-  rb_str_buf_cat(out, stream, size * nmemb);
-  return size * nmemb;
+                                   void *userdata) {
+  ruby_curl_easy *rbce = (ruby_curl_easy *)userdata;
+  size_t total = size * nmemb;
+  VALUE out = rb_easy_get("body_data");
+  if (NIL_P(out)) {
+    out = rb_easy_set("body_data", rb_str_buf_new(32768));
+  }
+  rb_str_buf_cat(out, stream, total);
+  return total;
+}
+
+/* Default header handler appends to easy.header_data buffer */
+static size_t default_header_handler(char *stream,
+                                     size_t size,
+                                     size_t nmemb,
+                                     void *userdata) {
+  ruby_curl_easy *rbce = (ruby_curl_easy *)userdata;
+  size_t total = size * nmemb;
+  VALUE out = rb_easy_get("header_data");
+  if (NIL_P(out)) {
+    out = rb_easy_set("header_data", rb_str_buf_new(16384));
+  }
+  rb_str_buf_cat(out, stream, total);
+  return total;
 }
 
 // size_t function( void *ptr, size_t size, size_t nmemb, void *stream);
@@ -48,14 +207,36 @@ static size_t read_data_handler(void *ptr,
                                 ruby_curl_easy *rbce) {
   VALUE upload = rb_easy_get("upload");
   size_t read_bytes = (size*nmemb);
-  VALUE stream = ruby_curl_upload_stream_get(upload);
+  VALUE stream;
+
+  if (NIL_P(upload)) {
+    return curl_read_abort_result();
+  }
+
+  stream = ruby_curl_upload_stream_get(upload);
 
   if (rb_respond_to(stream, rb_intern("read"))) {//if (rb_respond_to(stream, rb_intern("to_s"))) {
     /* copy read_bytes from stream into ptr */
-    VALUE str = rb_funcall(stream, rb_intern("read"), 1, rb_int_new(read_bytes) );
+    struct stream_read_call_args args;
+    args.stream = stream;
+    args.read_bytes = read_bytes;
+    VALUE str = rescue_easy_callback(rbce, call_stream_read, (VALUE)&args);
     if( str != Qnil ) {
-      memcpy(ptr, RSTRING_PTR(str), RSTRING_LEN(str));
-      return RSTRING_LEN(str);
+      size_t str_len;
+
+      str = rescue_easy_callback(rbce, call_string_value, str);
+      if (str == Qfalse || str == Qnil) {
+        return curl_read_abort_result();
+      }
+
+      str_len = (size_t)RSTRING_LEN(str);
+      if (str_len > read_bytes) {
+        snprintf(rbce->err_buf, CURL_ERROR_SIZE, "read callback returned more data than requested");
+        return curl_read_abort_result();
+      }
+
+      memcpy(ptr, RSTRING_PTR(str), str_len);
+      return str_len;
     }
     else {
       return 0;
@@ -67,13 +248,22 @@ static size_t read_data_handler(void *ptr,
     size_t len;
     size_t remaining;
     char *str_ptr;
-    Data_Get_Struct(upload, ruby_curl_upload, rbcu);
-    str = rb_funcall(stream, rb_intern("to_s"), 0);
+    TypedData_Get_Struct(upload, ruby_curl_upload, &ruby_curl_upload_data_type, rbcu);
+    str = rescue_easy_callback(rbce, call_stream_to_s, stream);
+    str = rescue_easy_callback(rbce, call_string_value, str);
+    if (str == Qfalse || str == Qnil) {
+      return curl_read_abort_result();
+    }
+
     len = RSTRING_LEN(str);
+    if (rbcu->offset >= len) {
+      return 0;
+    }
+
     remaining = len - rbcu->offset;
     str_ptr = RSTRING_PTR(str);
 
-    if( remaining < read_bytes ) {
+    if( remaining <= read_bytes ) {
       if( remaining > 0 ) {
         memcpy(ptr, str_ptr+rbcu->offset, remaining);
         read_bytes = remaining;
@@ -81,14 +271,10 @@ static size_t read_data_handler(void *ptr,
       }
       return remaining;
     }
-    else if( remaining > read_bytes ) { // read_bytes <= remaining - send what we can fit in the buffer(ptr)
+    else { // read_bytes < remaining - send what we can fit in the buffer(ptr)
       memcpy(ptr, str_ptr+rbcu->offset, read_bytes);
       rbcu->offset += read_bytes;
     }
-    else { // they're equal
-      memcpy(ptr, str_ptr+rbcu->offset, --read_bytes);
-      rbcu->offset += read_bytes;
-    }
     return read_bytes;
   }
   else {
@@ -96,6 +282,38 @@ static size_t read_data_handler(void *ptr,
   }
 }
 
+int seek_data_handler(ruby_curl_easy *rbce,
+                      curl_off_t offset,
+                      int origin) {
+
+  VALUE upload = rb_easy_get("upload");
+  VALUE stream;
+
+  if (NIL_P(upload)) {
+    return curl_seek_fail_result();
+  }
+
+  stream = ruby_curl_upload_stream_get(upload);
+
+  if (rb_respond_to(stream, rb_intern("seek"))) {
+    struct stream_seek_call_args args;
+    args.stream = stream;
+    args.offset = offset;
+    args.origin = origin;
+    rescue_easy_callback(rbce, call_stream_seek, (VALUE)&args);
+    if (!NIL_P(rbce->callback_error)) {
+      return curl_seek_fail_result();
+    }
+  } else {
+    ruby_curl_upload *rbcu;
+    TypedData_Get_Struct(upload, ruby_curl_upload, &ruby_curl_upload_data_type, rbcu);
+    // This OK because curl only uses SEEK_SET as per the documentation
+    rbcu->offset = offset;
+  }
+
+  return 0;
+}
+
 static size_t proc_data_handler(char *stream,
                                 size_t size,
                                 size_t nmemb,
@@ -120,22 +338,40 @@ static size_t proc_data_handler_body(char *stream,
                                      size_t nmemb,
                                      ruby_curl_easy *rbce)
 {
-  size_t ret;
-  rbce->callback_active = 1;
-  ret = proc_data_handler(stream, size, nmemb, rb_easy_get("body_proc"));
-  rbce->callback_active = 0;
-  return ret;
+  struct proc_data_call_args args;
+  struct easy_callback_dispatch_args dispatch_args;
+  VALUE procret;
+  args.stream = stream;
+  args.size = size;
+  args.nmemb = nmemb;
+  args.proc = rb_easy_get("body_proc");
+
+  dispatch_args.rbce = rbce;
+  dispatch_args.func = call_proc_data_handler_wrapped;
+  dispatch_args.arg = (VALUE)&args;
+  procret = rb_rescue(call_with_easy_callback_active, (VALUE)&dispatch_args, callback_exception_store_on_easy, (VALUE)rbce);
+
+  return ((procret == Qfalse) || (procret == Qnil)) ? 0 : NUM2ULONG(procret);
 }
 static size_t proc_data_handler_header(char *stream,
                                        size_t size,
                                        size_t nmemb,
                                        ruby_curl_easy *rbce)
 {
-  size_t ret;
-  rbce->callback_active = 1;
-  ret = proc_data_handler(stream, size, nmemb, rb_easy_get("header_proc"));
-  rbce->callback_active = 0;
-  return ret;
+  struct proc_data_call_args args;
+  struct easy_callback_dispatch_args dispatch_args;
+  VALUE procret;
+  args.stream = stream;
+  args.size = size;
+  args.nmemb = nmemb;
+  args.proc = rb_easy_get("header_proc");
+
+  dispatch_args.rbce = rbce;
+  dispatch_args.func = call_proc_data_handler_wrapped;
+  dispatch_args.arg = (VALUE)&args;
+  procret = rb_rescue(call_with_easy_callback_active, (VALUE)&dispatch_args, callback_exception_store_on_easy, (VALUE)rbce);
+
+  return ((procret == Qfalse) || (procret == Qnil)) ? 0 : NUM2ULONG(procret);
 }
 
 
@@ -147,11 +383,18 @@ static VALUE call_progress_handler(VALUE ary) {
                     rb_ary_entry(ary, 4)); // rb_float_new(ulnow));
 }
 
-static int proc_progress_handler(VALUE proc,
+/* CURLOPT_PROGRESSFUNCTION callback (deprecated since 7.32.0) */
+#ifndef HAVE_CURLOPT_XFERINFOFUNCTION
+static int proc_progress_handler(void *clientp,
                                  double dltotal,
                                  double dlnow,
                                  double ultotal,
                                  double ulnow) {
+  ruby_curl_easy *rbce = (ruby_curl_easy *)clientp;
+  VALUE proc = rb_easy_get("progress_proc");
+  if (proc == Qnil) {
+    return 0;
+  }
   VALUE procret;
   VALUE callargs = rb_ary_new2(5);
 
@@ -161,71 +404,267 @@ static int proc_progress_handler(VALUE proc,
   rb_ary_store(callargs, 3, rb_float_new(ultotal));
   rb_ary_store(callargs, 4, rb_float_new(ulnow));
 
-	//v = rb_rescue(range_check, (VALUE)args, range_failed, 0);
-  //procret = rb_funcall(proc, idCall, 4, rb_float_new(dltotal),
-  //                                      rb_float_new(dlnow),
-  //                                      rb_float_new(ultotal),
-  //                                      rb_float_new(ulnow));
-  procret = rb_rescue(call_progress_handler, callargs, callback_exception, Qnil);
+  struct easy_callback_dispatch_args dispatch_args;
+  dispatch_args.rbce = rbce;
+  dispatch_args.func = call_progress_handler;
+  dispatch_args.arg = callargs;
+  procret = rb_rescue(call_with_easy_callback_active, (VALUE)&dispatch_args, callback_exception, Qnil);
+
+  return(((procret == Qfalse) || (procret == Qnil)) ? -1 : 0);
+}
+#endif
+
+/* CURLOPT_XFERINFOFUNCTION callback (since 7.32.0, replaces PROGRESSFUNCTION) */
+#ifdef HAVE_CURLOPT_XFERINFOFUNCTION
+static int proc_xferinfo_handler(void *clientp,
+                                 curl_off_t dltotal,
+                                 curl_off_t dlnow,
+                                 curl_off_t ultotal,
+                                 curl_off_t ulnow) {
+  ruby_curl_easy *rbce = (ruby_curl_easy *)clientp;
+  VALUE proc = rb_easy_get("progress_proc");
+  if (proc == Qnil) {
+    return 0;
+  }
+  VALUE procret;
+  VALUE callargs = rb_ary_new2(5);
+
+  rb_ary_store(callargs, 0, proc);
+  rb_ary_store(callargs, 1, LL2NUM(dltotal));
+  rb_ary_store(callargs, 2, LL2NUM(dlnow));
+  rb_ary_store(callargs, 3, LL2NUM(ultotal));
+  rb_ary_store(callargs, 4, LL2NUM(ulnow));
+
+  struct easy_callback_dispatch_args dispatch_args;
+  dispatch_args.rbce = rbce;
+  dispatch_args.func = call_progress_handler;
+  dispatch_args.arg = callargs;
+  procret = rb_rescue(call_with_easy_callback_active, (VALUE)&dispatch_args, callback_exception, Qnil);
 
   return(((procret == Qfalse) || (procret == Qnil)) ? -1 : 0);
 }
+#endif
 
 static VALUE call_debug_handler(VALUE ary) {
   return rb_funcall(rb_ary_entry(ary, 0), idCall, 2,
-                    rb_ary_entry(ary, 1), // INT2FIX(type),
+                    rb_ary_entry(ary, 1), // INT2NUM(type),
                     rb_ary_entry(ary, 2)); // rb_str_new(data, data_len)
 }
 static int proc_debug_handler(CURL *curl,
                               curl_infotype type,
                               char *data,
                               size_t data_len,
-                              VALUE proc) {
+                              void *clientp) {
+  ruby_curl_easy *rbce = (ruby_curl_easy *)clientp;
+  VALUE proc = rb_easy_get("debug_proc");
+  if (proc == Qnil) {
+    return 0;
+  }
   VALUE callargs = rb_ary_new2(3);
   rb_ary_store(callargs, 0, proc);
-  rb_ary_store(callargs, 1, INT2FIX(type));
+  rb_ary_store(callargs, 1, INT2NUM(type));
   rb_ary_store(callargs, 2, rb_str_new(data, data_len));
-  rb_rescue(call_debug_handler, callargs, callback_exception, Qnil);
+  struct easy_callback_dispatch_args dispatch_args;
+  dispatch_args.rbce = rbce;
+  dispatch_args.func = call_debug_handler;
+  dispatch_args.arg = callargs;
+  rb_rescue(call_with_easy_callback_active, (VALUE)&dispatch_args, callback_exception, Qnil);
   /* no way to indicate to libcurl that we should break out given an exception in the on_debug handler...
    * this means exceptions will be swallowed
    */
-  //rb_funcall(proc, idCall, 2, INT2FIX(type), rb_str_new(data, data_len));
+  //rb_funcall(proc, idCall, 2, INT2NUM(type), rb_str_new(data, data_len));
   return 0;
 }
 
-/* ================== MARK/FREE FUNC ==================*/
-void curl_easy_mark(ruby_curl_easy *rbce) {
-  if (!NIL_P(rbce->opts)) { rb_gc_mark(rbce->opts); }
-  if (!NIL_P(rbce->multi)) { rb_gc_mark(rbce->multi); }
+/* ================== MARK/FREE/SIZE FUNCS ==================*/
+static void curl_easy_mark(void *ptr) {
+  ruby_curl_easy *rbce = (ruby_curl_easy *)ptr;
+  if (rbce) {
+    if (!NIL_P(rbce->opts)) { rb_gc_mark(rbce->opts); }
+    if (!NIL_P(rbce->multi)) { rb_gc_mark(rbce->multi); }
+    if (!NIL_P(rbce->callback_error)) { rb_gc_mark(rbce->callback_error); }
+  }
+}
+
+static void ruby_curl_easy_clear_headers_list(ruby_curl_easy *rbce) {
+  if (!rbce || !rbce->curl_headers) {
+    return;
+  }
+  if (rbce->curl) {
+    curl_easy_setopt(rbce->curl, CURLOPT_HTTPHEADER, NULL);
+  }
+  curl_slist_free_all(rbce->curl_headers);
+  rbce->curl_headers = NULL;
+}
+
+static void ruby_curl_easy_clear_proxy_headers_list(ruby_curl_easy *rbce) {
+  if (!rbce || !rbce->curl_proxy_headers) {
+    return;
+  }
+#ifdef HAVE_CURLOPT_PROXYHEADER
+  if (rbce->curl) {
+    curl_easy_setopt(rbce->curl, CURLOPT_PROXYHEADER, NULL);
+  }
+#endif
+  curl_slist_free_all(rbce->curl_proxy_headers);
+  rbce->curl_proxy_headers = NULL;
+}
+
+static void ruby_curl_easy_clear_ftp_commands_list(ruby_curl_easy *rbce) {
+  if (!rbce || !rbce->curl_ftp_commands) {
+    return;
+  }
+  if (rbce->curl) {
+    curl_easy_setopt(rbce->curl, CURLOPT_QUOTE, NULL);
+  }
+  curl_slist_free_all(rbce->curl_ftp_commands);
+  rbce->curl_ftp_commands = NULL;
+}
+
+static void ruby_curl_easy_clear_resolve_list(ruby_curl_easy *rbce) {
+  if (!rbce || !rbce->curl_resolve) {
+    return;
+  }
+#ifdef HAVE_CURLOPT_RESOLVE
+  if (rbce->curl) {
+    curl_easy_setopt(rbce->curl, CURLOPT_RESOLVE, NULL);
+  }
+#endif
+  curl_slist_free_all(rbce->curl_resolve);
+  rbce->curl_resolve = NULL;
+}
+
+/* Legacy wrapper for external callers */
+void ruby_curl_easy_mark(ruby_curl_easy *rbce) {
+  curl_easy_mark((void *)rbce);
+}
+
+static ruby_curl_multi *ruby_curl_multi_pointer_if_compatible(VALUE multi_val) {
+  if (NIL_P(multi_val) || !RB_TYPE_P(multi_val, T_DATA)) {
+    return NULL;
+  }
+
+#if defined(RTYPEDDATA_P) && defined(RTYPEDDATA_TYPE) && defined(RTYPEDDATA_DATA)
+  if (!RTYPEDDATA_P(multi_val)) {
+    return NULL;
+  }
+
+  if (RTYPEDDATA_TYPE(multi_val) != &ruby_curl_multi_data_type) {
+    return NULL;
+  }
+
+  return (ruby_curl_multi *)RTYPEDDATA_DATA(multi_val);
+#else
+  if (!rb_typeddata_is_kind_of(multi_val, &ruby_curl_multi_data_type)) {
+    return NULL;
+  }
+
+  return DATA_PTR(multi_val);
+#endif
 }
 
 static void ruby_curl_easy_free(ruby_curl_easy *rbce) {
-  if (rbce->curl_headers) {
-    curl_slist_free_all(rbce->curl_headers);
+  if (!rbce) {
+    return;
   }
 
-  if (rbce->curl_ftp_commands) {
-    curl_slist_free_all(rbce->curl_ftp_commands);
+  if (!NIL_P(rbce->multi)) {
+    VALUE multi_val = rbce->multi;
+    ruby_curl_multi *rbcm = ruby_curl_multi_pointer_if_compatible(multi_val);
+
+    rbce->multi = Qnil;
+
+    if (rbcm) {
+      /* Best-effort: ensure the handle is detached from the multi to avoid
+       * libcurl retaining a dangling pointer to a soon-to-be cleaned-up easy
+       * handle. This path runs during GC, so it must not invoke Ruby APIs that
+       * can allocate or raise. */
+      if (rbcm->handle && rbce->curl) {
+        curl_multi_remove_handle(rbcm->handle, rbce->curl);
+      }
+      rb_curl_multi_forget_easy(rbcm, rbce);
+    }
   }
 
+  ruby_curl_easy_clear_headers_list(rbce);
+  ruby_curl_easy_clear_proxy_headers_list(rbce);
+  ruby_curl_easy_clear_ftp_commands_list(rbce);
+  ruby_curl_easy_clear_resolve_list(rbce);
+
   if (rbce->curl) {
+    /* disable any progress or debug events */
+    curl_easy_setopt(rbce->curl, CURLOPT_WRITEFUNCTION, NULL);
+    curl_easy_setopt(rbce->curl, CURLOPT_WRITEDATA, NULL);
+    curl_easy_setopt(rbce->curl, CURLOPT_HEADERFUNCTION, NULL);
+    curl_easy_setopt(rbce->curl, CURLOPT_HEADERDATA, NULL);
+    curl_easy_setopt(rbce->curl, CURLOPT_DEBUGFUNCTION, NULL);
+    curl_easy_setopt(rbce->curl, CURLOPT_DEBUGDATA, NULL);
+    curl_easy_setopt(rbce->curl, CURLOPT_VERBOSE, 0);
+#ifdef HAVE_CURLOPT_XFERINFOFUNCTION
+    curl_easy_setopt(rbce->curl, CURLOPT_XFERINFOFUNCTION, NULL);
+#else
+    curl_easy_setopt(rbce->curl, CURLOPT_PROGRESSFUNCTION, NULL);
+#endif
+    curl_easy_setopt(rbce->curl, CURLOPT_NOPROGRESS, 1);
     curl_easy_cleanup(rbce->curl);
+    rbce->curl = NULL;
+  }
+
+  rbce->self = Qnil;
+}
+
+/* TypedData-compatible free function */
+static void curl_easy_free(void *ptr) {
+  ruby_curl_easy *rbce = (ruby_curl_easy *)ptr;
+  if (rbce) {
+    ruby_curl_easy_free(rbce);
+    free(rbce);
   }
 }
 
-void curl_easy_free(ruby_curl_easy *rbce) {
-  ruby_curl_easy_free(rbce);
-  free(rbce);
+/* Legacy wrapper for external callers (e.g., curb_multi) */
+void ruby_curl_easy_free_wrapper(ruby_curl_easy *rbce) {
+  curl_easy_free((void *)rbce);
 }
 
+static size_t curl_easy_memsize(const void *ptr) {
+  const ruby_curl_easy *rbce = (const ruby_curl_easy *)ptr;
+  size_t size = sizeof(ruby_curl_easy);
+  /* Note: We don't count curl_slist or CURL handle memory as they're
+   * managed by libcurl and would require complex introspection */
+  (void)rbce; /* silence unused warning */
+  return size;
+}
+
+const rb_data_type_t ruby_curl_easy_data_type = {
+  "Curl::Easy",
+  {
+    curl_easy_mark,
+    curl_easy_free,
+    curl_easy_memsize,
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    NULL, /* compact - not needed */
+#endif
+  },
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+  NULL, NULL, /* parent, data */
+  RUBY_TYPED_FREE_IMMEDIATELY
+#endif
+};
+
 
 /* ================= ALLOC METHODS ====================*/
 
 static void ruby_curl_easy_zero(ruby_curl_easy *rbce) {
   rbce->opts = rb_hash_new();
 
+  memset(rbce->err_buf, 0, CURL_ERROR_SIZE);
+
+  rbce->self = Qnil;
   rbce->curl_headers = NULL;
+  rbce->curl_proxy_headers = NULL;
   rbce->curl_ftp_commands = NULL;
+  rbce->curl_resolve = NULL;
 
   /* various-typed opts */
   rbce->local_port = 0;
@@ -236,14 +675,19 @@ static void ruby_curl_easy_zero(ruby_curl_easy *rbce) {
   rbce->proxy_auth_types = 0;
   rbce->max_redirs = -1;
   rbce->timeout = 0;
+  rbce->timeout_ms = 0;
   rbce->connect_timeout = 0;
+  rbce->connect_timeout_ms = 0;
   rbce->dns_cache_timeout = 60;
   rbce->ftp_response_timeout = 0;
   rbce->low_speed_limit = 0;
   rbce->low_speed_time = 0;
+  rbce->max_send_speed_large = 0;
+  rbce->max_recv_speed_large = 0;
   rbce->ssl_version = -1;
   rbce->use_ssl = -1;
   rbce->ftp_filemethod = -1;
+  rbce->http_version = CURL_HTTP_VERSION_NONE;
   rbce->resolve_mode = CURL_IPRESOLVE_WHATEVER;
 
   /* bool opts */
@@ -258,29 +702,47 @@ static void ruby_curl_easy_zero(ruby_curl_easy *rbce) {
   rbce->verbose = 0;
   rbce->multipart_form_post = 0;
   rbce->enable_cookies = 0;
+  rbce->cookielist_engine_enabled = 0;
   rbce->ignore_content_length = 0;
   rbce->callback_active = 0;
+  rbce->callback_error = Qnil;
+  rbce->last_result = 0;
+}
+
+/*
+ * Allocate space for a Curl::Easy instance.
+ */
+static VALUE ruby_curl_easy_allocate(VALUE klass) {
+  ruby_curl_easy *rbce;
+  rbce = ALLOC(ruby_curl_easy);
+  if (!rbce) {
+    rb_raise(rb_eNoMemError, "Failed to allocate memory for Curl::Easy");
+  }
+  rbce->curl = NULL;
+  rbce->opts  = Qnil;
+  rbce->multi = Qnil;
+  ruby_curl_easy_zero(rbce);
+  return TypedData_Wrap_Struct(klass, &ruby_curl_easy_data_type, rbce);
 }
 
 /*
  * call-seq:
- *   Curl::Easy.new                                   => #&lt;Curl::Easy...&gt;
- *   Curl::Easy.new(url = nil)                        => #&lt;Curl::Easy...&gt;
- *   Curl::Easy.new(url = nil) { |self| ... }         => #&lt;Curl::Easy...&gt;
+ *   Curl::Easy.new                                   => #<Curl::Easy...>
+ *   Curl::Easy.new(url = nil)                        => #<Curl::Easy...>
+ *   Curl::Easy.new(url = nil) { |self| ... }         => #<Curl::Easy...>
  *
- * Create a new Curl::Easy instance, optionally supplying the URL.
+ * Initialize a new Curl::Easy instance, optionally supplying the URL.
  * The block form allows further configuration to be supplied before
  * the instance is returned.
  */
-static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
+static VALUE ruby_curl_easy_initialize(int argc, VALUE *argv, VALUE self) {
   CURLcode ecode;
   VALUE url, blk;
-  VALUE new_curl;
   ruby_curl_easy *rbce;
 
   rb_scan_args(argc, argv, "01&", &url, &blk);
 
-  rbce = ALLOC(ruby_curl_easy);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 
   /* handler */
   rbce->curl = curl_easy_init();
@@ -288,32 +750,67 @@ static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
     rb_raise(eCurlErrFailedInit, "Failed to initialize easy handle");
   }
 
-  new_curl = Data_Wrap_Struct(klass, curl_easy_mark, curl_easy_free, rbce);
-
   rbce->multi = Qnil;
   rbce->opts  = Qnil;
 
   ruby_curl_easy_zero(rbce);
+  rbce->self = self;
+
+  curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, &rbce->err_buf);
 
   rb_easy_set("url", url);
 
-  /* set the new_curl pointer to the curl handle */
-  ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)new_curl);
+  /* set the pointer to the curl handle */
+  ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)rbce);
   if (ecode != CURLE_OK) {
     raise_curl_easy_error_exception(ecode);
   }
 
   if (blk != Qnil) {
-    rb_funcall(blk, idCall, 1, new_curl);
+    rb_funcall(blk, idCall, 1, self);
   }
 
-  return new_curl;
+  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;
+    struct curl_slist *new_list;
+    for (tmp = list; tmp; tmp = tmp->next) {
+        new_list = curl_slist_append(dup, tmp->data);
+        if (!new_list) {
+            if (dup) { curl_slist_free_all(dup); }
+            rb_raise(rb_eNoMemError, "Failed to duplicate curl_slist");
+        }
+        dup = new_list;
+    }
+    return dup;
+}
+
+static VALUE duplicate_upload(VALUE upload) {
+  ruby_curl_upload *rbcu, *newrbcu;
+  VALUE new_upload;
+
+  if (NIL_P(upload)) {
+    return Qnil;
+  }
+
+  TypedData_Get_Struct(upload, ruby_curl_upload, &ruby_curl_upload_data_type, rbcu);
+
+  new_upload = ruby_curl_upload_new(cCurlUpload);
+  TypedData_Get_Struct(new_upload, ruby_curl_upload, &ruby_curl_upload_data_type, newrbcu);
+  newrbcu->stream = rbcu->stream;
+  newrbcu->offset = rbcu->offset;
+
+  return new_upload;
 }
 
 /*
  * call-seq:
- *   easy.clone                                       => #&lt;easy clone&gt;
- *   easy.dup                                         => #&lt;easy clone&gt;
+ *   easy.clone                                       => <easy clone>
+ *   easy.dup                                         => <easy clone>
  *
  * Clone this Curl::Easy instance, creating a new instance.
  * This method duplicates the underlying CURL* handle.
@@ -321,15 +818,57 @@ static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
 static VALUE ruby_curl_easy_clone(VALUE self) {
   ruby_curl_easy *rbce, *newrbce;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 
   newrbce = ALLOC(ruby_curl_easy);
+  if (!newrbce) {
+    rb_raise(rb_eNoMemError, "Failed to allocate memory for Curl::Easy clone");
+  }
+  /* 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_ftp_commands = NULL;
+  if (!newrbce->curl) {
+    free(newrbce);
+    rb_raise(rb_eNoMemError, "Failed to duplicate Curl::Easy handle");
+  }
+  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;
 
-  return Data_Wrap_Struct(cCurlEasy, curl_easy_mark, curl_easy_free, newrbce);
+  /* A cloned easy should not retain ownership reference to the original multi. */
+  newrbce->multi = Qnil;
+  newrbce->callback_error = Qnil;
+
+  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);
+
+  if (newrbce->opts != Qnil) {
+    VALUE upload = rb_hash_aref(newrbce->opts, rb_easy_hkey("upload"));
+    if (!NIL_P(upload)) {
+      rb_hash_aset(newrbce->opts, rb_easy_hkey("upload"), duplicate_upload(upload));
+      curl_easy_setopt(newrbce->curl, CURLOPT_READFUNCTION, (curl_read_callback)read_data_handler);
+      curl_easy_setopt(newrbce->curl, CURLOPT_READDATA, newrbce);
+#ifdef HAVE_CURLOPT_SEEKFUNCTION
+      curl_easy_setopt(newrbce->curl, CURLOPT_SEEKFUNCTION, (curl_seek_callback)seek_data_handler);
+#endif
+#ifdef HAVE_CURLOPT_SEEKDATA
+      curl_easy_setopt(newrbce->curl, CURLOPT_SEEKDATA, newrbce);
+#endif
+    }
+  }
+
+  VALUE clone = TypedData_Wrap_Struct(cCurlEasy, &ruby_curl_easy_data_type, newrbce);
+  newrbce->self = clone;
+  curl_easy_setopt(newrbce->curl, CURLOPT_PRIVATE, (void*)newrbce);
+
+  return clone;
 }
 
 /*
@@ -337,14 +876,14 @@ static VALUE ruby_curl_easy_clone(VALUE self) {
  *   easy.close                                      => nil
  *
  * Close the Curl::Easy instance. Any open connections are closed
- * The easy handle is reinitialized.  If a previous multi handle was 
+ * The easy handle is reinitialized.  If a previous multi handle was
  * open it is set to nil and will be cleared after a GC.
  */
 static VALUE ruby_curl_easy_close(VALUE self) {
   CURLcode ecode;
   ruby_curl_easy *rbce;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 
   if (rbce->callback_active) {
     rb_raise(rb_eRuntimeError, "Cannot close an active curl handle within a callback");
@@ -361,9 +900,12 @@ static VALUE ruby_curl_easy_close(VALUE self) {
   rbce->multi = Qnil;
 
   ruby_curl_easy_zero(rbce);
+  rbce->self = self;
+
+  curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, rbce->err_buf);
 
   /* give the new curl handle a reference back to the ruby object */
-  ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)self);
+  ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)rbce);
   if (ecode != CURLE_OK) {
     raise_curl_easy_error_exception(ecode);
   }
@@ -387,7 +929,7 @@ static VALUE ruby_curl_easy_reset(VALUE self) {
   CURLcode ecode;
   ruby_curl_easy *rbce;
   VALUE opts_dup;
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 
   if (rbce->callback_active) {
     rb_raise(rb_eRuntimeError, "Cannot close an active curl handle within a callback");
@@ -395,21 +937,19 @@ static VALUE ruby_curl_easy_reset(VALUE self) {
 
   opts_dup = rb_funcall(rbce->opts, rb_intern("dup"), 0);
 
+  ruby_curl_easy_cleanup(self, rbce);
   curl_easy_reset(rbce->curl);
   ruby_curl_easy_zero(rbce);
+  rbce->self = self;
 
-  /* rest clobbers the private setting, so reset it to self */
-  ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)self);
+  curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, &rbce->err_buf);
+
+  /* reset clobbers the private setting, so reset it to self */
+  ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)rbce);
   if (ecode != CURLE_OK) {
     raise_curl_easy_error_exception(ecode);
   }
 
-  /* Free everything up */
-  if (rbce->curl_headers) {
-    curl_slist_free_all(rbce->curl_headers);
-    rbce->curl_headers = NULL;
-  }
-
   return opts_dup;
 }
 
@@ -462,6 +1002,10 @@ static VALUE ruby_curl_easy_headers_set(VALUE self, VALUE headers) {
   CURB_OBJECT_HSETTER(ruby_curl_easy, headers);
 }
 
+static VALUE ruby_curl_easy_proxy_headers_set(VALUE self, VALUE proxy_headers) {
+  CURB_OBJECT_HSETTER(ruby_curl_easy, proxy_headers);
+}
+
 /*
  * call-seq:
  *   easy.headers                                     => Hash, Array or Str
@@ -471,12 +1015,47 @@ static VALUE ruby_curl_easy_headers_set(VALUE self, VALUE headers) {
 static VALUE ruby_curl_easy_headers_get(VALUE self) {
   ruby_curl_easy *rbce;
   VALUE headers;
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
-  headers = rb_easy_get("headers");//rb_hash_aref(rbce->opts, rb_intern("headers")); 
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  headers = rb_easy_get("headers");//rb_hash_aref(rbce->opts, rb_intern("headers"));
   if (headers == Qnil) { headers = rb_easy_set("headers", rb_hash_new()); }
   return headers;
 }
 
+/*
+ * call-seq:
+ *   easy.proxy_headers = "Header: val"                              => "Header: val"
+ *   easy.proxy_headers = {"Header" => "val" ..., "Header" => "val"} => {"Header: val", ...}
+ *   easy.proxy_headers = ["Header: val" ..., "Header: val"]         => ["Header: val", ...]
+ *
+ *
+ * For example to set a standard or custom header:
+ *
+ *    easy.proxy_headers["MyHeader"] = "myval"
+ *
+ * To remove a standard header (this is useful when removing libcurls default
+ * 'Expect: 100-Continue' header when using HTTP form posts):
+ *
+ *    easy.proxy_headers["Expect"] = ''
+ *
+ * Anything passed to libcurl as a header will be converted to a string during
+ * the perform step.
+ */
+
+/*
+ * call-seq:
+ *   easy.proxy_headers                                     => Hash, Array or Str
+ *
+ * Obtain the custom HTTP proxy_headers for following requests.
+ */
+static VALUE ruby_curl_easy_proxy_headers_get(VALUE self) {
+  ruby_curl_easy *rbce;
+  VALUE proxy_headers;
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  proxy_headers = rb_easy_get("proxy_headers");//rb_hash_aref(rbce->opts, rb_intern("proxy_headers"));
+  if (proxy_headers == Qnil) { proxy_headers = rb_easy_set("proxy_headers", rb_hash_new()); }
+  return proxy_headers;
+}
+
 /*
  * call-seq:
  *   easy.interface                                   => string
@@ -515,7 +1094,16 @@ static VALUE ruby_curl_easy_proxypwd_get(VALUE self) {
  * call-seq:
  *   easy.cookies                                     => "name1=content1; name2=content2;"
  *
- * Obtain the cookies for this Curl::Easy instance.
+ * Obtain the manually set Cookie header string for this Curl::Easy instance.
+ *
+ * Notes:
+ * - This corresponds to libcurl's CURLOPT_COOKIE and only affects the outgoing
+ *   Cookie request header. It does NOT modify the internal libcurl cookie engine
+ *   that stores cookies received via Set-Cookie.
+ * - To inspect or modify cookies stored in the cookie engine, use
+ *   +easy.cookielist+ (getter) and +easy.cookielist=+ or +easy.set(:cookielist, ...)+ (setter).
+ * - To clear a previously set manual Cookie header, assign an empty string.
+ *   Assigning +nil+ currently has no effect.
  */
 static VALUE ruby_curl_easy_cookies_get(VALUE self) {
   CURB_OBJECT_HGETTER(ruby_curl_easy, cookies);
@@ -525,7 +1113,8 @@ static VALUE ruby_curl_easy_cookies_get(VALUE self) {
  * call-seq:
  *   easy.cookiefile                                  => string
  *
- * Obtain the cookiefile file for this Curl::Easy instance.
+ * Obtain the cookiefile path for this Curl::Easy instance (used to load cookies when the
+ * cookie engine is enabled).
  */
 static VALUE ruby_curl_easy_cookiefile_get(VALUE self) {
   CURB_OBJECT_HGETTER(ruby_curl_easy, cookiefile);
@@ -535,7 +1124,8 @@ static VALUE ruby_curl_easy_cookiefile_get(VALUE self) {
  * call-seq:
  *   easy.cookiejar                                   => string
  *
- * Obtain the cookiejar file to use for this Curl::Easy instance.
+ * Obtain the cookiejar path for this Curl::Easy instance (used to persist cookies when the
+ * cookie engine is enabled).
  */
 static VALUE ruby_curl_easy_cookiejar_get(VALUE self) {
   CURB_OBJECT_HGETTER(ruby_curl_easy, cookiejar);
@@ -684,57 +1274,81 @@ static VALUE ruby_curl_easy_useragent_get(VALUE self) {
 /*
  * call-seq:
  *   easy.post_body = "some=form%20data&to=send"      => string or nil
- * 
+ *
  * Sets the POST body of this Curl::Easy instance.  This is expected to be
  * URL encoded; no additional processing or encoding is done on the string.
  * The content-type header will be set to application/x-www-form-urlencoded.
- * 
+ *
  * This is handy if you want to perform a POST against a Curl::Multi instance.
  */
-static VALUE ruby_curl_easy_post_body_set(VALUE self, VALUE post_body) {
+static VALUE ruby_curl_easy_post_body_set_with_mode(VALUE self, VALUE post_body, int force_http_get_on_nil) {
   ruby_curl_easy *rbce;
   CURL *curl;
-  
+
+  VALUE body_str;
+  VALUE retained_body_str;
   char *data;
   long len;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
-  
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+
   curl = rbce->curl;
-  
+
   if ( post_body == Qnil ) {
     rb_easy_del("postdata_buffer");
-    curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);
-    
-  } else {  
+    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, NULL);
+    curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, 0);
+    if (force_http_get_on_nil) {
+      curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);
+    }
+
+  } else {
     if (rb_type(post_body) == T_STRING) {
-      data = StringValuePtr(post_body);
-      len = RSTRING_LEN(post_body);
+      body_str = post_body;
     }
     else if (rb_respond_to(post_body, rb_intern("to_s"))) {
-      VALUE str_body = rb_funcall(post_body, rb_intern("to_s"), 0);
-      data = StringValuePtr(str_body);
-      len = RSTRING_LEN(post_body);
+      body_str = rb_funcall(post_body, rb_intern("to_s"), 0);
     }
     else {
       rb_raise(rb_eRuntimeError, "post data must respond_to .to_s");
     }
-  
-    // Store the string, since it has to hang around for the duration of the 
+
+    StringValue(body_str);
+
+    // Store the string, since it has to hang around for the duration of the
     // request.  See CURLOPT_POSTFIELDS in the libcurl docs.
-    //rbce->postdata_buffer = post_body;
-    rb_easy_set("postdata_buffer", post_body);
-  
+#ifdef HAVE_CURLOPT_COPYPOSTFIELDS
+    /*
+     * libcurl copies the bytes immediately for COPYPOSTFIELDS, so retain a
+     * matching Ruby snapshot for post_body instead of the caller's mutable
+     * source string.
+     */
+    retained_body_str = rb_str_dup(body_str);
+#else
+    retained_body_str = body_str;
+#endif
+    data = StringValuePtr(retained_body_str);
+    len = RSTRING_LEN(retained_body_str);
+    rb_easy_set("postdata_buffer", retained_body_str);
+
     curl_easy_setopt(curl, CURLOPT_POST, 1);
-    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
     curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, len);
-    
+#ifdef HAVE_CURLOPT_COPYPOSTFIELDS
+    curl_easy_setopt(curl, CURLOPT_COPYPOSTFIELDS, data);
+#else
+    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
+#endif
+
     return post_body;
   }
-  
+
   return Qnil;
 }
 
+static VALUE ruby_curl_easy_post_body_set(VALUE self, VALUE post_body) {
+  return ruby_curl_easy_post_body_set_with_mode(self, post_body, 1);
+}
+
 /*
  * call-seq:
  *   easy.post_body                                  => string or nil
@@ -748,7 +1362,7 @@ static VALUE ruby_curl_easy_post_body_get(VALUE self) {
 /*
  * call-seq:
  *   easy.put_data = data                             => ""
- * 
+ *
  * Points this Curl::Easy instance to data to be uploaded via PUT.  This
  * sets the request to a PUT type request - useful if you want to PUT via
  * a multi handle.
@@ -757,26 +1371,15 @@ static VALUE ruby_curl_easy_put_data_set(VALUE self, VALUE data) {
   ruby_curl_easy *rbce;
   CURL *curl;
   VALUE upload;
+  VALUE upload_stream = data;
   VALUE headers;
+  VALUE infile_size = Qnil;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
-
-  upload = ruby_curl_upload_new(cCurlUpload);
-  ruby_curl_upload_stream_set(upload,data);
-
-  curl = rbce->curl;
-  rb_easy_set("upload", upload); /* keep the upload object alive as long as
-                                    the easy handle is active or until the upload
-                                    is complete or terminated... */
-
-  curl_easy_setopt(curl, CURLOPT_NOBODY, 0);
-  curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
-  curl_easy_setopt(curl, CURLOPT_READFUNCTION, (curl_read_callback)read_data_handler);
-  curl_easy_setopt(curl, CURLOPT_READDATA, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 
-  /* 
-   * we need to set specific headers for the PUT to work... so
-   * convert the internal headers structure to a HASH if one is set
+  /*
+   * Validate and prepare Ruby-visible state before mutating the CURL handle.
+   * Several branches below can raise (header type, stat, size, to_s).
    */
   if (!rb_easy_nil("headers")) {
     if (rb_easy_type_check("headers", T_ARRAY) || rb_easy_type_check("headers", T_STRING)) {
@@ -784,43 +1387,80 @@ static VALUE ruby_curl_easy_put_data_set(VALUE self, VALUE data) {
     }
   }
 
-  // exit fast if the payload is empty
-  if (NIL_P(data)) { return data; }
+  if (!NIL_P(data) && !rb_respond_to(data, rb_intern("read"))) {
+    if (rb_respond_to(data, rb_intern("to_s"))) {
+      upload_stream = rb_obj_as_string(data);
+    } else {
+      rb_raise(rb_eRuntimeError, "PUT data must respond to read or to_s");
+    }
+  }
 
   headers = rb_easy_get("headers");
-  if( headers == Qnil ) { 
+  if( headers == Qnil ) {
     headers = rb_hash_new();
   }
 
-  if (rb_respond_to(data, rb_intern("read"))) {
-    VALUE stat = rb_funcall(data, rb_intern("stat"), 0);
-    if( stat && rb_hash_aref(headers, rb_str_new2("Content-Length")) == Qnil) {
+  if (!NIL_P(data) && rb_respond_to(data, rb_intern("read"))) {
+    VALUE stat = Qnil;
+    if (rb_respond_to(data, rb_intern("stat"))) {
+      stat = rb_funcall(data, rb_intern("stat"), 0);
+    }
+    if(!NIL_P(stat) && stat != Qfalse && rb_hash_aref(headers, rb_str_new2("Content-Length")) == Qnil) {
       VALUE size;
       if( rb_hash_aref(headers, rb_str_new2("Expect")) == Qnil ) {
         rb_hash_aset(headers, rb_str_new2("Expect"), rb_str_new2(""));
       }
       size = rb_funcall(stat, rb_intern("size"), 0);
-      curl_easy_setopt(curl, CURLOPT_INFILESIZE, FIX2LONG(size));
+      infile_size = size;
     }
     else if( rb_hash_aref(headers, rb_str_new2("Content-Length")) == Qnil && rb_hash_aref(headers, rb_str_new2("Transfer-Encoding")) == Qnil ) {
       rb_hash_aset(headers, rb_str_new2("Transfer-Encoding"), rb_str_new2("chunked"));
     }
     else if( rb_hash_aref(headers, rb_str_new2("Content-Length")) ) {
       VALUE size = rb_funcall(rb_hash_aref(headers, rb_str_new2("Content-Length")), rb_intern("to_i"), 0);
-      curl_easy_setopt(curl, CURLOPT_INFILESIZE, FIX2LONG(size));
+      infile_size = size;
     }
   }
-  else if (rb_respond_to(data, rb_intern("to_s"))) {
-    curl_easy_setopt(curl, CURLOPT_INFILESIZE, RSTRING_LEN(data));
+  else if (!NIL_P(data) && rb_respond_to(data, rb_intern("to_s"))) {
+    infile_size = LONG2NUM(RSTRING_LEN(upload_stream));
     if( rb_hash_aref(headers, rb_str_new2("Expect")) == Qnil ) {
       rb_hash_aset(headers, rb_str_new2("Expect"), rb_str_new2(""));
     }
   }
+  else if (NIL_P(data)) {
+    /* Preserve legacy nil handling: configure an upload with no payload. */
+  }
   else {
     rb_raise(rb_eRuntimeError, "PUT data must respond to read or to_s");
   }
   rb_easy_set("headers",headers);
 
+  upload = ruby_curl_upload_new(cCurlUpload);
+  ruby_curl_upload_stream_set(upload, upload_stream);
+
+  curl = rbce->curl;
+  rb_easy_set("upload", upload); /* keep the upload object alive as long as
+                                    the easy handle is active or until the upload
+                                    is complete or terminated... */
+
+  curl_easy_setopt(curl, CURLOPT_NOBODY, 0);
+  curl_easy_setopt(curl, CURLOPT_POST, 0);
+  curl_easy_setopt(curl, CURLOPT_POSTFIELDS, NULL);
+  curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, 0);
+  curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
+  curl_easy_setopt(curl, CURLOPT_READFUNCTION, (curl_read_callback)read_data_handler);
+#ifdef HAVE_CURLOPT_SEEKFUNCTION
+  curl_easy_setopt(curl, CURLOPT_SEEKFUNCTION, (curl_seek_callback)seek_data_handler);
+#endif
+  curl_easy_setopt(curl, CURLOPT_READDATA, rbce);
+#ifdef HAVE_CURLOPT_SEEKDATA
+  curl_easy_setopt(curl, CURLOPT_SEEKDATA, rbce);
+#endif
+
+  if (!NIL_P(infile_size)) {
+    curl_easy_setopt(curl, CURLOPT_INFILESIZE, NUM2LONG(infile_size));
+  }
+
   // if we made it this far, all should be well.
   return data;
 }
@@ -829,20 +1469,47 @@ static VALUE ruby_curl_easy_put_data_set(VALUE self, VALUE data) {
  * call-seq:
  *   easy.ftp_commands = ["CWD /", "MKD directory"]   => ["CWD /", ...]
  *
- * Explicitly sets the list of commands to execute on the FTP server when calling perform
+ * Explicitly sets the list of commands to execute on the FTP server when calling perform.
+ *
+ * NOTE:
+ * - This maps to libcurl CURLOPT_QUOTE; it sends commands on the control connection.
+ * - Do not include data-transfer commands like LIST/NLST/RETR/STOR here. libcurl does not
+ *   parse PASV/EPSV replies from QUOTE commands and will not establish the required data
+ *   connection. For directory listings, set CURLOPT_DIRLISTONLY (via `easy.set(:dirlistonly, true)`)
+ *   and request an FTP directory URL (e.g. "ftp://host/path/") so libcurl manages PASV/EPSV
+ *   and the data connection for you.
  */
 static VALUE ruby_curl_easy_ftp_commands_set(VALUE self, VALUE ftp_commands) {
   CURB_OBJECT_HSETTER(ruby_curl_easy, ftp_commands);
 }
 
 /*
- * call-seq
+ * call-seq:
  *   easy.ftp_commands                                => array or nil
  */
 static VALUE ruby_curl_easy_ftp_commands_get(VALUE self) {
   CURB_OBJECT_HGETTER(ruby_curl_easy, ftp_commands);
 }
 
+/*
+ * call-seq:
+ *   easy.resolve = [ "example.com:80:127.0.0.1" ]   => [ "example.com:80:127.0.0.1" ]
+ *
+ * Set the resolve list to statically resolve hostnames to IP addresses,
+ * bypassing DNS for matching hostname/port combinations.
+ */
+static VALUE ruby_curl_easy_resolve_set(VALUE self, VALUE resolve) {
+  CURB_OBJECT_HSETTER(ruby_curl_easy, resolve);
+}
+
+/*
+ * call-seq:
+ *   easy.resolve                                => array or nil
+ */
+static VALUE ruby_curl_easy_resolve_get(VALUE self) {
+  CURB_OBJECT_HGETTER(ruby_curl_easy, resolve);
+}
+
 /* ================== IMMED ATTRS ==================*/
 
 /*
@@ -951,16 +1618,16 @@ static VALUE ruby_curl_easy_proxy_type_get(VALUE self) {
   (!strncmp("digest",node,6)) ? CURLAUTH_DIGEST : \
   (!strncmp("gssnegotiate",node,12)) ? CURLAUTH_GSSNEGOTIATE : \
   (!strncmp("ntlm",node,4)) ? CURLAUTH_NTLM : \
-  (!strncmp("any",node,3)) ? CURLAUTH_ANY : \
-  (!strncmp("anysafe",node,7)) ? CURLAUTH_ANYSAFE : 0
-#else 
+  (!strncmp("anysafe",node,7)) ? CURLAUTH_ANYSAFE : \
+  (!strncmp("any",node,3)) ? CURLAUTH_ANY : 0
+#else
 #define CURL_HTTPAUTH_STR_TO_NUM(node) \
   (!strncmp("basic",node,5)) ? CURLAUTH_BASIC : \
   (!strncmp("digest",node,6)) ? CURLAUTH_DIGEST : \
   (!strncmp("gssnegotiate",node,12)) ? CURLAUTH_GSSNEGOTIATE : \
   (!strncmp("ntlm",node,4)) ? CURLAUTH_NTLM : \
-  (!strncmp("any",node,3)) ? CURLAUTH_ANY : \
-  (!strncmp("anysafe",node,7)) ? CURLAUTH_ANYSAFE : 0
+  (!strncmp("anysafe",node,7)) ? CURLAUTH_ANYSAFE : \
+  (!strncmp("any",node,3)) ? CURLAUTH_ANY : 0
 #endif
 /*
  * call-seq:
@@ -974,21 +1641,22 @@ static VALUE ruby_curl_easy_proxy_type_get(VALUE self) {
 static VALUE ruby_curl_easy_http_auth_types_set(int argc, VALUE *argv, VALUE self) {//VALUE self, VALUE http_auth_types) {
   ruby_curl_easy *rbce;
   VALUE args_ary;
-  int i, len;
+  long i, len;
   char* node = NULL;
-  long mask = 0x000000;
+  long mask = 0;
 
   rb_scan_args(argc, argv, "*", &args_ary);
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 
-  len = (int)RARRAY_LEN(args_ary);
+  len = RARRAY_LEN(args_ary);
 
-  if (len == 1 && (TYPE(rb_ary_entry(args_ary,0)) == T_FIXNUM || rb_ary_entry(args_ary,0) == Qnil)) {
-    if (rb_ary_entry(args_ary,0) == Qnil) { 
+  if (len == 1 && (rb_ary_entry(args_ary,0) == Qnil || TYPE(rb_ary_entry(args_ary,0)) == T_FIXNUM ||
+        TYPE(rb_ary_entry(args_ary,0)) == T_BIGNUM)) {
+    if (rb_ary_entry(args_ary,0) == Qnil) {
       rbce->http_auth_types = 0;
     }
     else {
-      rbce->http_auth_types = NUM2INT(rb_ary_entry(args_ary,0));
+      rbce->http_auth_types = NUM2LONG(rb_ary_entry(args_ary,0));
     }
   }
   else {
@@ -1001,7 +1669,7 @@ static VALUE ruby_curl_easy_http_auth_types_set(int argc, VALUE *argv, VALUE sel
     }
     rbce->http_auth_types = mask;
   }
-  return INT2NUM(rbce->http_auth_types);
+  return LONG2NUM(rbce->http_auth_types);
 }
 
 /*
@@ -1066,7 +1734,7 @@ static VALUE ruby_curl_easy_max_redirects_get(VALUE self) {
 
 /*
  * call-seq:
- *   easy.timeout = fixnum or nil                     => fixnum or nil
+ *   easy.timeout = float, fixnum or nil              => numeric
  *
  * Set the maximum time in seconds that you allow the libcurl transfer
  * operation to take. Normally, name lookups can take a considerable time
@@ -1075,20 +1743,77 @@ static VALUE ruby_curl_easy_max_redirects_get(VALUE self) {
  *
  * Set to nil (or zero) to disable timeout (it will then only timeout
  * on the system's internal timeouts).
+ *
+ * Uses timeout_ms internally instead of timeout because it allows for
+ * better precision and libcurl will use the last set value when both
+ * timeout and timeout_ms are set.
+ *
  */
-static VALUE ruby_curl_easy_timeout_set(VALUE self, VALUE timeout) {
-  CURB_IMMED_SETTER(ruby_curl_easy, timeout, 0);
+static VALUE ruby_curl_easy_timeout_set(VALUE self, VALUE timeout_s) {
+  ruby_curl_easy *rbce;
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+
+  if (Qnil == timeout_s || NUM2DBL(timeout_s) <= 0.0) {
+    rbce->timeout_ms = 0;
+  } else {
+    rbce->timeout_ms = (unsigned long)(NUM2DBL(timeout_s) * 1000);
+  }
+
+  return DBL2NUM(rbce->timeout_ms / 1000.0);
 }
 
 /*
  * call-seq:
- *   easy.timeout                                     => fixnum or nil
+ *   easy.timeout                                     => numeric
  *
  * Obtain the maximum time in seconds that you allow the libcurl transfer
  * operation to take.
+ *
+ * Uses timeout_ms internally instead of timeout.
+ *
+ */
+static VALUE ruby_curl_easy_timeout_get(VALUE self) {
+  ruby_curl_easy *rbce;
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  return DBL2NUM(rbce->timeout_ms / 1000.0);
+}
+
+/*
+ * call-seq:
+ *   easy.timeout_ms = fixnum or nil                  => fixnum or nil
+ *
+ * Set the maximum time in milliseconds that you allow the libcurl transfer
+ * operation to take. Normally, name lookups can take a considerable time
+ * and limiting operations to less than a few minutes risk aborting
+ * perfectly normal operations.
+ *
+ * Set to nil (or zero) to disable timeout (it will then only timeout
+ * on the system's internal timeouts).
+ */
+static VALUE ruby_curl_easy_timeout_ms_set(VALUE self, VALUE timeout_ms) {
+  ruby_curl_easy *rbce;
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+
+  if (Qnil == timeout_ms || NUM2DBL(timeout_ms) <= 0.0) {
+    rbce->timeout_ms = 0;
+  } else {
+    rbce->timeout_ms = NUM2ULONG(timeout_ms);
+  }
+
+  return ULONG2NUM(rbce->timeout_ms);
+}
+
+/*
+ * call-seq:
+ *   easy.timeout_ms                                  => fixnum or nil
+ *
+ * Obtain the maximum time in milliseconds that you allow the libcurl transfer
+ * operation to take.
  */
-static VALUE ruby_curl_easy_timeout_get(VALUE self, VALUE timeout) {
-  CURB_IMMED_GETTER(ruby_curl_easy, timeout, 0);
+static VALUE ruby_curl_easy_timeout_ms_get(VALUE self) {
+  ruby_curl_easy *rbce;
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  return LONG2NUM(rbce->timeout_ms);
 }
 
 /*
@@ -1113,10 +1838,36 @@ static VALUE ruby_curl_easy_connect_timeout_set(VALUE self, VALUE connect_timeou
  * Obtain the maximum time in seconds that you allow the connection to the
  * server to take.
  */
-static VALUE ruby_curl_easy_connect_timeout_get(VALUE self, VALUE connect_timeout) {
+static VALUE ruby_curl_easy_connect_timeout_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, connect_timeout, 0);
 }
 
+/*
+ * call-seq:
+ *   easy.connect_timeout_ms = fixnum or nil          => fixnum or nil
+ *
+ * Set the maximum time in milliseconds that you allow the connection to the
+ * server to take. This only limits the connection phase, once it has
+ * connected, this option is of no more use.
+ *
+ * Set to nil (or zero) to disable connection timeout (it will then only
+ * timeout on the system's internal timeouts).
+ */
+static VALUE ruby_curl_easy_connect_timeout_ms_set(VALUE self, VALUE connect_timeout_ms) {
+  CURB_IMMED_SETTER(ruby_curl_easy, connect_timeout_ms, 0);
+}
+
+/*
+ * call-seq:
+ *   easy.connect_timeout_ms                          => fixnum or nil
+ *
+ * Obtain the maximum time in milliseconds that you allow the connection to the
+ * server to take.
+ */
+static VALUE ruby_curl_easy_connect_timeout_ms_get(VALUE self) {
+  CURB_IMMED_GETTER(ruby_curl_easy, connect_timeout_ms, 0);
+}
+
 /*
  * call-seq:
  *   easy.dns_cache_timeout = fixnum or nil           => fixnum or nil
@@ -1136,7 +1887,7 @@ static VALUE ruby_curl_easy_dns_cache_timeout_set(VALUE self, VALUE dns_cache_ti
  *
  * Obtain the dns cache timeout in seconds.
  */
-static VALUE ruby_curl_easy_dns_cache_timeout_get(VALUE self, VALUE dns_cache_timeout) {
+static VALUE ruby_curl_easy_dns_cache_timeout_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, dns_cache_timeout, -1);
 }
 
@@ -1163,7 +1914,7 @@ static VALUE ruby_curl_easy_ftp_response_timeout_set(VALUE self, VALUE ftp_respo
  *
  * Obtain the maximum time that libcurl will wait for FTP command responses.
  */
-static VALUE ruby_curl_easy_ftp_response_timeout_get(VALUE self, VALUE ftp_response_timeout) {
+static VALUE ruby_curl_easy_ftp_response_timeout_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, ftp_response_timeout, 0);
 }
 
@@ -1186,7 +1937,7 @@ static VALUE ruby_curl_easy_low_speed_limit_set(VALUE self, VALUE low_speed_limi
  * Obtain the minimum transfer speed over +low_speed+time+ below which the
  * transfer will be aborted.
  */
-static VALUE ruby_curl_easy_low_speed_limit_get(VALUE self, VALUE low_speed_limit) {
+static VALUE ruby_curl_easy_low_speed_limit_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, low_speed_limit, 0);
 }
 
@@ -1208,10 +1959,50 @@ static VALUE ruby_curl_easy_low_speed_time_set(VALUE self, VALUE low_speed_time)
  * Obtain the time that the transfer should be below +low_speed_limit+ for
  * the library to abort it.
  */
-static VALUE ruby_curl_easy_low_speed_time_get(VALUE self, VALUE low_speed_time) {
+static VALUE ruby_curl_easy_low_speed_time_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, low_speed_time, 0);
 }
 
+/*
+ * call-seq:
+ *   easy.max_send_speed_large = fixnum or nil        => fixnum or nil
+ *
+ * Set the maximal sending transfer speed (in bytes per second) 
+ */
+static VALUE ruby_curl_easy_max_send_speed_large_set(VALUE self, VALUE max_send_speed_large) {
+  CURB_IMMED_SETTER(ruby_curl_easy, max_send_speed_large, 0);
+}
+
+/*
+ * call-seq:
+ *   easy.max_send_speed_large = fixnum or nil        => fixnum or nil
+ *
+ * Get the maximal sending transfer speed (in bytes per second) 
+ */
+static VALUE ruby_curl_easy_max_send_speed_large_get(VALUE self) {
+  CURB_IMMED_GETTER(ruby_curl_easy, max_send_speed_large, 0);
+}
+
+/*
+ * call-seq:
+ *   easy.max_recv_speed_large = fixnum or nil        => fixnum or nil
+ *
+ * Set the maximal receiving transfer speed (in bytes per second) 
+ */
+static VALUE ruby_curl_easy_max_recv_speed_large_set(VALUE self, VALUE max_recv_speed_large) {
+  CURB_IMMED_SETTER(ruby_curl_easy, max_recv_speed_large, 0);
+}
+
+/*
+ * call-seq:
+ *   easy.max_recv_speed_large = fixnum or nil        => fixnum or nil
+ *
+ * Get the maximal receiving transfer speed (in bytes per second) 
+ */
+static VALUE ruby_curl_easy_max_recv_speed_large_get(VALUE self) {
+  CURB_IMMED_GETTER(ruby_curl_easy, max_recv_speed_large, 0);
+}
+
 /*
  * call-seq:
  *   easy.username = string                           => string
@@ -1219,7 +2010,7 @@ static VALUE ruby_curl_easy_low_speed_time_get(VALUE self, VALUE low_speed_time)
  * Set the HTTP Authentication username.
  */
 static VALUE ruby_curl_easy_username_set(VALUE self, VALUE username) {
-#if HAVE_CURLOPT_USERNAME
+#ifdef HAVE_CURLOPT_USERNAME
   CURB_OBJECT_HSETTER(ruby_curl_easy, username);
 #else
   return Qnil;
@@ -1229,11 +2020,11 @@ static VALUE ruby_curl_easy_username_set(VALUE self, VALUE username) {
 /*
  * call-seq:
  *   easy.username                                    => string
- * 
+ *
  * Get the current username
  */
-static VALUE ruby_curl_easy_username_get(VALUE self, VALUE username) {
-#if HAVE_CURLOPT_USERNAME
+static VALUE ruby_curl_easy_username_get(VALUE self) {
+#ifdef HAVE_CURLOPT_USERNAME
   CURB_OBJECT_HGETTER(ruby_curl_easy, username);
 #else
   return Qnil;
@@ -1247,7 +2038,7 @@ static VALUE ruby_curl_easy_username_get(VALUE self, VALUE username) {
  * Set the HTTP Authentication password.
  */
 static VALUE ruby_curl_easy_password_set(VALUE self, VALUE password) {
-#if HAVE_CURLOPT_PASSWORD
+#ifdef HAVE_CURLOPT_PASSWORD
   CURB_OBJECT_HSETTER(ruby_curl_easy, password);
 #else
   return Qnil;
@@ -1257,11 +2048,11 @@ static VALUE ruby_curl_easy_password_set(VALUE self, VALUE password) {
 /*
  * call-seq:
  *   easy.password                                    => string
- * 
+ *
  * Get the current password
  */
-static VALUE ruby_curl_easy_password_get(VALUE self, VALUE password) {
-#if HAVE_CURLOPT_PASSWORD
+static VALUE ruby_curl_easy_password_get(VALUE self) {
+#ifdef HAVE_CURLOPT_PASSWORD
   CURB_OBJECT_HGETTER(ruby_curl_easy, password);
 #else
   return Qnil;
@@ -1273,8 +2064,16 @@ static VALUE ruby_curl_easy_password_get(VALUE self, VALUE password) {
  *   easy.ssl_version = value                         => fixnum or nil
  *
  * Sets the version of SSL/TLS that libcurl will attempt to use. Valid
- * options are Curl::CURL_SSLVERSION_TLSv1, Curl::CURL_SSLVERSION::SSLv2,
- * Curl::CURL_SSLVERSION_SSLv3 and Curl::CURL_SSLVERSION_DEFAULT
+ * options are:
+ *
+ *   Curl::CURL_SSLVERSION_DEFAULT
+ *   Curl::CURL_SSLVERSION_TLSv1 (TLS 1.x)
+ *   Curl::CURL_SSLVERSION_SSLv2
+ *   Curl::CURL_SSLVERSION_SSLv3
+ *   Curl::CURL_SSLVERSION_TLSv1_0
+ *   Curl::CURL_SSLVERSION_TLSv1_1
+ *   Curl::CURL_SSLVERSION_TLSv1_2
+ *   Curl::CURL_SSLVERSION_TLSv1_3
  */
 static VALUE ruby_curl_easy_ssl_version_set(VALUE self, VALUE ssl_version) {
   CURB_IMMED_SETTER(ruby_curl_easy, ssl_version, -1);
@@ -1286,14 +2085,14 @@ static VALUE ruby_curl_easy_ssl_version_set(VALUE self, VALUE ssl_version) {
  *
  * Get the version of SSL/TLS that libcurl will attempt to use.
  */
-static VALUE ruby_curl_easy_ssl_version_get(VALUE self, VALUE ssl_version) {
+static VALUE ruby_curl_easy_ssl_version_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, ssl_version, -1);
 }
 
 /*
  * call-seq:
  *   easy.use_ssl = value                             => fixnum or nil
- * 
+ *
  * Ensure libcurl uses SSL for FTP connections. Valid options are Curl::CURL_USESSL_NONE,
  * Curl::CURL_USESSL_TRY, Curl::CURL_USESSL_CONTROL, and Curl::CURL_USESSL_ALL.
  */
@@ -1307,7 +2106,7 @@ static VALUE ruby_curl_easy_use_ssl_set(VALUE self, VALUE use_ssl) {
  *
  * Get the desired level for using SSL on FTP connections.
  */
-static VALUE ruby_curl_easy_use_ssl_get(VALUE self, VALUE use_ssl) {
+static VALUE ruby_curl_easy_use_ssl_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, use_ssl, -1);
 }
 
@@ -1323,12 +2122,12 @@ static VALUE ruby_curl_easy_ftp_filemethod_set(VALUE self, VALUE ftp_filemethod)
 }
 
 /*
- * call-seq
+ * call-seq:
  *   easy.ftp_filemethod                              => fixnum
  *
  * Get the configuration for how libcurl will reach files on the server.
  */
-static VALUE ruby_curl_easy_ftp_filemethod_get(VALUE self, VALUE ftp_filemethod) {
+static VALUE ruby_curl_easy_ftp_filemethod_get(VALUE self) {
   CURB_IMMED_GETTER(ruby_curl_easy, ftp_filemethod, -1);
 }
 
@@ -1486,7 +2285,7 @@ static VALUE ruby_curl_easy_use_netrc_q(VALUE self) {
  */
 static VALUE ruby_curl_easy_autoreferer_set(VALUE self, VALUE autoreferer) {
   ruby_curl_easy *rbce;
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 
   if (Qtrue == autoreferer) {
     curl_easy_setopt(rbce->curl, CURLOPT_AUTOREFERER, 1);
@@ -1587,7 +2386,12 @@ static VALUE ruby_curl_easy_multipart_form_post_q(VALUE self) {
  *   easy.enable_cookies = boolean                    => boolean
  *
  * Configure whether the libcurl cookie engine is enabled for this Curl::Easy
- * instance.
+ * instance. When enabled, cookies received via Set-Cookie are stored by libcurl
+ * and automatically sent on subsequent matching requests. Use +easy.cookiefile+
+ * to load cookies and +easy.cookiejar+ to persist them.
+ *
+ * This setting is independent from the manual Cookie header set via +easy.cookies+.
+ * The manual header is additive and can be cleared by assigning an empty string.
  */
 static VALUE ruby_curl_easy_enable_cookies_set(VALUE self, VALUE enable_cookies)
 {
@@ -1637,9 +2441,10 @@ static VALUE ruby_curl_easy_ignore_content_length_q(VALUE self) {
  */
 static VALUE ruby_curl_easy_resolve_mode(VALUE self) {
   ruby_curl_easy *rbce;
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  unsigned short rm;
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 
-  unsigned short rm = rbce->resolve_mode;
+  rm = rbce->resolve_mode;
 
   switch(rm) {
     case CURL_IPRESOLVE_V4:
@@ -1668,9 +2473,10 @@ static VALUE ruby_curl_easy_resolve_mode_set(VALUE self, VALUE resolve_mode) {
     return Qnil;
   } else {
     ruby_curl_easy *rbce;
-    Data_Get_Struct(self, ruby_curl_easy, rbce);
+    ID resolve_mode_id;
+    TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 
-    ID resolve_mode_id = rb_to_id(resolve_mode);
+    resolve_mode_id = rb_to_id(resolve_mode);
 
     if (resolve_mode_id == rb_intern("auto")) {
       rbce->resolve_mode = CURL_IPRESOLVE_WHATEVER;
@@ -1688,12 +2494,52 @@ static VALUE ruby_curl_easy_resolve_mode_set(VALUE self, VALUE resolve_mode) {
   }
 }
 
+/*
+ * call-seq:
+ *   easy.http_version = Curl::HTTP_1_1               => Curl::HTTP_1_1
+ *
+ * Force libcurl to use a specific HTTP protocol version. By default libcurl
+ * negotiates the highest version supported by both peers. Supported constants
+ * include Curl::HTTP_NONE, Curl::HTTP_1_0, Curl::HTTP_1_1, Curl::HTTP_2_0,
+ * Curl::HTTP_2TLS, and Curl::HTTP_2_PRIOR_KNOWLEDGE (when provided by libcurl).
+ */
+static VALUE ruby_curl_easy_http_version_set(VALUE self, VALUE version) {
+  ruby_curl_easy *rbce;
+  long http_version;
+
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+
+  if (NIL_P(version)) {
+    http_version = CURL_HTTP_VERSION_NONE;
+  } else {
+    http_version = NUM2LONG(version);
+  }
+
+  rbce->http_version = http_version;
+
+  return version;
+}
+
+/*
+ * call-seq:
+ *   easy.http_version                                => integer
+ *
+ * Returns the HTTP protocol version currently configured.
+ */
+static VALUE ruby_curl_easy_http_version_get(VALUE self) {
+  ruby_curl_easy *rbce;
+
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+
+  return LONG2NUM(rbce->http_version);
+}
+
 
 /* ================= EVENT PROCS ================== */
 
 /*
  * call-seq:
- *   easy.on_body { |body_data| ... }                 => &lt;old handler&gt;
+ *   easy.on_body { |body_data| ... }                 => <old handler>
  *
  * Assign or remove the +on_body+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1712,7 +2558,7 @@ static VALUE ruby_curl_easy_on_body_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_success { |easy| ... }                   => &lt;old handler&gt;
+ *   easy.on_success { |easy| ... }                   => <old handler>
  *
  * Assign or remove the +on_success+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1727,7 +2573,7 @@ static VALUE ruby_curl_easy_on_success_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_failure {|easy,code| ... }               => &lt;old handler&gt;
+ *   easy.on_failure {|easy,code| ... }               => <old handler>
  *
  * Assign or remove the +on_failure+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1742,13 +2588,13 @@ static VALUE ruby_curl_easy_on_failure_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *  easy.on_missing {|easy,code| ... }                => &lt;old handler;&gt;
+ *  easy.on_missing {|easy,code| ... }                => <old handler;>
  *
  *  Assign or remove the on_missing handler for this Curl::Easy instance.
  *  To remove a previously-supplied handler, call this method with no attached
  *  block.
  *
- *  The +on_missing+ handler is called when request is finished with a 
+ *  The +on_missing+ handler is called when request is finished with a
  *  status of 40x
  */
 static VALUE ruby_curl_easy_on_missing_set(int argc, VALUE *argv, VALUE self) {
@@ -1757,13 +2603,13 @@ static VALUE ruby_curl_easy_on_missing_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *  easy.on_redirect {|easy,code| ... }                => &lt;old handler;&gt;
+ *  easy.on_redirect {|easy,code| ... }                => <old handler;>
  *
  *  Assign or remove the on_redirect handler for this Curl::Easy instance.
  *  To remove a previously-supplied handler, call this method with no attached
  *  block.
  *
- *  The +on_redirect+ handler is called when request is finished with a 
+ *  The +on_redirect+ handler is called when request is finished with a
  *  status of 30x
  */
 static VALUE ruby_curl_easy_on_redirect_set(int argc, VALUE *argv, VALUE self) {
@@ -1772,7 +2618,7 @@ static VALUE ruby_curl_easy_on_redirect_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_complete {|easy| ... }                   => &lt;old handler&gt;
+ *   easy.on_complete {|easy| ... }                   => <old handler>
  *
  * Assign or remove the +on_complete+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1786,7 +2632,7 @@ static VALUE ruby_curl_easy_on_complete_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_header { |header_data| ... }             => &lt;old handler&gt;
+ *   easy.on_header { |header_data| ... }             => <old handler>
  *
  * Assign or remove the +on_header+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1802,7 +2648,7 @@ static VALUE ruby_curl_easy_on_header_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_progress { |dl_total, dl_now, ul_total, ul_now| ... } => &lt;old handler&gt;
+ *   easy.on_progress { |dl_total, dl_now, ul_total, ul_now| ... } => <old handler>
  *
  * Assign or remove the +on_progress+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1823,7 +2669,7 @@ static VALUE ruby_curl_easy_on_progress_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_debug { |type, data| ... }               => &lt;old handler&gt;
+ *   easy.on_debug { |type, data| ... }               => <old handler>
  *
  * Assign or remove the +on_debug+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1848,12 +2694,12 @@ static VALUE ruby_curl_easy_on_debug_set(int argc, VALUE *argv, VALUE self) {
 /***********************************************
  * This is an rb_iterate callback used to set up http headers.
  */
-static VALUE cb_each_http_header(VALUE header, VALUE wrap) {
+static VALUE cb_each_http_header(VALUE header, VALUE wrap, int _c, const VALUE *_ptr, VALUE unused) {
   struct curl_slist **list;
-  Data_Get_Struct(wrap, struct curl_slist *, list);
-
   VALUE header_str = Qnil;
 
+  TypedData_Get_Struct(wrap, struct curl_slist *, &curl_slist_ptr_type, list);
+
   //rb_p(header);
 
   if (rb_type(header) == T_ARRAY) {
@@ -1862,34 +2708,100 @@ static VALUE cb_each_http_header(VALUE header, VALUE wrap) {
 
     name = rb_obj_as_string(rb_ary_entry(header, 0));
     value = rb_obj_as_string(rb_ary_entry(header, 1));
+    if (rb_str_strlen(value) == 0) { // removing the header e.g. Accept: with nothing trailing should remove it see: https://curl.se/libcurl/c/CURLOPT_HTTPHEADER.html
+      header_str = rb_str_plus(name, rb_str_new2(":"));
+    } else {
+      // This is a bit inefficient, but we don't want to be modifying
+      // the actual values in the original hash.
+      header_str = rb_str_plus(name, rb_str_new2(": "));
+      header_str = rb_str_plus(header_str, value);
+    }
+  } else {
+    header_str = rb_obj_as_string(header);
+  }
+
+  //rb_p(header_str);
+
+  struct curl_slist *new_list = curl_slist_append(*list, StringValuePtr(header_str));
+  if (!new_list) {
+    rb_raise(rb_eNoMemError, "Failed to append to header list");
+  }
+  *list = new_list;
+  return header_str;
+}
+
+/***********************************************
+ * This is an rb_iterate callback used to set up http proxy headers.
+ */
+static VALUE cb_each_http_proxy_header(VALUE proxy_header, VALUE wrap, int _c, const VALUE *_ptr, VALUE unused) {
+  struct curl_slist **list;
+  VALUE proxy_header_str = Qnil;
+
+  TypedData_Get_Struct(wrap, struct curl_slist *, &curl_slist_ptr_type, list);
+
+  //rb_p(proxy_header);
+
+  if (rb_type(proxy_header) == T_ARRAY) {
+    // we're processing a hash, proxy header is [name, val]
+    VALUE name, value;
+
+    name = rb_obj_as_string(rb_ary_entry(proxy_header, 0));
+    value = rb_obj_as_string(rb_ary_entry(proxy_header, 1));
 
     // This is a bit inefficient, but we don't want to be modifying
     // the actual values in the original hash.
-    header_str = rb_str_plus(name, rb_str_new2(": "));
-    header_str = rb_str_plus(header_str, value);
+    proxy_header_str = rb_str_plus(name, rb_str_new2(": "));
+    proxy_header_str = rb_str_plus(proxy_header_str, value);
   } else {
-    header_str = rb_obj_as_string(header);
+    proxy_header_str = rb_obj_as_string(proxy_header);
   }
 
   //rb_p(header_str);
 
-  *list = curl_slist_append(*list, StringValuePtr(header_str));
-  return header_str;
+  struct curl_slist *new_list = curl_slist_append(*list, StringValuePtr(proxy_header_str));
+  if (!new_list) {
+    rb_raise(rb_eNoMemError, "Failed to append to proxy header list");
+  }
+  *list = new_list;
+  return proxy_header_str;
 }
 
 /***********************************************
  * This is an rb_iterate callback used to set up ftp commands.
  */
-static VALUE cb_each_ftp_command(VALUE ftp_command, VALUE wrap) {
+static VALUE cb_each_ftp_command(VALUE ftp_command, VALUE wrap, int _c, const VALUE *_ptr, VALUE unused) {
   struct curl_slist **list;
-  Data_Get_Struct(wrap, struct curl_slist *, list);
+  VALUE ftp_command_string;
+  TypedData_Get_Struct(wrap, struct curl_slist *, &curl_slist_ptr_type, list);
 
-  VALUE ftp_command_string = rb_obj_as_string(ftp_command);
-  *list = curl_slist_append(*list, StringValuePtr(ftp_command));
+  ftp_command_string = rb_obj_as_string(ftp_command);
+  struct curl_slist *new_list = curl_slist_append(*list, StringValuePtr(ftp_command_string));
+  if (!new_list) {
+    rb_raise(rb_eNoMemError, "Failed to append to FTP command list");
+  }
+  *list = new_list;
 
   return ftp_command_string;
 }
 
+/***********************************************
+ * This is an rb_iterate callback used to set up the resolve list.
+ */
+static VALUE cb_each_resolve(VALUE resolve, VALUE wrap, int _c, const VALUE *_ptr, VALUE unused) {
+  struct curl_slist **list;
+  VALUE resolve_string;
+  TypedData_Get_Struct(wrap, struct curl_slist *, &curl_slist_ptr_type, list);
+
+  resolve_string = rb_obj_as_string(resolve);
+  struct curl_slist *new_list = curl_slist_append(*list, StringValuePtr(resolve_string));
+  if (!new_list) {
+    rb_raise(rb_eNoMemError, "Failed to append to resolve list");
+  }
+  *list = new_list;
+
+  return resolve_string;
+}
+
 /***********************************************
  *
  * Setup a connection
@@ -1901,16 +2813,18 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
   CURL *curl;
   VALUE url, _url = rb_easy_get("url");
   struct curl_slist **hdrs = &(rbce->curl_headers);
+  struct curl_slist **phdrs = &(rbce->curl_proxy_headers);
   struct curl_slist **cmds = &(rbce->curl_ftp_commands);
+  struct curl_slist **rslv = &(rbce->curl_resolve);
 
   curl = rbce->curl;
+  rbce->callback_error = Qnil;
 
   if (_url == Qnil) {
     rb_raise(eCurlErrError, "No URL supplied");
   }
 
   url = rb_check_string_type(_url);
-
   curl_easy_setopt(curl, CURLOPT_URL, StringValuePtr(url));
 
   // network stuff and auth
@@ -1920,7 +2834,7 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
     curl_easy_setopt(curl, CURLOPT_INTERFACE, NULL);
   }
 
-#if HAVE_CURLOPT_USERNAME == 1 && HAVE_CURLOPT_PASSWORD == 1
+#if defined(HAVE_CURLOPT_USERNAME) && defined(HAVE_CURLOPT_PASSWORD)
   if (!rb_easy_nil("username")) {
     curl_easy_setopt(curl, CURLOPT_USERNAME, rb_easy_get_str("username"));
   } else {
@@ -1936,7 +2850,7 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
 
   if (!rb_easy_nil("userpwd")) {
     curl_easy_setopt(curl, CURLOPT_USERPWD, rb_easy_get_str("userpwd"));
-#if HAVE_CURLOPT_USERNAME == 1
+#if defined(HAVE_CURLOPT_USERNAME) && defined(HAVE_CURLOPT_PASSWORD)
   } else if (rb_easy_nil("username") && rb_easy_nil("password")) { /* don't set this even to NULL if we have set username and password */
 #else
   } else {
@@ -1956,6 +2870,14 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
     curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, rb_easy_get_str("proxypwd"));
   }
 
+#ifdef HAVE_CURLOPT_NOPROXY
+  if (rb_easy_nil("noproxy")) {
+    curl_easy_setopt(curl, CURLOPT_NOPROXY, NULL);
+  } else {
+    curl_easy_setopt(curl, CURLOPT_NOPROXY, rb_easy_get_str("noproxy"));
+  }
+#endif
+
   // body/header procs
   if (!rb_easy_nil("body_proc")) {
     curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)&proc_data_handler_body);
@@ -1963,9 +2885,9 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
     /* clear out the body_data if it was set */
     rb_easy_del("body_data");
   } else {
-    VALUE body_buffer = rb_easy_set("body_data", rb_str_buf_new(32768));
-    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)&default_data_handler);
-    curl_easy_setopt(curl, CURLOPT_WRITEDATA, body_buffer);
+    rb_easy_set("body_data", rb_str_buf_new(32768));
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)&default_body_handler);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, rbce);
   }
 
   if (!rb_easy_nil("header_proc")) {
@@ -1974,9 +2896,9 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
     /* clear out the header_data if it was set */
     rb_easy_del("header_data");
   } else {
-    VALUE header_buffer = rb_easy_set("header_data", rb_str_buf_new(16384));
-    curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, (curl_write_callback)&default_data_handler);
-    curl_easy_setopt(curl, CURLOPT_HEADERDATA, header_buffer);
+    rb_easy_set("header_data", rb_str_buf_new(16384));
+    curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, (curl_write_callback)&default_header_handler);
+    curl_easy_setopt(curl, CURLOPT_HEADERDATA, rbce);
   }
 
   /* encoding */
@@ -1986,21 +2908,31 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
 
   // progress and debug procs
   if (!rb_easy_nil("progress_proc")) {
+#ifdef HAVE_CURLOPT_XFERINFOFUNCTION
+    curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, &proc_xferinfo_handler);
+    curl_easy_setopt(curl, CURLOPT_XFERINFODATA, rbce);
+#else
     curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, (curl_progress_callback)&proc_progress_handler);
-    curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, rb_easy_get("progress_proc"));
+    curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, rbce);
+#endif
     curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
   } else {
     curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1);
+#ifdef HAVE_CURLOPT_XFERINFOFUNCTION
+    curl_easy_setopt(curl, CURLOPT_XFERINFODATA, rbce);
+#else
+    curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, rbce);
+#endif
   }
 
   if (!rb_easy_nil("debug_proc")) {
     curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, (curl_debug_callback)&proc_debug_handler);
-    curl_easy_setopt(curl, CURLOPT_DEBUGDATA, rb_easy_get("debug_proc"));
+    curl_easy_setopt(curl, CURLOPT_DEBUGDATA, rbce);
     curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
   } else {
     // have to remove handler to re-enable standard verbosity
     curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, NULL);
-    curl_easy_setopt(curl, CURLOPT_DEBUGDATA, NULL);
+    curl_easy_setopt(curl, CURLOPT_DEBUGDATA, rbce);
     curl_easy_setopt(curl, CURLOPT_VERBOSE, rbce->verbose);
   }
 
@@ -2008,7 +2940,14 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
 
   curl_easy_setopt(curl, CURLOPT_HEADER, rbce->header_in_body);
   curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, rbce->follow_location);
+#if LIBCURL_VERSION_NUM == 0x081000
+  /* Work around 8.16.0 regression that clamps -1 (infinite) to zero */
+  if (rbce->max_redirs >= 0) {
+    curl_easy_setopt(curl, CURLOPT_MAXREDIRS, rbce->max_redirs);
+  }
+#else
   curl_easy_setopt(curl, CURLOPT_MAXREDIRS, rbce->max_redirs);
+#endif
 
   curl_easy_setopt(curl, CURLOPT_HTTPPROXYTUNNEL, rbce->proxy_tunnel);
   curl_easy_setopt(curl, CURLOPT_FILETIME, rbce->fetch_file_time);
@@ -2023,13 +2962,22 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
 
   curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, rbce->unrestricted_auth);
 
-  curl_easy_setopt(curl, CURLOPT_TIMEOUT, rbce->timeout);
+#ifdef HAVE_CURLOPT_TIMEOUT_MS
+  curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, rbce->timeout_ms);
+#endif
+
   curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, rbce->connect_timeout);
+#ifdef HAVE_CURLOPT_CONNECTTIMEOUT_MS
+  curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT_MS, rbce->connect_timeout_ms);
+#endif
   curl_easy_setopt(curl, CURLOPT_DNS_CACHE_TIMEOUT, rbce->dns_cache_timeout);
 
   curl_easy_setopt(curl, CURLOPT_IGNORE_CONTENT_LENGTH, rbce->ignore_content_length);
 
   curl_easy_setopt(curl, CURLOPT_IPRESOLVE, rbce->resolve_mode);
+#if HAVE_CURLOPT_HTTP_VERSION
+  curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, rbce->http_version);
+#endif
 
 
 #if LIBCURL_VERSION_NUM >= 0x070a08
@@ -2043,6 +2991,9 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
   curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, rbce->low_speed_limit);
   curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, rbce->low_speed_time);
 
+  curl_easy_setopt(curl, CURLOPT_MAX_RECV_SPEED_LARGE, rbce->max_recv_speed_large);
+  curl_easy_setopt(curl, CURLOPT_MAX_SEND_SPEED_LARGE, rbce->max_send_speed_large);
+
   // Set up localport / proxy port
   // FIXME these won't get returned to default if they're unset Ruby
   if (rbce->proxy_port > 0) {
@@ -2075,29 +3026,27 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
 #endif
   }
 
-  if (rbce->http_auth_types > 0) {
+  /*
+   * NOTE: we used to set CURLAUTH_ANY but see: http://curl.haxx.se/mail/lib-2015-06/0033.html
+   */
+  if (rbce->http_auth_types != 0) {
 #if LIBCURL_VERSION_NUM >= 0x070a06
     curl_easy_setopt(curl, CURLOPT_HTTPAUTH, rbce->http_auth_types);
-  } else {
-    curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
 #else
     rb_warn("Installed libcurl is too old to support http_auth_types");
 #endif
   }
 
-  if (rbce->proxy_auth_types > 0) {
+  if (rbce->proxy_auth_types != 0) {
 #if LIBCURL_VERSION_NUM >= 0x070a07
     curl_easy_setopt(curl, CURLOPT_PROXYAUTH, rbce->proxy_auth_types);
-  } else {
-    curl_easy_setopt(curl, CURLOPT_PROXYAUTH, CURLAUTH_ANY);
 #else
     rb_warn("Installed libcurl is too old to support proxy_auth_types");
 #endif
   }
 
-  /* Set up HTTP cookie handling if necessary
-     FIXME this may not get disabled if it's enabled, the disabled again from ruby.
-     */
+  /* Set up HTTP cookie handling if necessary */
+  /* Enable/attach cookie engine if requested, or implicitly via COOKIELIST usage */
   if (rbce->enable_cookies) {
     if (!rb_easy_nil("cookiejar")) {
       curl_easy_setopt(curl, CURLOPT_COOKIEJAR, rb_easy_get_str("cookiejar"));
@@ -2108,6 +3057,9 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
     } else {
       curl_easy_setopt(curl, CURLOPT_COOKIEFILE, ""); /* "" = magic to just enable */
     }
+  } else if (rbce->cookielist_engine_enabled) {
+    /* Ensure cookie engine is enabled even if enable_cookies? is false. */
+    curl_easy_setopt(curl, CURLOPT_COOKIEFILE, "");
   }
 
   if (!rb_easy_nil("cookies")) {
@@ -2150,7 +3102,7 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
     rb_warn("libcurl is not configured with SSL support");
   }
 #endif
-  
+
   if (rbce->ftp_filemethod > 0) {
     curl_easy_setopt(curl, CURLOPT_FTP_FILEMETHOD, rbce->ftp_filemethod);
   }
@@ -2165,11 +3117,15 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
 
   if (!rb_easy_nil("headers")) {
     if (rb_easy_type_check("headers", T_ARRAY) || rb_easy_type_check("headers", T_HASH)) {
-      VALUE wrap = Data_Wrap_Struct(rb_cObject, 0, 0, hdrs);
-      rb_iterate(rb_each, rb_easy_get("headers"), cb_each_http_header, wrap);
+      VALUE wrap = TypedData_Wrap_Struct(rb_cObject, &curl_slist_ptr_type, hdrs);
+      rb_block_call(rb_easy_get("headers"), rb_intern("each"), 0, NULL, cb_each_http_header, wrap);
     } else {
       VALUE headers_str = rb_obj_as_string(rb_easy_get("headers"));
-      *hdrs = curl_slist_append(*hdrs, StringValuePtr(headers_str));
+      struct curl_slist *new_list = curl_slist_append(*hdrs, StringValuePtr(headers_str));
+      if (!new_list) {
+        rb_raise(rb_eNoMemError, "Failed to append to headers list");
+      }
+      *hdrs = new_list;
     }
 
     if (*hdrs) {
@@ -2177,11 +3133,34 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
     }
   }
 
+#ifdef HAVE_CURLOPT_PROXYHEADER
+  /* Setup HTTP proxy headers if necessary */
+  curl_easy_setopt(curl, CURLOPT_PROXYHEADER, NULL);   // XXX: maybe we shouldn't be clearing this?
+
+  if (!rb_easy_nil("proxy_headers")) {
+    if (rb_easy_type_check("proxy_headers", T_ARRAY) || rb_easy_type_check("proxy_headers", T_HASH)) {
+      VALUE wrap = TypedData_Wrap_Struct(rb_cObject, &curl_slist_ptr_type, phdrs);
+      rb_block_call(rb_easy_get("proxy_headers"), rb_intern("each"), 0, NULL, cb_each_http_proxy_header, wrap);
+    } else {
+      VALUE proxy_headers_str = rb_obj_as_string(rb_easy_get("proxy_headers"));
+      struct curl_slist *new_list = curl_slist_append(*phdrs, StringValuePtr(proxy_headers_str));
+      if (!new_list) {
+        rb_raise(rb_eNoMemError, "Failed to append to proxy headers list");
+      }
+      *phdrs = new_list;
+    }
+
+    if (*phdrs) {
+      curl_easy_setopt(curl, CURLOPT_PROXYHEADER, *phdrs);
+    }
+  }
+#endif
+
   /* Setup FTP commands if necessary */
   if (!rb_easy_nil("ftp_commands")) {
     if (rb_easy_type_check("ftp_commands", T_ARRAY)) {
-      VALUE wrap = Data_Wrap_Struct(rb_cObject, 0, 0, cmds);
-      rb_iterate(rb_each, rb_easy_get("ftp_commands"), cb_each_ftp_command, wrap);
+      VALUE wrap = TypedData_Wrap_Struct(rb_cObject, &curl_slist_ptr_type, cmds);
+      rb_block_call(rb_easy_get("ftp_commands"), rb_intern("each"), 0, NULL, cb_each_ftp_command, wrap);
     }
 
     if (*cmds) {
@@ -2189,38 +3168,108 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
     }
   }
 
+#ifdef HAVE_CURLOPT_RESOLVE
+  /* Setup resolve list if necessary */
+  if (!rb_easy_nil("resolve")) {
+    if (rb_easy_type_check("resolve", T_ARRAY)) {
+      VALUE wrap = TypedData_Wrap_Struct(rb_cObject, &curl_slist_ptr_type, rslv);
+      rb_block_call(rb_easy_get("resolve"), rb_intern("each"), 0, NULL, cb_each_resolve, wrap);
+    } else {
+      VALUE resolve_str = rb_obj_as_string(rb_easy_get("resolve"));
+      struct curl_slist *new_list = curl_slist_append(*rslv, StringValuePtr(resolve_str));
+      if (!new_list) {
+        rb_raise(rb_eNoMemError, "Failed to append to resolve list");
+      }
+      *rslv = new_list;
+    }
+
+    if (*rslv) {
+      curl_easy_setopt(curl, CURLOPT_RESOLVE, *rslv);
+    }
+  }
+#endif
+
   return Qnil;
 }
 /***********************************************
  *
  * Clean up a connection
  *
- * Always returns Qtrue.
+ * Always returns Qnil.
  */
 VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce ) {
 
   CURL *curl = rbce->curl;
   struct curl_slist *ftp_commands;
+  struct curl_slist *resolve;
+
+  ruby_curl_easy_clear_headers_list(rbce);
+  ruby_curl_easy_clear_proxy_headers_list(rbce);
 
-  /* Free everything up */
-  if (rbce->curl_headers) {
-    curl_slist_free_all(rbce->curl_headers);
-    rbce->curl_headers = NULL;
+  ftp_commands = rbce->curl_ftp_commands;
+  if (ftp_commands) {
+    ruby_curl_easy_clear_ftp_commands_list(rbce);
+  }
+
+  resolve = rbce->curl_resolve;
+  if (resolve) {
+    ruby_curl_easy_clear_resolve_list(rbce);
+  }
+
+  /* clean up a PUT request's curl options. */
+  if (!rb_easy_nil("upload")) {
+    rb_easy_del("upload"); // set the upload object to Qnil to let the GC clean up
+    curl_easy_setopt(curl, CURLOPT_UPLOAD, 0);
+    curl_easy_setopt(curl, CURLOPT_READFUNCTION, NULL);
+    curl_easy_setopt(curl, CURLOPT_READDATA, NULL);
+#ifdef HAVE_CURLOPT_SEEKFUNCTION
+    curl_easy_setopt(curl, CURLOPT_SEEKFUNCTION, NULL);
+#endif
+#ifdef HAVE_CURLOPT_SEEKDATA
+    curl_easy_setopt(curl, CURLOPT_SEEKDATA, NULL);
+#endif
+    curl_easy_setopt(curl, CURLOPT_INFILESIZE, 0);
   }
 
-  ftp_commands = rbce->curl_ftp_commands;
-  if (ftp_commands) {
-    curl_slist_free_all(ftp_commands);
-    rbce->curl_ftp_commands = NULL;
-  }
+  // set values on cleanup to nil
+  //rb_easy_del("multi");
+
+  return Qnil;
+}
+
+struct easy_perform_request_restore_args {
+  VALUE self;
+  CURL *curl;
+  ruby_curl_easy *rbce;
+  int clear_customrequest;
+  int clear_nobody;
+  int clear_postfields;
+};
+
+static VALUE perform_with_request_restore_body(VALUE argp) {
+  struct easy_perform_request_restore_args *args = (struct easy_perform_request_restore_args *)argp;
+  return rb_funcall(args->self, rb_intern("perform"), 0);
+}
+
+static VALUE perform_with_request_restore_ensure(VALUE argp) {
+  struct easy_perform_request_restore_args *args = (struct easy_perform_request_restore_args *)argp;
 
-  /* clean up a PUT request's curl options. */
-  if (!rb_easy_nil("upload")) {
-    rb_easy_del("upload"); // set the upload object to Qnil to let the GC clean up
-    curl_easy_setopt(curl, CURLOPT_UPLOAD, 0);
-    curl_easy_setopt(curl, CURLOPT_READFUNCTION, NULL);
-    curl_easy_setopt(curl, CURLOPT_READDATA, NULL);
-    curl_easy_setopt(curl, CURLOPT_INFILESIZE, 0);
+  if (args->curl) {
+    if (args->clear_nobody) {
+      curl_easy_setopt(args->curl, CURLOPT_NOBODY, 0L);
+    }
+    if (args->clear_customrequest) {
+      curl_easy_setopt(args->curl, CURLOPT_CUSTOMREQUEST, NULL);
+    }
+    if (args->clear_postfields) {
+      curl_easy_setopt(args->curl, CURLOPT_POST, 0L);
+      curl_easy_setopt(args->curl, CURLOPT_POSTFIELDS, NULL);
+      curl_easy_setopt(args->curl, CURLOPT_POSTFIELDSIZE, 0L);
+      curl_easy_setopt(args->curl, CURLOPT_HTTPGET, 1L);
+      if (args->rbce && !NIL_P(args->rbce->opts)) {
+        rb_hash_delete(args->rbce->opts, rb_easy_hkey("postdata_buffer"));
+      }
+    }
   }
 
   return Qnil;
@@ -2234,14 +3283,33 @@ static VALUE ruby_curl_easy_perform_verb_str(VALUE self, const char *verb) {
   CURL *curl;
   VALUE retval;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   curl = rbce->curl;
 
+  memset(rbce->err_buf, 0, CURL_ERROR_SIZE);
+
+  /* Use method override and adjust related options for special verbs. */
   curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, verb);
 
-  retval = rb_funcall(self, rb_intern("perform"), 0);
+  /* For HEAD, ensure no body is requested/downloaded, as some servers
+   * include a Content-Length header which should not cause libcurl to
+   * wait for a body that will never arrive. */
+  int is_head = (verb && (
+#ifdef _WIN32
+    _stricmp(verb, "HEAD") == 0
+#else
+    strcasecmp(verb, "HEAD") == 0
+#endif
+  ));
+  if (is_head) {
+    curl_easy_setopt(curl, CURLOPT_NOBODY, 1L);
+    curl_easy_setopt(curl, CURLOPT_HTTPGET, 0L);
+    curl_easy_setopt(curl, CURLOPT_POST, 0L);
+  }
 
-  curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, NULL);
+  struct easy_perform_request_restore_args restore_args = { self, curl, rbce, 1, is_head, 0 };
+  retval = rb_ensure(perform_with_request_restore_body, (VALUE)&restore_args,
+                     perform_with_request_restore_ensure, (VALUE)&restore_args);
 
   return retval;
 }
@@ -2267,6 +3335,76 @@ static VALUE ruby_curl_easy_perform_verb(VALUE self, VALUE verb) {
   }
 }
 
+static VALUE call_easy_perform(VALUE self) {
+  return rb_funcall(self, rb_intern("perform"), 0);
+}
+
+struct easy_form_perform_args {
+  VALUE self;
+  CURL *curl;
+  int argc;
+  VALUE *argv;
+  struct curl_httppost *first;
+  struct curl_httppost *last;
+  int clear_customrequest;
+  int form_set_on_curl;
+};
+
+static void append_multipart_form_argument(VALUE arg,
+                                           struct curl_httppost **first,
+                                           struct curl_httppost **last) {
+  if (rb_obj_is_instance_of(arg, cCurlPostField)) {
+    append_to_form(arg, first, last);
+  } else if (rb_type(arg) == T_ARRAY) {
+    long j, argv_len = RARRAY_LEN(arg);
+    for (j = 0; j < argv_len; ++j) {
+      VALUE field = rb_ary_entry(arg, j);
+      if (rb_obj_is_instance_of(field, cCurlPostField)) {
+        append_to_form(field, first, last);
+      } 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");
+  }
+}
+
+static VALUE build_and_perform_multipart_form(VALUE argp) {
+  struct easy_form_perform_args *args = (struct easy_form_perform_args *)argp;
+  int i;
+
+  for (i = 0; i < args->argc; i++) {
+    append_multipart_form_argument(args->argv[i], &args->first, &args->last);
+  }
+
+  curl_easy_setopt(args->curl, CURLOPT_POST, 0);
+  curl_easy_setopt(args->curl, CURLOPT_HTTPPOST, args->first);
+  args->form_set_on_curl = 1;
+
+  return call_easy_perform(args->self);
+}
+
+static VALUE ensure_free_form_post(VALUE argp) {
+  struct easy_form_perform_args *args = (struct easy_form_perform_args *)argp;
+  if (args->curl) {
+    if (args->form_set_on_curl) {
+      curl_easy_setopt(args->curl, CURLOPT_HTTPPOST, NULL);
+    }
+    if (args->clear_customrequest) {
+      curl_easy_setopt(args->curl, CURLOPT_CUSTOMREQUEST, NULL);
+    }
+  }
+  if (args->first) {
+    curl_formfree(args->first);
+    args->first = NULL;
+  }
+  args->last = NULL;
+  return Qnil;
+}
+
 /*
  * call-seq:
  *   easy.http_post("url=encoded%20form%20data;and=so%20on") => true
@@ -2294,45 +3432,21 @@ static VALUE ruby_curl_easy_perform_verb(VALUE self, VALUE verb) {
 static VALUE ruby_curl_easy_perform_post(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);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   curl = rbce->curl;
 
+  memset(rbce->err_buf, 0, CURL_ERROR_SIZE);
+
   curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, NULL);
 
   if (rbce->multipart_form_post) {
     VALUE ret;
-    struct curl_httppost *first = NULL, *last = NULL;
-
-    // Make the multipart form
-    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) {
-        // see: https://github.com/rvanlieshout/curb/commit/8bcdefddc0162484681ebd1a92d52a642666a445
-        int c = 0, argv_len = (int)RARRAY_LEN(argv[i]);
-        for (; c < argv_len; ++c) {
-          if (rb_obj_is_instance_of(rb_ary_entry(argv[i],c), cCurlPostField)) {
-            append_to_form(rb_ary_entry(argv[i],c), &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;
-      }
-    }
-
-    curl_easy_setopt(curl, CURLOPT_POST, 0);
-    curl_easy_setopt(curl, CURLOPT_HTTPPOST, first);
-    ret = rb_funcall(self, rb_intern("perform"), 0);
-    curl_formfree(first);
+    struct easy_form_perform_args perform_args = { self, curl, argc, argv, NULL, NULL, 0, 0 };
+    ret = rb_ensure(build_and_perform_multipart_form, (VALUE)&perform_args, ensure_free_form_post, (VALUE)&perform_args);
 
     return ret;
   } else {
@@ -2353,7 +3467,65 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
         ruby_curl_easy_post_body_set(self, post_body);
       }
 
-      return rb_funcall(self, rb_intern("perform"), 0);
+      struct easy_perform_request_restore_args restore_args = { self, curl, rbce, 1, 0, 0 };
+      return rb_ensure(perform_with_request_restore_body, (VALUE)&restore_args,
+                       perform_with_request_restore_ensure, (VALUE)&restore_args);
+    }
+  }
+}
+
+/*
+ * 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;
+  VALUE args_ary;
+
+  rb_scan_args(argc, argv, "*", &args_ary);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, 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 easy_form_perform_args perform_args = { self, curl, argc, argv, NULL, NULL, 1, 0 };
+    ret = rb_ensure(build_and_perform_multipart_form, (VALUE)&perform_args, ensure_free_form_post, (VALUE)&perform_args);
+    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);
+      }
+      struct easy_perform_request_restore_args restore_args = { self, curl, rbce, 1, 0, 1 };
+      return rb_ensure(perform_with_request_restore_body, (VALUE)&restore_args,
+                       perform_with_request_restore_ensure, (VALUE)&restore_args);
     }
   }
 }
@@ -2366,17 +3538,47 @@ 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;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  rb_scan_args(argc, argv, "*", &args_ary);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   curl = rbce->curl;
 
-  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");
 
-  return rb_funcall(self, rb_intern("perform"), 0);
+  /* 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 easy_form_perform_args perform_args = { self, curl, argc, argv, NULL, NULL, 1, 0 };
+    ret = rb_ensure(build_and_perform_multipart_form, (VALUE)&perform_args, ensure_free_form_post, (VALUE)&perform_args);
+    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);
+    }
+  }
+  struct easy_perform_request_restore_args restore_args = { self, curl, rbce, 1, 0, 0 };
+  return rb_ensure(perform_with_request_restore_body, (VALUE)&restore_args,
+                   perform_with_request_restore_ensure, (VALUE)&restore_args);
 }
 
 
@@ -2391,6 +3593,10 @@ static VALUE ruby_curl_easy_perform_put(VALUE self, VALUE data) {
  * your own body handler, this string will be empty.
  */
 static VALUE ruby_curl_easy_body_str_get(VALUE self) {
+  /*
+     TODO: can we force_encoding on the return here if we see charset=utf-8 in the content-type header?
+     Content-Type: application/json; charset=utf-8
+  */
   CURB_OBJECT_HGETTER(ruby_curl_easy, body_data);
 }
 
@@ -2421,7 +3627,7 @@ static VALUE ruby_curl_easy_last_effective_url_get(VALUE self) {
   ruby_curl_easy *rbce;
   char* url;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_EFFECTIVE_URL, &url);
 
   if (url && url[0]) {    // curl returns empty string if none
@@ -2444,7 +3650,7 @@ static VALUE ruby_curl_easy_response_code_get(VALUE self) {
   ruby_curl_easy *rbce;
   long code;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 #ifdef HAVE_CURLINFO_RESPONSE_CODE
   curl_easy_getinfo(rbce->curl, CURLINFO_RESPONSE_CODE, &code);
 #else
@@ -2467,8 +3673,8 @@ static VALUE ruby_curl_easy_response_code_get(VALUE self) {
 static VALUE ruby_curl_easy_primary_ip_get(VALUE self) {
   ruby_curl_easy *rbce;
   char* ip;
-  
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_PRIMARY_IP, &ip);
 
   if (ip && ip[0]) {    // curl returns empty string if none
@@ -2489,7 +3695,7 @@ static VALUE ruby_curl_easy_http_connect_code_get(VALUE self) {
   ruby_curl_easy *rbce;
   long code;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_HTTP_CONNECTCODE, &code);
 
   return LONG2NUM(code);
@@ -2517,13 +3723,13 @@ static VALUE ruby_curl_easy_file_time_get(VALUE self) {
   ruby_curl_easy *rbce;
   long time;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_FILETIME, &time);
 
   return LONG2NUM(time);
 #else
   rb_warn("Installed libcurl is too old to support file_time");
-  return INT2FIX(0);
+  return LONG2NUM(0);
 #endif
 }
 
@@ -2538,7 +3744,7 @@ static VALUE ruby_curl_easy_total_time_get(VALUE self) {
   ruby_curl_easy *rbce;
   double time;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_TOTAL_TIME, &time);
 
   return rb_float_new(time);
@@ -2555,7 +3761,7 @@ static VALUE ruby_curl_easy_name_lookup_time_get(VALUE self) {
   ruby_curl_easy *rbce;
   double time;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_NAMELOOKUP_TIME, &time);
 
   return rb_float_new(time);
@@ -2572,12 +3778,35 @@ static VALUE ruby_curl_easy_connect_time_get(VALUE self) {
   ruby_curl_easy *rbce;
   double time;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_CONNECT_TIME, &time);
 
   return rb_float_new(time);
 }
 
+/*
+ * call-seq:
+ *   easy.app_connect_time                         => float
+ *
+ * Retrieve the time, in seconds, it took from the start until the SSL/SSH
+ * connect/handshake to the remote host was completed. This time is most often
+ * very near to the pre transfer time, except for cases such as HTTP
+ * pipelining where the pretransfer time can be delayed due to waits in line
+ * for the pipeline and more.
+ */
+#if defined(HAVE_CURLINFO_APPCONNECT_TIME)
+static VALUE ruby_curl_easy_app_connect_time_get(VALUE self) {
+  ruby_curl_easy *rbce;
+  double time;
+
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  curl_easy_getinfo(rbce->curl, CURLINFO_APPCONNECT_TIME, &time);
+
+  return rb_float_new(time);
+}
+#endif
+
+
 /*
  * call-seq:
  *   easy.pre_transfer_time                           => float
@@ -2591,7 +3820,7 @@ static VALUE ruby_curl_easy_pre_transfer_time_get(VALUE self) {
   ruby_curl_easy *rbce;
   double time;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_PRETRANSFER_TIME, &time);
 
   return rb_float_new(time);
@@ -2609,7 +3838,7 @@ static VALUE ruby_curl_easy_start_transfer_time_get(VALUE self) {
   ruby_curl_easy *rbce;
   double time;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_STARTTRANSFER_TIME, &time);
 
   return rb_float_new(time);
@@ -2631,7 +3860,7 @@ static VALUE ruby_curl_easy_redirect_time_get(VALUE self) {
   ruby_curl_easy *rbce;
   double time;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_REDIRECT_TIME, &time);
 
   return rb_float_new(time);
@@ -2654,13 +3883,13 @@ static VALUE ruby_curl_easy_redirect_count_get(VALUE self) {
   ruby_curl_easy *rbce;
   long count;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_REDIRECT_COUNT, &count);
 
   return LONG2NUM(count);
 #else
   rb_warn("Installed libcurl is too old to support redirect_count");
-  return INT2FIX(-1);
+  return LONG2NUM(-1);
 #endif
 
 }
@@ -2669,7 +3898,7 @@ static VALUE ruby_curl_easy_redirect_count_get(VALUE self) {
  * call-seq:
  *   easy.redirect_url                               => "http://some.url" or nil
  *
- * Retrieve  the URL a redirect would take you to if you 
+ * Retrieve  the URL a redirect would take you to if you
  * would enable CURLOPT_FOLLOWLOCATION.
  *
  * Requires libcurl 7.18.2 or higher, otherwise -1 is always returned.
@@ -2679,7 +3908,7 @@ static VALUE ruby_curl_easy_redirect_url_get(VALUE self) {
   ruby_curl_easy *rbce;
   char* url;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_REDIRECT_URL, &url);
 
   if (url && url[0]) {    // curl returns empty string if none
@@ -2689,7 +3918,7 @@ static VALUE ruby_curl_easy_redirect_url_get(VALUE self) {
   }
 #else
   rb_warn("Installed libcurl is too old to support redirect_url");
-  return INT2FIX(-1);
+  return LONG2NUM(-1);
 #endif
 }
 
@@ -2704,12 +3933,17 @@ static VALUE ruby_curl_easy_redirect_url_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_uploaded_bytes_get(VALUE self) {
   ruby_curl_easy *rbce;
-  double bytes;
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+#ifdef HAVE_CURLINFO_SIZE_UPLOAD_T
+  curl_off_t bytes;
+  curl_easy_getinfo(rbce->curl, CURLINFO_SIZE_UPLOAD_T, &bytes);
+  return LL2NUM(bytes);
+#else
+  double bytes;
   curl_easy_getinfo(rbce->curl, CURLINFO_SIZE_UPLOAD, &bytes);
-
   return rb_float_new(bytes);
+#endif
 }
 
 /*
@@ -2721,12 +3955,17 @@ static VALUE ruby_curl_easy_uploaded_bytes_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_downloaded_bytes_get(VALUE self) {
   ruby_curl_easy *rbce;
-  double bytes;
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+#ifdef HAVE_CURLINFO_SIZE_DOWNLOAD_T
+  curl_off_t bytes;
+  curl_easy_getinfo(rbce->curl, CURLINFO_SIZE_DOWNLOAD_T, &bytes);
+  return LL2NUM(bytes);
+#else
+  double bytes;
   curl_easy_getinfo(rbce->curl, CURLINFO_SIZE_DOWNLOAD, &bytes);
-
   return rb_float_new(bytes);
+#endif
 }
 
 /*
@@ -2738,12 +3977,17 @@ static VALUE ruby_curl_easy_downloaded_bytes_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_upload_speed_get(VALUE self) {
   ruby_curl_easy *rbce;
-  double bytes;
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+#ifdef HAVE_CURLINFO_SPEED_UPLOAD_T
+  curl_off_t bytes;
+  curl_easy_getinfo(rbce->curl, CURLINFO_SPEED_UPLOAD_T, &bytes);
+  return LL2NUM(bytes);
+#else
+  double bytes;
   curl_easy_getinfo(rbce->curl, CURLINFO_SPEED_UPLOAD, &bytes);
-
   return rb_float_new(bytes);
+#endif
 }
 
 /*
@@ -2755,12 +3999,17 @@ static VALUE ruby_curl_easy_upload_speed_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_download_speed_get(VALUE self) {
   ruby_curl_easy *rbce;
-  double bytes;
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+#ifdef HAVE_CURLINFO_SPEED_DOWNLOAD_T
+  curl_off_t bytes;
+  curl_easy_getinfo(rbce->curl, CURLINFO_SPEED_DOWNLOAD_T, &bytes);
+  return LL2NUM(bytes);
+#else
+  double bytes;
   curl_easy_getinfo(rbce->curl, CURLINFO_SPEED_DOWNLOAD, &bytes);
-
   return rb_float_new(bytes);
+#endif
 }
 
 /*
@@ -2774,7 +4023,7 @@ static VALUE ruby_curl_easy_header_size_get(VALUE self) {
   ruby_curl_easy *rbce;
   long size;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_HEADER_SIZE, &size);
 
   return LONG2NUM(size);
@@ -2792,7 +4041,7 @@ static VALUE ruby_curl_easy_request_size_get(VALUE self) {
   ruby_curl_easy *rbce;
   long size;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_REQUEST_SIZE, &size);
 
   return LONG2NUM(size);
@@ -2809,7 +4058,7 @@ static VALUE ruby_curl_easy_ssl_verify_result_get(VALUE self) {
   ruby_curl_easy *rbce;
   long result;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_SSL_VERIFYRESULT, &result);
 
   return LONG2NUM(result);
@@ -2832,12 +4081,17 @@ NOTE: you must call curl_slist_free_all(3) on the list pointer once you're done
  */
 static VALUE ruby_curl_easy_downloaded_content_length_get(VALUE self) {
   ruby_curl_easy *rbce;
-  double bytes;
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+#ifdef HAVE_CURLINFO_CONTENT_LENGTH_DOWNLOAD_T
+  curl_off_t bytes;
+  curl_easy_getinfo(rbce->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T, &bytes);
+  return LL2NUM(bytes);
+#else
+  double bytes;
   curl_easy_getinfo(rbce->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &bytes);
-
   return rb_float_new(bytes);
+#endif
 }
 
 /*
@@ -2848,12 +4102,17 @@ static VALUE ruby_curl_easy_downloaded_content_length_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_uploaded_content_length_get(VALUE self) {
   ruby_curl_easy *rbce;
-  double bytes;
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+#ifdef HAVE_CURLINFO_CONTENT_LENGTH_UPLOAD_T
+  curl_off_t bytes;
+  curl_easy_getinfo(rbce->curl, CURLINFO_CONTENT_LENGTH_UPLOAD_T, &bytes);
+  return LL2NUM(bytes);
+#else
+  double bytes;
   curl_easy_getinfo(rbce->curl, CURLINFO_CONTENT_LENGTH_UPLOAD, &bytes);
-
   return rb_float_new(bytes);
+#endif
 }
 
 /*
@@ -2869,7 +4128,7 @@ static VALUE ruby_curl_easy_content_type_get(VALUE self) {
   ruby_curl_easy *rbce;
   char* type;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_CONTENT_TYPE, &type);
 
   if (type && type[0]) {    // curl returns empty string if none
@@ -2912,13 +4171,13 @@ static VALUE ruby_curl_easy_os_errno_get(VALUE self) {
   ruby_curl_easy *rbce;
   long result;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_OS_ERRNO, &result);
 
   return LONG2NUM(result);
 #else
   rb_warn("Installed libcurl is too old to support os_errno");
-  return INT2FIX(0);
+  return LONG2NUM(0);
 #endif
 }
 
@@ -2941,23 +4200,59 @@ static VALUE ruby_curl_easy_num_connects_get(VALUE self) {
   ruby_curl_easy *rbce;
   long result;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_NUM_CONNECTS, &result);
 
   return LONG2NUM(result);
 #else
   rb_warn("Installed libcurl is too old to support num_connects");
-  return INT2FIX(-1);
+  return LONG2NUM(-1);
 #endif
 }
 
 
-/* TODO this needs to be implemented.
+/*
+ * call-seq:
+ *   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.
+ *
+ * To modify the cookie engine (add/replace/remove), use +easy.cookielist= string+
+ * or +easy.set(:cookielist, string)+ with one of the following accepted inputs:
+ * - A Set-Cookie style header string: "Set-Cookie: name=value; Domain=example.com; Path=/; Expires=..."
+ * - One or more lines in Netscape cookie file format (tab-separated fields)
+ * - Special commands: "ALL" (clear all), "SESS" (remove session cookies), "FLUSH" (write to jar), "RELOAD" (reload from file)
+ *
+ * @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
+  ruby_curl_easy *rbce;
+  struct curl_slist *cookies;
+  struct curl_slist *cookie;
+  VALUE rb_cookies;
+
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  curl_easy_getinfo(rbce->curl, CURLINFO_COOKIELIST, &cookies);
+  if (!cookies)
+    return Qnil;
+  rb_cookies = rb_ary_new();
+  for (cookie = cookies; cookie; cookie = cookie->next)
+    rb_ary_push(rb_cookies, rb_str_new2(cookie->data));
+  curl_slist_free_all(cookies);
+  return rb_cookies;
 
-CURLINFO_COOKIELIST
+#else
+    rb_warn("Installed libcurl is too old to support cookielist");
+    return INT2FIX(-1);
+#endif
+}
 
-Pass a pointer to a 'struct curl_slist *' to receive a linked-list of all cookies cURL knows (expired ones, too). Don't forget to curl_slist_free_all(3) the list after it has been used. If there are no cookies (cookies for the handle have not been enabled or simply none have been received) 'struct curl_slist *' will be set to point to NULL. (Added in 7.14.1)
-*/
 
 /* TODO this needs to be implemented. Could probably support CONNECT_ONLY by having this
  *      return an open Socket or something.
@@ -2982,7 +4277,7 @@ static VALUE ruby_curl_easy_ftp_entry_path_get(VALUE self) {
   ruby_curl_easy *rbce;
   char* path = NULL;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   curl_easy_getinfo(rbce->curl, CURLINFO_FTP_ENTRY_PATH, &path);
 
   if (path && path[0]) {    // curl returns NULL or empty string if none
@@ -2991,7 +4286,7 @@ static VALUE ruby_curl_easy_ftp_entry_path_get(VALUE self) {
     return Qnil;
   }
 #else
-  rb_warn("Installed libcurl is too old to support num_connects");
+  rb_warn("Installed libcurl is too old to support ftp_entry_path");
   return Qnil;
 #endif
 }
@@ -3002,7 +4297,7 @@ static VALUE ruby_curl_easy_ftp_entry_path_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_multi_get(VALUE self) {
   ruby_curl_easy *rbce;
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   return rbce->multi;
 }
 
@@ -3012,7 +4307,12 @@ static VALUE ruby_curl_easy_multi_get(VALUE self) {
  */
 static VALUE ruby_curl_easy_multi_set(VALUE self, VALUE multi) {
   ruby_curl_easy *rbce;
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+
+  if (!NIL_P(multi) && rb_obj_is_kind_of(multi, cCurlMulti) != Qtrue) {
+    rb_raise(rb_eTypeError, "expected Curl::Multi or nil");
+  }
+
   rbce->multi = multi;
   return rbce->multi;
 }
@@ -3023,21 +4323,44 @@ static VALUE ruby_curl_easy_multi_set(VALUE self, VALUE multi) {
  */
 static VALUE ruby_curl_easy_last_result(VALUE self) {
   ruby_curl_easy *rbce;
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
-  return INT2FIX(rbce->last_result);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+  return LONG2NUM(rbce->last_result);
+}
+
+/*
+ * call-seq:
+ *   easy.last_error                                     => "Error details" or nil
+ */
+static VALUE ruby_curl_easy_last_error(VALUE self) {
+  ruby_curl_easy *rbce;
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+
+  if (rbce->err_buf[0]) {    // curl returns NULL or empty string if none
+    return rb_str_new2(rbce->err_buf);
+  } else {
+    return Qnil;
+  }
 }
 
 /*
  * call-seq:
- *   easy.setopt Fixnum, value  => value
+ *   easy.setopt(opt, val)  => val
  *
- * Iniital access to libcurl curl_easy_setopt
+ * 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;
-  long option = FIX2LONG(opt);
+  long option = NUM2LONG(opt);
+  rb_io_t *open_f_ptr;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 
   switch (option) {
   /* BEHAVIOR OPTIONS */
@@ -3059,9 +4382,11 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
   case CURLOPT_CUSTOMREQUEST:
     curl_easy_setopt(rbce->curl, CURLOPT_CUSTOMREQUEST, NIL_P(val) ? NULL : StringValueCStr(val));
     break;
-  case CURLOPT_HTTP_VERSION:
-    curl_easy_setopt(rbce->curl, CURLOPT_HTTP_VERSION, FIX2INT(val));
-    break;
+  case CURLOPT_HTTP_VERSION: {
+    long http_version = NIL_P(val) ? CURL_HTTP_VERSION_NONE : NUM2LONG(val);
+    rbce->http_version = http_version;
+    curl_easy_setopt(rbce->curl, CURLOPT_HTTP_VERSION, http_version);
+    } break;
   case CURLOPT_PROXY: {
     VALUE proxy_url = val;
     CURB_OBJECT_HSETTER(ruby_curl_easy, proxy_url);
@@ -3073,6 +4398,12 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
   case CURLOPT_HEADER:
   case CURLOPT_NOPROGRESS:
   case CURLOPT_NOSIGNAL:
+#ifdef HAVE_CURLOPT_PATH_AS_IS
+  case CURLOPT_PATH_AS_IS:
+#endif
+#ifdef HAVE_CURLOPT_PIPEWAIT
+  case CURLOPT_PIPEWAIT:
+#endif
   case CURLOPT_HTTPGET:
   case CURLOPT_NOBODY: {
     int type = rb_type(val);
@@ -3084,8 +4415,17 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
     } else {
       value = rb_funcall(val, rb_intern("to_i"), 0);
     }
-    curl_easy_setopt(rbce->curl, option, FIX2INT(value));
+    curl_easy_setopt(rbce->curl, option, NUM2LONG(value));
     } break;
+  case CURLOPT_POST: {
+    curl_easy_setopt(rbce->curl, CURLOPT_POST, rb_type(val) == T_TRUE);
+  } break;
+  case CURLOPT_MAXCONNECTS: {
+    curl_easy_setopt(rbce->curl, CURLOPT_MAXCONNECTS, NUM2LONG(val));
+  } break;
+  case CURLOPT_POSTFIELDS: {
+    ruby_curl_easy_post_body_set_with_mode(self, val, 0);
+  } break;
   case CURLOPT_USERPWD: {
     VALUE userpwd = val;
     CURB_OBJECT_HSETTER(ruby_curl_easy, userpwd);
@@ -3094,6 +4434,12 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
     VALUE proxypwd = val;
     CURB_OBJECT_HSETTER(ruby_curl_easy, proxypwd);
     } break;
+#ifdef HAVE_CURLOPT_NOPROXY
+  case CURLOPT_NOPROXY: {
+    VALUE noproxy = val;
+    CURB_OBJECT_HSETTER(ruby_curl_easy, noproxy);
+    } break;
+#endif
   case CURLOPT_COOKIE: {
     VALUE cookies = val;
     CURB_OBJECT_HSETTER(ruby_curl_easy, cookies);
@@ -3106,14 +4452,205 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
     VALUE cookiejar = val;
     CURB_OBJECT_HSETTER(ruby_curl_easy, cookiejar);
     } break;
+#ifdef HAVE_CURLOPT_REQUEST_TARGET
+  case CURLOPT_REQUEST_TARGET: {
+    /* Forward request-target directly to libcurl as a string. */
+    curl_easy_setopt(rbce->curl, CURLOPT_REQUEST_TARGET, NIL_P(val) ? NULL : StringValueCStr(val));
+    } break;
+#endif
+  case CURLOPT_TCP_NODELAY: {
+    curl_easy_setopt(rbce->curl, CURLOPT_TCP_NODELAY, NUM2LONG(val));
+    } break;
+  /* FTP-specific toggles */
+#ifdef HAVE_CURLOPT_DIRLISTONLY
+  case CURLOPT_DIRLISTONLY: {
+    int type = rb_type(val);
+    VALUE value;
+    if (type == T_TRUE) {
+      value = rb_int_new(1);
+    } else if (type == T_FALSE) {
+      value = rb_int_new(0);
+    } else {
+      value = rb_funcall(val, rb_intern("to_i"), 0);
+    }
+    curl_easy_setopt(rbce->curl, CURLOPT_DIRLISTONLY, NUM2LONG(value));
+    } break;
+#endif
+#ifdef HAVE_CURLOPT_FTP_USE_EPSV
+  case CURLOPT_FTP_USE_EPSV: {
+    int type = rb_type(val);
+    VALUE value;
+    if (type == T_TRUE) {
+      value = rb_int_new(1);
+    } else if (type == T_FALSE) {
+      value = rb_int_new(0);
+    } else {
+      value = rb_funcall(val, rb_intern("to_i"), 0);
+    }
+    curl_easy_setopt(rbce->curl, CURLOPT_FTP_USE_EPSV, NUM2LONG(value));
+    } break;
+#endif
+#ifdef HAVE_CURLOPT_FTP_USE_EPRT
+  case CURLOPT_FTP_USE_EPRT: {
+    int type = rb_type(val);
+    VALUE value;
+    if (type == T_TRUE) {
+      value = rb_int_new(1);
+    } else if (type == T_FALSE) {
+      value = rb_int_new(0);
+    } else {
+      value = rb_funcall(val, rb_intern("to_i"), 0);
+    }
+    curl_easy_setopt(rbce->curl, CURLOPT_FTP_USE_EPRT, NUM2LONG(value));
+    } break;
+#endif
+#ifdef HAVE_CURLOPT_FTP_SKIP_PASV_IP
+  case CURLOPT_FTP_SKIP_PASV_IP: {
+    int type = rb_type(val);
+    VALUE value;
+    if (type == T_TRUE) {
+      value = rb_int_new(1);
+    } else if (type == T_FALSE) {
+      value = rb_int_new(0);
+    } else {
+      value = rb_funcall(val, rb_intern("to_i"), 0);
+    }
+    curl_easy_setopt(rbce->curl, CURLOPT_FTP_SKIP_PASV_IP, NUM2LONG(value));
+    } break;
+#endif
+  case CURLOPT_RANGE: {
+    curl_easy_setopt(rbce->curl, CURLOPT_RANGE, StringValueCStr(val));
+    } break;
   case CURLOPT_RESUME_FROM: {
-    curl_easy_setopt(rbce->curl, CURLOPT_RESUME_FROM, FIX2LONG(val));
+    curl_easy_setopt(rbce->curl, CURLOPT_RESUME_FROM, NUM2LONG(val));
     } break;
   case CURLOPT_FAILONERROR: {
-    curl_easy_setopt(rbce->curl, CURLOPT_FAILONERROR, FIX2LONG(val));
+    curl_easy_setopt(rbce->curl, CURLOPT_FAILONERROR, NUM2LONG(val));
     } break;
-  default:
+  case CURLOPT_SSL_CIPHER_LIST: {
+    curl_easy_setopt(rbce->curl, CURLOPT_SSL_CIPHER_LIST, StringValueCStr(val));
+    } break;
+  case CURLOPT_FORBID_REUSE: {
+    curl_easy_setopt(rbce->curl, CURLOPT_FORBID_REUSE, NUM2LONG(val));
+    } break;
+#ifdef HAVE_CURLOPT_GSSAPI_DELEGATION
+  case CURLOPT_GSSAPI_DELEGATION: {
+    curl_easy_setopt(rbce->curl, CURLOPT_GSSAPI_DELEGATION, NUM2LONG(val));
+    } break;
+#endif
+#ifdef HAVE_CURLOPT_UNIX_SOCKET_PATH
+  case CURLOPT_UNIX_SOCKET_PATH: {
+	curl_easy_setopt(rbce->curl, CURLOPT_UNIX_SOCKET_PATH, StringValueCStr(val));
+    } break;
+#endif
+#ifdef HAVE_CURLOPT_MAX_SEND_SPEED_LARGE
+  case CURLOPT_MAX_SEND_SPEED_LARGE: {
+    curl_easy_setopt(rbce->curl, CURLOPT_MAX_SEND_SPEED_LARGE, (curl_off_t) NUM2LL(val));
+    } break;
+#endif
+#ifdef HAVE_CURLOPT_MAX_RECV_SPEED_LARGE
+  case CURLOPT_MAX_RECV_SPEED_LARGE: {
+    curl_easy_setopt(rbce->curl, CURLOPT_MAX_RECV_SPEED_LARGE, (curl_off_t) NUM2LL(val));
+    } break;
+#endif
+#ifdef HAVE_CURLOPT_MAXFILESIZE
+  case CURLOPT_MAXFILESIZE:
+    curl_easy_setopt(rbce->curl, CURLOPT_MAXFILESIZE, NUM2LONG(val));
+    break;
+#endif
+#ifdef HAVE_CURLOPT_TCP_KEEPALIVE
+  case CURLOPT_TCP_KEEPALIVE:
+    curl_easy_setopt(rbce->curl, CURLOPT_TCP_KEEPALIVE, NUM2LONG(val));
+    break;
+  case CURLOPT_TCP_KEEPIDLE:
+    curl_easy_setopt(rbce->curl, CURLOPT_TCP_KEEPIDLE, NUM2LONG(val));
+    break;
+  case CURLOPT_TCP_KEEPINTVL:
+    curl_easy_setopt(rbce->curl, CURLOPT_TCP_KEEPINTVL, NUM2LONG(val));
+    break;
+#endif
+#ifdef HAVE_CURLOPT_HAPROXYPROTOCOL
+  case CURLOPT_HAPROXYPROTOCOL:
+    curl_easy_setopt(rbce->curl, CURLOPT_HAPROXYPROTOCOL, NUM2LONG(val));
+    break;
+#endif
+  case CURLOPT_STDERR:
+    // libcurl requires raw FILE pointer and this should be IO object in Ruby.
+    // Tempfile or StringIO won't work.
+    Check_Type(val, T_FILE);
+    GetOpenFile(val, open_f_ptr);
+    curl_easy_setopt(rbce->curl, CURLOPT_STDERR, rb_io_stdio_file(open_f_ptr));
+    /* Retain a Ruby reference to the IO to prevent GC/finalization
+     * while libcurl still holds and writes to the underlying FILE*. */
+    rb_easy_set("stderr_io", val);
+    break;
+  case CURLOPT_PROTOCOLS:
+  case CURLOPT_REDIR_PROTOCOLS:
+    curl_easy_setopt(rbce->curl, option, NUM2LONG(val));
+    break;
+#ifdef HAVE_CURLOPT_SSL_SESSIONID_CACHE
+  case CURLOPT_SSL_SESSIONID_CACHE:
+    curl_easy_setopt(rbce->curl, CURLOPT_SSL_SESSIONID_CACHE, NUM2LONG(val));
     break;
+#endif
+#ifdef HAVE_CURLOPT_COOKIELIST
+  case CURLOPT_COOKIELIST: {
+	/* Forward to libcurl */
+	curl_easy_setopt(rbce->curl, CURLOPT_COOKIELIST, StringValueCStr(val));
+	/* Track whether the cookie engine should be enabled for requests.
+	 * According to libcurl docs, CURLOPT_COOKIELIST also enables the cookie engine
+	 * when provided with a non-command string. Some environments may still require
+	 * an explicit "enable" via CURLOPT_COOKIEFILE="" to send cookies on requests.
+	 * We do that in the perform setup when this flag is set.
+	 */
+	if (RB_TYPE_P(val, T_STRING)) {
+	  const char *s = StringValueCStr(val);
+	  if (!(strcmp(s, "ALL") == 0 || strcmp(s, "SESS") == 0 || strcmp(s, "FLUSH") == 0 || strcmp(s, "RELOAD") == 0)) {
+	    rbce->cookielist_engine_enabled = 1;
+	  }
+	} else {
+	  /* Non-string values are unexpected; be conservative and do not enable. */
+	}
+  } break;
+#endif
+#ifdef HAVE_CURLOPT_PROXY_SSL_VERIFYHOST
+  case CURLOPT_PROXY_SSL_VERIFYHOST:
+    curl_easy_setopt(rbce->curl, CURLOPT_PROXY_SSL_VERIFYHOST, NUM2LONG(val));
+    break;
+#endif
+#ifdef HAVE_CURLOPT_RESOLVE
+  case CURLOPT_RESOLVE: {
+    struct curl_slist *list = NULL;
+    ruby_curl_easy_clear_resolve_list(rbce);
+    if (NIL_P(val)) {
+      /* When nil is passed, we clear any previous resolve list */
+      list = NULL;
+    } else if (TYPE(val) == T_ARRAY) {
+      long i, len = RARRAY_LEN(val);
+      for (i = 0; i < len; i++) {
+        VALUE item = rb_ary_entry(val, i);
+        struct curl_slist *new_list = curl_slist_append(list, StringValueCStr(item));
+        if (!new_list) {
+          curl_slist_free_all(list);
+          rb_raise(rb_eNoMemError, "Failed to append to resolve list");
+        }
+        list = new_list;
+      }
+    } else {
+      /* If a single string is passed, use it directly */
+      list = curl_slist_append(NULL, StringValueCStr(val));
+      if (!list) {
+        rb_raise(rb_eNoMemError, "Failed to create resolve list");
+      }
+    }
+    /* Save the list pointer in the ruby_curl_easy structure for cleanup later */
+    rbce->curl_resolve = list;
+    rb_hash_aset(rbce->opts, rb_easy_hkey("resolve"), val);
+    curl_easy_setopt(rbce->curl, CURLOPT_RESOLVE, list);
+  } break;
+#endif
+  default:
+    rb_raise(rb_eTypeError, "Curb unsupported option");
   }
 
   return val;
@@ -3121,9 +4658,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;
@@ -3136,7 +4677,7 @@ static VALUE ruby_curl_easy_get_opt(VALUE self, VALUE opt) {
 static VALUE ruby_curl_easy_inspect(VALUE self) {
   char buf[64];
   ruby_curl_easy *rbce;
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   /* if we don't have a url set... we'll crash... */
   if( !rb_easy_nil("url") && rb_easy_type_check("url", T_STRING)) {
     VALUE url = rb_easy_get("url");
@@ -3168,7 +4709,7 @@ static VALUE ruby_curl_easy_escape(VALUE self, VALUE svalue) {
   VALUE rresult;
   VALUE str = svalue;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 
   /* NOTE: make sure the value is a string, if not call to_s */
   if( rb_type(str) != T_STRING ) { str = rb_funcall(str,rb_intern("to_s"),0); }
@@ -3199,12 +4740,12 @@ static VALUE ruby_curl_easy_unescape(VALUE self, VALUE str) {
   char *result;
   VALUE rresult;
 
-  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 
 #if (LIBCURL_VERSION_NUM >= 0x070f04)
   result = (char*)curl_easy_unescape(rbce->curl, StringValuePtr(str), (int)RSTRING_LEN(str), &rlen);
 #else
-  result = (char*)curl_unescape(StringValuePtr(str), RSTRING_LEN(str));
+  result = (char*)curl_unescape(StringValuePtr(str), (int)RSTRING_LEN(str));
   rlen = strlen(result);
 #endif
 
@@ -3219,15 +4760,16 @@ static VALUE ruby_curl_easy_unescape(VALUE self, VALUE str) {
 
 /*
  * call-seq:
- *   Curl::Easy.error(code)    => String
+ *   Curl::Easy.error(code)    => [ErrCode, String]
  *
  * translate an internal libcurl error to ruby error class
  */
 static VALUE ruby_curl_easy_error_message(VALUE klass, VALUE code) {
-  return rb_curl_easy_error(FIX2INT(code));
+  return rb_curl_easy_error(NUM2INT(code));
 }
 
 /* =================== INIT LIB =====================*/
+// TODO: https://bugs.ruby-lang.org/issues/18007
 void init_curb_easy() {
   idCall = rb_intern("call");
   idJoin = rb_intern("join");
@@ -3238,12 +4780,21 @@ void init_curb_easy() {
   cCurlEasy = rb_define_class_under(mCurl, "Easy", rb_cObject);
 
   /* Class methods */
-  rb_define_singleton_method(cCurlEasy, "new", ruby_curl_easy_new, -1);
+  rb_define_alloc_func(cCurlEasy, ruby_curl_easy_allocate);
   rb_define_singleton_method(cCurlEasy, "error", ruby_curl_easy_error_message, 1);
 
+  /* Initialize method */
+  rb_define_method(cCurlEasy, "initialize", ruby_curl_easy_initialize, -1);
+
   /* Attributes for config next perform */
   rb_define_method(cCurlEasy, "url", ruby_curl_easy_url_get, 0);
   rb_define_method(cCurlEasy, "proxy_url", ruby_curl_easy_proxy_url_get, 0);
+  rb_define_method(cCurlEasy, "http_version=", ruby_curl_easy_http_version_set, 1);
+  rb_define_method(cCurlEasy, "http_version", ruby_curl_easy_http_version_get, 0);
+
+  rb_define_method(cCurlEasy, "proxy_headers=", ruby_curl_easy_proxy_headers_set, 1);
+  rb_define_method(cCurlEasy, "proxy_headers", ruby_curl_easy_proxy_headers_get, 0);
+
   rb_define_method(cCurlEasy, "headers=", ruby_curl_easy_headers_set, 1);
   rb_define_method(cCurlEasy, "headers", ruby_curl_easy_headers_get, 0);
   rb_define_method(cCurlEasy, "interface", ruby_curl_easy_interface_get, 0);
@@ -3270,6 +4821,8 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "put_data=", ruby_curl_easy_put_data_set, 1);
   rb_define_method(cCurlEasy, "ftp_commands=", ruby_curl_easy_ftp_commands_set, 1);
   rb_define_method(cCurlEasy, "ftp_commands", ruby_curl_easy_ftp_commands_get, 0);
+  rb_define_method(cCurlEasy, "resolve=", ruby_curl_easy_resolve_set, 1);
+  rb_define_method(cCurlEasy, "resolve", ruby_curl_easy_resolve_get, 0);
 
   rb_define_method(cCurlEasy, "local_port=", ruby_curl_easy_local_port_set, 1);
   rb_define_method(cCurlEasy, "local_port", ruby_curl_easy_local_port_get, 0);
@@ -3287,8 +4840,12 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "max_redirects", ruby_curl_easy_max_redirects_get, 0);
   rb_define_method(cCurlEasy, "timeout=", ruby_curl_easy_timeout_set, 1);
   rb_define_method(cCurlEasy, "timeout", ruby_curl_easy_timeout_get, 0);
+  rb_define_method(cCurlEasy, "timeout_ms=", ruby_curl_easy_timeout_ms_set, 1);
+  rb_define_method(cCurlEasy, "timeout_ms", ruby_curl_easy_timeout_ms_get, 0);
   rb_define_method(cCurlEasy, "connect_timeout=", ruby_curl_easy_connect_timeout_set, 1);
   rb_define_method(cCurlEasy, "connect_timeout", ruby_curl_easy_connect_timeout_get, 0);
+  rb_define_method(cCurlEasy, "connect_timeout_ms=", ruby_curl_easy_connect_timeout_ms_set, 1);
+  rb_define_method(cCurlEasy, "connect_timeout_ms", ruby_curl_easy_connect_timeout_ms_get, 0);
   rb_define_method(cCurlEasy, "dns_cache_timeout=", ruby_curl_easy_dns_cache_timeout_set, 1);
   rb_define_method(cCurlEasy, "dns_cache_timeout", ruby_curl_easy_dns_cache_timeout_get, 0);
   rb_define_method(cCurlEasy, "ftp_response_timeout=", ruby_curl_easy_ftp_response_timeout_set, 1);
@@ -3297,6 +4854,10 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "low_speed_limit", ruby_curl_easy_low_speed_limit_get, 0);
   rb_define_method(cCurlEasy, "low_speed_time=", ruby_curl_easy_low_speed_time_set, 1);
   rb_define_method(cCurlEasy, "low_speed_time", ruby_curl_easy_low_speed_time_get, 0);
+  rb_define_method(cCurlEasy, "max_send_speed_large=", ruby_curl_easy_max_send_speed_large_set, 1);
+  rb_define_method(cCurlEasy, "max_send_speed_large", ruby_curl_easy_max_send_speed_large_get, 0);
+  rb_define_method(cCurlEasy, "max_recv_speed_large=", ruby_curl_easy_max_recv_speed_large_set, 1);
+  rb_define_method(cCurlEasy, "max_recv_speed_large", ruby_curl_easy_max_recv_speed_large_get, 0);
   rb_define_method(cCurlEasy, "ssl_version=", ruby_curl_easy_ssl_version_set, 1);
   rb_define_method(cCurlEasy, "ssl_version", ruby_curl_easy_ssl_version_get, 0);
   rb_define_method(cCurlEasy, "use_ssl=", ruby_curl_easy_use_ssl_set, 1);
@@ -3348,7 +4909,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);
@@ -3356,6 +4918,7 @@ void init_curb_easy() {
 
   rb_define_method(cCurlEasy, "last_effective_url", ruby_curl_easy_last_effective_url_get, 0);
   rb_define_method(cCurlEasy, "response_code", ruby_curl_easy_response_code_get, 0);
+  rb_define_method(cCurlEasy, "code", ruby_curl_easy_response_code_get, 0);
 #if defined(HAVE_CURLINFO_PRIMARY_IP)
   rb_define_method(cCurlEasy, "primary_ip", ruby_curl_easy_primary_ip_get, 0);
 #endif
@@ -3364,6 +4927,9 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "total_time", ruby_curl_easy_total_time_get, 0);
   rb_define_method(cCurlEasy, "name_lookup_time", ruby_curl_easy_name_lookup_time_get, 0);
   rb_define_method(cCurlEasy, "connect_time", ruby_curl_easy_connect_time_get, 0);
+#if defined(HAVE_CURLINFO_APPCONNECT_TIME)
+  rb_define_method(cCurlEasy, "app_connect_time", ruby_curl_easy_app_connect_time_get, 0);
+#endif
   rb_define_method(cCurlEasy, "pre_transfer_time", ruby_curl_easy_pre_transfer_time_get, 0);
   rb_define_method(cCurlEasy, "start_transfer_time", ruby_curl_easy_start_transfer_time_get, 0);
   rb_define_method(cCurlEasy, "redirect_time", ruby_curl_easy_redirect_time_get, 0);
@@ -3381,6 +4947,7 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "content_type", ruby_curl_easy_content_type_get, 0);
   rb_define_method(cCurlEasy, "os_errno", ruby_curl_easy_os_errno_get, 0);
   rb_define_method(cCurlEasy, "num_connects", ruby_curl_easy_num_connects_get, 0);
+  rb_define_method(cCurlEasy, "cookielist", ruby_curl_easy_cookielist_get, 0);
   rb_define_method(cCurlEasy, "ftp_entry_path", ruby_curl_easy_ftp_entry_path_get, 0);
 
   rb_define_method(cCurlEasy, "close", ruby_curl_easy_close, 0);
@@ -3397,7 +4964,9 @@ void init_curb_easy() {
 
   rb_define_method(cCurlEasy, "multi", ruby_curl_easy_multi_get, 0);
   rb_define_method(cCurlEasy, "multi=", ruby_curl_easy_multi_set, 1);
+  rb_define_private_method(cCurlEasy, "_take_callback_error", ruby_curl_easy_take_callback_error, 0);
   rb_define_method(cCurlEasy, "last_result", ruby_curl_easy_last_result, 0);
+  rb_define_method(cCurlEasy, "last_error", ruby_curl_easy_last_error, 0);
 
   rb_define_method(cCurlEasy, "setopt", ruby_curl_easy_set_opt, 2);
   rb_define_method(cCurlEasy, "getinfo", ruby_curl_easy_get_opt, 1);