curb 0.9.8 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64402c665924d5c24d6fa01dff9dd9f41d522ef1ca6e663d2038a204bd0290b4
-  data.tar.gz: 645f0b0f29804b105b9a4caaa1b2132d9d18b5dd4d678072e7e41a1d8d73771a
+  metadata.gz: dce5f49b09bacccf705e3d25ba29031dd4fc82c2721860eef02bb4a8af2dd0e2
+  data.tar.gz: 9456ed69688f2236bdd17f338e26faaf46b91f0fd4e51b3a48d5551ff8fdc433
 SHA512:
-  metadata.gz: f86cb2a29633a86820862e35a5a1113c859e55636a50e779ab4235ccc54fb3b38a894edb8fcc090522ceb509ac0c2da329f708a9c109a2f871ce9c718984729c
-  data.tar.gz: a2d20ac0b5aee80de2aa37f4c49b923c5e6b19c2b0dd82d4466d14b21f0988644baa893bd23950380efec0ab028c9f1fd9c1dfc6d2ab7c97246c86bb2aad5cf2
+  metadata.gz: df6ab81576ef567878331724c1600c59ff923be34d3a71bd31d07e4999880743e73c31a502bab8aaece54099fd5142bf954dbf004fffd38f0e6698750e3f9682
+  data.tar.gz: 5b7b867979da88d328e9f71a4a6eb7183430de26902311cb8678b443a6c53cf50aa62952f277bc2c2821bafc2af48c0e28067f7dce512ff7c2912b195bc27ad5

data/README.markdown

@@ -7,7 +7,7 @@ Curb (probably CUrl-RuBy or something) provides Ruby-language bindings for the
 libcurl(3), a fully-featured client-side URL transfer library.
 cURL and libcurl live at [http://curl.haxx.se/](http://curl.haxx.se/) .
 
-Curb is a work-in-progress, and currently only supports libcurl's 'easy' and 'multi' modes.
+Curb is a work-in-progress, and currently only supports libcurl's `easy` and `multi` modes.
 
 ## License
 
@@ -16,10 +16,26 @@ Ruby license. See the LICENSE file for the gory details.
 
 ## You will need
 
-* A working Ruby installation (2.1+)
-* A working (lib)curl installation, with development stuff (7.5+, tested with 7.19.x)
+* A working Ruby installation (`1.8.7+` will work but `2.1+` preferred)
+* A working libcurl development installation
+(Ideally one of the versions listed in the compatibility chart below that maps to your `curb` version)
 * A sane build environment (e.g. gcc, make)
 
+## Version Compatibility chart
+
+A **non-exhaustive** set of compatibility versions of the libcurl library
+with this gem are as follows. (Note that these are only the ones that have been
+tested and reported to work across a variety of platforms / rubies)
+
+| Gem Version | Release Date | libcurl versions |
+| ----------- | -----------  | ---------------- |
+| 0.9.8       | Jan 2019     | 7.58 - 7.63      |
+| 0.9.7       | Nov 2018     | 7.56 - 7.60      |
+| 0.9.6       | May 2018     | 7.51 - 7.59      |
+| 0.9.5       | May 2018     | 7.51 - 7.59      |
+| 0.9.4       | Aug 2017     | 7.41 - 7.58      |
+| 0.9.3       | Apr 2016     | 7.26 - 7.58      |
+
 ## Installation...
 
 ... will usually be as simple as:
@@ -31,6 +47,10 @@ the [development version of libcurl](http://curl.haxx.se/gknw.net/7.39.0/dist-w3
 line (alter paths to your curl location, but remember to use forward slashes):
 
     gem install curb --platform=ruby -- --with-curl-lib=C:/curl-7.39.0-devel-mingw32/lib --with-curl-include=C:/curl-7.39.0-devel-mingw32/include
+    
+Note that with Windows moving from one method of compiling to another as of Ruby `2.4` (DevKit -> MYSYS2),
+the usage of Ruby `2.4+` with this gem on windows is unlikely to work. It is advised to use the
+latest version of Ruby 2.3 available [HERE](https://dl.bintray.com/oneclick/rubyinstaller/rubyinstaller-2.3.3.exe)
 
 Or, if you downloaded the archive:
 
@@ -47,6 +67,12 @@ expand on the above instructions, please report the issue at http://github.com/t
 
 On Ubuntu, the dependencies can be satisfied by installing the following packages:
 
+18.04 and onwards
+    
+    $ sudo apt-get install libcurl4 libcurl3-gnutls libcurl4-openssl-dev
+
+< 18.04
+
     $ sudo apt-get install libcurl3 libcurl3-gnutls libcurl4-openssl-dev
 
 On RedHat:

data/Rakefile

@@ -57,22 +57,20 @@ MAKEOPTS = ENV['MAKE_OPTS'] || ''
 CURB_SO = "ext/curb_core.#{(defined?(RbConfig) ? RbConfig : Config)::MAKEFILE_CONFIG['DLEXT']}"
 
 file 'ext/Makefile' => 'ext/extconf.rb' do
-  Dir.chdir('ext') do
-    shell('ruby', 'extconf.rb', ENV['EXTCONF_OPTS'].to_s, live_stdout: STDOUT)
-  end
+  shell(['ruby', 'extconf.rb', ENV['EXTCONF_OPTS'].to_s],
+        { :live_stdout => STDOUT , :cwd => "#{Dir.pwd}/ext" }
+       ).error!
 end
 
 def make(target = '')
-  Dir.chdir('ext') do 
-    pid = system("#{MAKECMD} #{MAKEOPTS} #{target}")
-    $?.exitstatus
-  end    
+  shell(["#{MAKECMD}", "#{MAKEOPTS}", "#{target}"].reject(&:empty?),
+        { :live_stdout => STDOUT, :cwd => "#{Dir.pwd}/ext" }
+       ).error!
 end
 
 # Let make handle dependencies between c/o/so - we'll just run it. 
 file CURB_SO => (['ext/Makefile'] + Dir['ext/*.c'] + Dir['ext/*.h']) do
-  m = make
-  fail "Make failed (status #{m})" unless m == 0
+  make
 end
 
 desc "Compile the shared object"
@@ -80,8 +78,7 @@ task :compile => [CURB_SO]
 
 desc "Install to your site_ruby directory"
 task :install do
-  m = make 'install' 
-  fail "Make install failed (status #{m})" unless m == 0
+  make 'install'
 end
 
 # Test Tasks ---------------------------------------------------------
@@ -186,7 +183,7 @@ else
     spec_source = File.read File.join(File.dirname(__FILE__),'curb.gemspec')
     spec = nil
     # see: http://gist.github.com/16215
-    Thread.new { spec = eval("$SAFE = 3\n#{spec_source}") }.join
+    Thread.new { spec = eval("#{spec_source}") }.join
     spec.validate
     Gem::Package.build(spec)
   end

data/ext/banned.h

@@ -0,0 +1,32 @@
+#ifndef BANNED_H
+#define BANNED_H
+
+/*
+ * This header lists functions that have been banned from our code base,
+ * because they're too easy to misuse (and even if used correctly,
+ * complicate audits). Including this header turns them into compile-time
+ * errors.
+ */
+
+#define BANNED(func) sorry_##func##_is_a_banned_function
+
+#undef strcpy
+#define strcpy(x,y) BANNED(strcpy)
+#undef strcat
+#define strcat(x,y) BANNED(strcat)
+#undef strncpy
+#define strncpy(x,y,n) BANNED(strncpy)
+#undef strncat
+#define strncat(x,y,n) BANNED(strncat)
+
+#undef sprintf
+#undef vsprintf
+#ifdef HAVE_VARIADIC_MACROS
+#define sprintf(...) BANNED(sprintf)
+#define vsprintf(...) BANNED(vsprintf)
+#else
+#define sprintf(buf,fmt,arg) BANNED(sprintf)
+#define vsprintf(buf,fmt,arg) BANNED(sprintf)
+#endif
+
+#endif /* BANNED_H */

data/ext/curb.c

@@ -292,18 +292,26 @@ void Init_curb_core() {
 #endif
 
 #ifdef CURL_VERSION_SSL
-  rb_define_const(mCurl, "CURL_SSLVERSION_DEFAULT", LONG2NUM(CURL_SSLVERSION_DEFAULT));
+  rb_define_const(mCurl, "CURL_SSLVERSION_DEFAULT",     LONG2NUM(CURL_SSLVERSION_DEFAULT));
+  rb_define_const(mCurl, "CURL_SSLVERSION_MAX_DEFAULT", LONG2NUM(CURL_SSLVERSION_MAX_DEFAULT));
   rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1",   LONG2NUM(CURL_SSLVERSION_TLSv1));
   rb_define_const(mCurl, "CURL_SSLVERSION_SSLv2",   LONG2NUM(CURL_SSLVERSION_SSLv2));
   rb_define_const(mCurl, "CURL_SSLVERSION_SSLv3",   LONG2NUM(CURL_SSLVERSION_SSLv3));
 #if HAVE_CURL_SSLVERSION_TLSV1_0
-  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_0",   LONG2NUM(CURL_SSLVERSION_TLSv1_0));
+  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_0",     LONG2NUM(CURL_SSLVERSION_TLSv1_0));
+  rb_define_const(mCurl, "CURL_SSLVERSION_MAX_TLSv1_0", LONG2NUM(CURL_SSLVERSION_MAX_TLSv1_0));
 #endif
 #if HAVE_CURL_SSLVERSION_TLSV1_1
-  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_1",   LONG2NUM(CURL_SSLVERSION_TLSv1_1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_1",     LONG2NUM(CURL_SSLVERSION_TLSv1_1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_MAX_TLSv1_1", LONG2NUM(CURL_SSLVERSION_MAX_TLSv1_1));
 #endif
 #if HAVE_CURL_SSLVERSION_TLSV1_2
-  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_2",   LONG2NUM(CURL_SSLVERSION_TLSv1_2));
+  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_2",     LONG2NUM(CURL_SSLVERSION_TLSv1_2));
+  rb_define_const(mCurl, "CURL_SSLVERSION_MAX_TLSv1_2", LONG2NUM(CURL_SSLVERSION_MAX_TLSv1_2));
+#endif
+#if HAVE_CURL_SSLVERSION_TLSV1_3
+  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_3",     LONG2NUM(CURL_SSLVERSION_TLSv1_3));
+  rb_define_const(mCurl, "CURL_SSLVERSION_MAX_TLSv1_3", LONG2NUM(CURL_SSLVERSION_MAX_TLSv1_3));
 #endif
 
   rb_define_const(mCurl, "CURL_USESSL_CONTROL", LONG2NUM(CURB_FTPSSL_CONTROL));
@@ -316,13 +324,20 @@ void Init_curb_core() {
   rb_define_const(mCurl, "CURL_SSLVERSION_SSLv2",   LONG2NUM(-1));
   rb_define_const(mCurl, "CURL_SSLVERSION_SSLv3",   LONG2NUM(-1));
 #if HAVE_CURL_SSLVERSION_TLSv1_0
-  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_0", LONG2NUM(-1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_0",     LONG2NUM(-1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_MAX_TLSv1_0", LONG2NUM(-1));
 #endif
 #if HAVE_CURL_SSLVERSION_TLSv1_1
-  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_1", LONG2NUM(-1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_1",     LONG2NUM(-1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_MAX_TLSv1_1", LONG2NUM(-1));
 #endif
 #if HAVE_CURL_SSLVERSION_TLSv1_2
-  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_2", LONG2NUM(-1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_2",     LONG2NUM(-1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_MAX_TLSv1_2", LONG2NUM(-1));
+#endif
+#if HAVE_CURL_SSLVERSION_TLSv1_3
+  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_3",     LONG2NUM(-1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_MAX_TLSv1_3", LONG2NUM(-1));
 #endif
 
   rb_define_const(mCurl, "CURL_USESSL_CONTROL", LONG2NUM(-1));
@@ -925,12 +940,19 @@ void Init_curb_core() {
 #endif
 #if HAVE_CURL_SSLVERSION_TLSv1_0
   CURB_DEFINE(CURL_SSLVERSION_TLSv1_0);
+  CURB_DEFINE(CURL_SSLVERSION_MAX_TLSv1_0);
 #endif
 #if HAVE_CURL_SSLVERSION_TLSv1_1
   CURB_DEFINE(CURL_SSLVERSION_TLSv1_1);
+  CURB_DEFINE(CURL_SSLVERSION_MAX_TLSv1_1);
 #endif
 #if HAVE_CURL_SSLVERSION_TLSv1_2
   CURB_DEFINE(CURL_SSLVERSION_TLSv1_2);
+  CURB_DEFINE(CURL_SSLVERSION_MAX_TLSv1_2);
+#endif
+#if HAVE_CURL_SSLVERSION_TLSv1_3
+  CURB_DEFINE(CURL_SSLVERSION_TLSv1_3);
+  CURB_DEFINE(CURL_SSLVERSION_MAX_TLSv1_3);
 #endif
 #if HAVE_CURLOPT_SSL_VERIFYPEER
   CURB_DEFINE(CURLOPT_SSL_VERIFYPEER);
@@ -1040,6 +1062,132 @@ void Init_curb_core() {
   CURB_DEFINE(CURLOPT_PIPEWAIT);
 #endif
 
+#if HAVE_CURLOPT_TCP_KEEPALIVE
+  CURB_DEFINE(CURLOPT_TCP_KEEPALIVE);
+  CURB_DEFINE(CURLOPT_TCP_KEEPIDLE);
+  CURB_DEFINE(CURLOPT_TCP_KEEPINTVL);
+#endif
+
+#if HAVE_CURLOPT_HAPROXYPROTOCOL
+  CURB_DEFINE(CURLOPT_HAPROXYPROTOCOL);
+#endif
+
+#if HAVE_CURLPROTO_RTMPTE
+  CURB_DEFINE(CURLPROTO_RTMPTE);
+#endif
+
+#if HAVE_CURLPROTO_RTMPTS
+  CURB_DEFINE(CURLPROTO_RTMPTS);
+#endif
+
+#if HAVE_CURLPROTO_SMBS
+  CURB_DEFINE(CURLPROTO_SMBS);
+#endif
+
+#if HAVE_CURLPROTO_LDAP
+  CURB_DEFINE(CURLPROTO_LDAP);
+#endif
+
+#if HAVE_CURLPROTO_FTP
+  CURB_DEFINE(CURLPROTO_FTP);
+#endif
+
+#if HAVE_CURLPROTO_SMTPS
+  CURB_DEFINE(CURLPROTO_SMTPS);
+#endif
+
+#if HAVE_CURLPROTO_HTTP
+  CURB_DEFINE(CURLPROTO_HTTP);
+#endif
+
+#if HAVE_CURLPROTO_SMTP
+  CURB_DEFINE(CURLPROTO_SMTP);
+#endif
+
+#if HAVE_CURLPROTO_TFTP
+  CURB_DEFINE(CURLPROTO_TFTP);
+#endif
+
+#if HAVE_CURLPROTO_LDAPS
+  CURB_DEFINE(CURLPROTO_LDAPS);
+#endif
+
+#if HAVE_CURLPROTO_IMAPS
+  CURB_DEFINE(CURLPROTO_IMAPS);
+#endif
+
+#if HAVE_CURLPROTO_SCP
+  CURB_DEFINE(CURLPROTO_SCP);
+#endif
+
+#if HAVE_CURLPROTO_SFTP
+  CURB_DEFINE(CURLPROTO_SFTP);
+#endif
+
+#if HAVE_CURLPROTO_TELNET
+  CURB_DEFINE(CURLPROTO_TELNET);
+#endif
+
+#if HAVE_CURLPROTO_FILE
+  CURB_DEFINE(CURLPROTO_FILE);
+#endif
+
+#if HAVE_CURLPROTO_FTPS
+  CURB_DEFINE(CURLPROTO_FTPS);
+#endif
+
+#if HAVE_CURLPROTO_HTTPS
+  CURB_DEFINE(CURLPROTO_HTTPS);
+#endif
+
+#if HAVE_CURLPROTO_IMAP
+  CURB_DEFINE(CURLPROTO_IMAP);
+#endif
+
+#if HAVE_CURLPROTO_POP3
+  CURB_DEFINE(CURLPROTO_POP3);
+#endif
+
+#if HAVE_CURLPROTO_GOPHER
+  CURB_DEFINE(CURLPROTO_GOPHER);
+#endif
+
+#if HAVE_CURLPROTO_DICT
+  CURB_DEFINE(CURLPROTO_DICT);
+#endif
+
+#if HAVE_CURLPROTO_SMB
+  CURB_DEFINE(CURLPROTO_SMB);
+#endif
+
+#if HAVE_CURLPROTO_RTMP
+  CURB_DEFINE(CURLPROTO_RTMP);
+#endif
+
+#if HAVE_CURLPROTO_ALL
+  CURB_DEFINE(CURLPROTO_ALL);
+#endif
+
+#if HAVE_CURLPROTO_RTMPE
+  CURB_DEFINE(CURLPROTO_RTMPE);
+#endif
+
+#if HAVE_CURLPROTO_RTMPS
+  CURB_DEFINE(CURLPROTO_RTMPS);
+#endif
+
+#if HAVE_CURLPROTO_RTMPT
+  CURB_DEFINE(CURLPROTO_RTMPT);
+#endif
+
+#if HAVE_CURLPROTO_POP3S
+  CURB_DEFINE(CURLPROTO_POP3S);
+#endif
+
+#if HAVE_CURLPROTO_RTSP
+  CURB_DEFINE(CURLPROTO_RTSP);
+#endif
+
 #if LIBCURL_VERSION_NUM >= 0x072B00 /* 7.43.0 */
   CURB_DEFINE(CURLPIPE_NOTHING);
   CURB_DEFINE(CURLPIPE_HTTP1);

data/ext/curb.h

@@ -9,8 +9,16 @@
 #define __CURB_H
 
 #include <ruby.h>
+
+#ifdef HAVE_RUBY_IO_H
+#include "ruby/io.h"
+#else
+#include "rubyio.h" // ruby 1.8
+#endif
+
 #include <curl/curl.h>
 
+#include "banned.h"
 #include "curb_config.h"
 #include "curb_easy.h"
 #include "curb_errors.h"
@@ -20,11 +28,11 @@
 #include "curb_macros.h"
 
 // These should be managed from the Rake 'release' task.
-#define CURB_VERSION   "0.9.8"
-#define CURB_VER_NUM   908
-#define CURB_VER_MAJ   0
-#define CURB_VER_MIN   9
-#define CURB_VER_MIC   8
+#define CURB_VERSION   "1.0.0"
+#define CURB_VER_NUM   1000
+#define CURB_VER_MAJ   1
+#define CURB_VER_MIN   0
+#define CURB_VER_MIC   0
 #define CURB_VER_PATCH 0
 
 
@@ -41,6 +49,11 @@
   #define RHASH_SIZE(hash) RHASH(hash)->tbl->num_entries
 #endif
 
+// ruby 1.8 does not provide the macro
+#ifndef DBL2NUM
+  #define DBL2NUM(dbl) rb_float_new(dbl)
+#endif
+
 extern VALUE mCurl;
 
 extern void Init_curb_core();

data/ext/curb_easy.c

@@ -25,6 +25,12 @@ static VALUE rbstrAmp;
 
 VALUE cCurlEasy;
 
+// for Ruby 1.8
+#ifndef HAVE_RB_IO_STDIO_FILE
+static FILE * rb_io_stdio_file(rb_io_t *fptr) {
+  return fptr->f;
+}
+#endif
 
 /* ================== CURL HANDLER FUNCS ==============*/
 
@@ -247,6 +253,7 @@ static void ruby_curl_easy_free(ruby_curl_easy *rbce) {
     curl_easy_setopt(rbce->curl, CURLOPT_PROGRESSFUNCTION, NULL);
     curl_easy_setopt(rbce->curl, CURLOPT_NOPROGRESS, 1);
     curl_easy_cleanup(rbce->curl);
+    rbce->curl = NULL;
   }
 }
 
@@ -261,6 +268,8 @@ void curl_easy_free(ruby_curl_easy *rbce) {
 static void ruby_curl_easy_zero(ruby_curl_easy *rbce) {
   rbce->opts = rb_hash_new();
 
+  memset(rbce->err_buf, 0, sizeof(rbce->err_buf));
+
   rbce->curl_headers = NULL;
   rbce->curl_proxy_headers = NULL;
   rbce->curl_ftp_commands = NULL;
@@ -348,8 +357,9 @@ static VALUE ruby_curl_easy_initialize(int argc, VALUE *argv, VALUE self) {
 
   ruby_curl_easy_zero(rbce);
 
-  rb_easy_set("url", url);
+  curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, &rbce->err_buf);
 
+  rb_easy_set("url", url);
 
   /* set the pointer to the curl handle */
   ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)self);
@@ -385,6 +395,8 @@ static VALUE ruby_curl_easy_clone(VALUE self) {
   newrbce->curl_ftp_commands = NULL;
   newrbce->curl_resolve = NULL;
 
+  curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, &rbce->err_buf);
+
   return Data_Wrap_Struct(cCurlEasy, curl_easy_mark, curl_easy_free, newrbce);
 }
 
@@ -454,7 +466,9 @@ static VALUE ruby_curl_easy_reset(VALUE self) {
   curl_easy_reset(rbce->curl);
   ruby_curl_easy_zero(rbce);
 
-  /* rest clobbers the private setting, so reset it to 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*)self);
   if (ecode != CURLE_OK) {
     raise_curl_easy_error_exception(ecode);
@@ -1532,6 +1546,7 @@ static VALUE ruby_curl_easy_password_get(VALUE self, VALUE password) {
  *   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);
@@ -2543,7 +2558,7 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
  *
  * Clean up a connection
  *
- * Always returns Qtrue.
+ * Always returns Qnil.
  */
 VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce ) {
 
@@ -2583,6 +2598,9 @@ VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce ) {
     curl_easy_setopt(curl, CURLOPT_INFILESIZE, 0);
   }
 
+  // set values on cleanup to nil
+  rb_easy_del("multi");
+
   return Qnil;
 }
 
@@ -2597,6 +2615,8 @@ static VALUE ruby_curl_easy_perform_verb_str(VALUE self, const char *verb) {
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl = rbce->curl;
 
+  memset(rbce->err_buf, 0, sizeof(rbce->err_buf));
+
   curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, verb);
 
   retval = rb_funcall(self, rb_intern("perform"), 0);
@@ -2662,6 +2682,8 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl = rbce->curl;
 
+  memset(rbce->err_buf, 0, sizeof(rbce->err_buf));
+
   curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, NULL);
 
   if (rbce->multipart_form_post) {
@@ -2733,6 +2755,8 @@ static VALUE ruby_curl_easy_perform_put(VALUE self, VALUE data) {
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl = rbce->curl;
 
+  memset(rbce->err_buf, 0, sizeof(rbce->err_buf));
+
   curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, NULL);
   ruby_curl_easy_put_data_set(self, data);
 
@@ -2945,7 +2969,7 @@ static VALUE ruby_curl_easy_connect_time_get(VALUE self) {
  * 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
- * pippelining where the pretransfer time can be delayed due to waits in line
+ * pipelining where the pretransfer time can be delayed due to waits in line
  * for the pipeline and more.
  */
 #if defined(HAVE_CURLINFO_APPCONNECT_TIME)
@@ -3438,6 +3462,21 @@ static VALUE ruby_curl_easy_last_result(VALUE self) {
   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;
+  Data_Get_Struct(self, ruby_curl_easy, 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
@@ -3447,6 +3486,7 @@ static VALUE ruby_curl_easy_last_result(VALUE self) {
 static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
   ruby_curl_easy *rbce;
   long option = NUM2LONG(opt);
+  rb_io_t *open_f_ptr;
 
   Data_Get_Struct(self, ruby_curl_easy, rbce);
 
@@ -3535,6 +3575,9 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
   case CURLOPT_TCP_NODELAY: {
     curl_easy_setopt(rbce->curl, CURLOPT_TCP_NODELAY, NUM2LONG(val));
     } break;
+  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, NUM2LONG(val));
     } break;
@@ -3571,6 +3614,38 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
   case CURLOPT_MAXFILESIZE:
     curl_easy_setopt(rbce->curl, CURLOPT_MAXFILESIZE, NUM2LONG(val));
     break;
+#endif
+#if 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
+#if 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));
+    break;
+  case CURLOPT_PROTOCOLS:
+  case CURLOPT_REDIR_PROTOCOLS:
+    curl_easy_setopt(rbce->curl, option, NUM2LONG(val));
+    break;
+#if HAVE_CURLOPT_SSL_SESSIONID_CACHE
+  case CURLOPT_SSL_SESSIONID_CACHE:
+    curl_easy_setopt(rbce->curl, CURLOPT_SSL_SESSIONID_CACHE, NUM2LONG(val));
+    break;
 #endif
   default:
     rb_raise(rb_eTypeError, "Curb unsupported option");
@@ -3879,6 +3954,7 @@ 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_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);

data/ext/curb_easy.h

@@ -36,6 +36,9 @@ typedef struct {
   /* The handler */
   CURL *curl;
 
+  /* Buffer for error details from CURLOPT_ERRORBUFFER */
+  char err_buf[CURL_ERROR_SIZE];
+
   VALUE opts; /* rather then allocate everything we might need to store, allocate a Hash and only store objects we actually use... */
   VALUE multi; /* keep a multi handle alive for each easy handle not being used by a multi handle.  This improves easy performance when not within a multi context */
 

data/ext/extconf.rb

@@ -18,6 +18,8 @@ elsif !have_library('curl') or !have_header('curl/curl.h')
   fail <<-EOM
   Can't find libcurl or curl/curl.h
 
+  Make sure development libs (ie libcurl4-openssl-dev) are installed on the system.
+
   Try passing --with-curl-dir or --with-curl-lib and --with-curl-include
   options to extconf.
   EOM
@@ -59,6 +61,9 @@ def have_constant(name)
   end
 end
 
+have_constant "curlopt_tcp_keepalive"
+have_constant "curlopt_tcp_keepidle"
+have_constant "curlopt_tcp_keepintvl"
 have_constant "curlinfo_appconnect_time"
 have_constant "curlinfo_redirect_time"
 have_constant "curlinfo_response_code"
@@ -153,6 +158,8 @@ have_func("curl_multi_timeout")
 have_func("curl_multi_fdset")
 have_func("curl_multi_perform")
 
+have_constant "curlopt_haproxyprotocol"
+
 # constants
 have_constant "curlopt_interleavefunction"
 have_constant "curlopt_interleavedata"
@@ -336,6 +343,9 @@ have_constant :CURL_SSLVERSION_TLSv1_0
 have_constant :CURL_SSLVERSION_TLSv1_1
 have_constant :CURL_SSLVERSION_TLSv1_2
 
+# Added in 7.52.0
+have_constant :CURL_SSLVERSION_TLSv1_3
+
 have_constant "curlopt_ssl_verifypeer"
 have_constant "curlopt_cainfo"
 have_constant "curlopt_issuercert"
@@ -395,6 +405,37 @@ have_constant "curlopt_path_as_is"
 # added in 7.43.0
 have_constant "curlopt_pipewait"
 
+# protocol constants
+have_constant "curlproto_all"
+have_constant "curlproto_dict"
+have_constant "curlproto_file"
+have_constant "curlproto_ftp"
+have_constant "curlproto_ftps"
+have_constant "curlproto_gopher"
+have_constant "curlproto_http"
+have_constant "curlproto_https"
+have_constant "curlproto_imap"
+have_constant "curlproto_imaps"
+have_constant "curlproto_ldap"
+have_constant "curlproto_ldaps"
+have_constant "curlproto_pop3"
+have_constant "curlproto_pop3s"
+have_constant "curlproto_rtmp"
+have_constant "curlproto_rtmpe"
+have_constant "curlproto_rtmps"
+have_constant "curlproto_rtmpt"
+have_constant "curlproto_rtmpte"
+have_constant "curlproto_rtmpts"
+have_constant "curlproto_rtsp"
+have_constant "curlproto_scp"
+have_constant "curlproto_sftp"
+have_constant "curlproto_smb"
+have_constant "curlproto_smbs"
+have_constant "curlproto_smtp"
+have_constant "curlproto_smtps"
+have_constant "curlproto_telnet"
+have_constant "curlproto_tftp"
+
 if try_compile('int main() { return 0; }','-Wall')
   $CFLAGS << ' -Wall'
 end
@@ -422,6 +463,8 @@ test_for("curl_easy_escape", "CURL_EASY_ESCAPE", %{
 
 have_func('rb_thread_blocking_region')
 have_header('ruby/thread.h') && have_func('rb_thread_call_without_gvl', 'ruby/thread.h')
+have_header('ruby/io.h')
+have_func('rb_io_stdio_file')
 
 create_header('curb_config.h')
 create_makefile('curb_core')

data/lib/curb.rb

@@ -1 +1,2 @@
+# frozen_string_literal: true
 require 'curl'

data/lib/curl/easy.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Curl
   class Easy
 
@@ -68,9 +69,15 @@ module Curl
       ret = self.multi.perform
       self.multi.remove self
 
+      if Curl::Multi.autoclose
+        self.multi.close
+        self.multi = nil
+      end
+
       if self.last_result != 0 && self.on_failure.nil?
-        error = Curl::Easy.error(self.last_result)
-        raise error.first.new(self.head)
+        (err_class, err_summary) = Curl::Easy.error(self.last_result)
+        err_detail = self.last_error
+        raise err_class.new([err_summary, err_detail].compact.join(": "))
       end
 
       ret

data/lib/curl/multi.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Curl
   class Multi
     class << self
@@ -143,7 +144,7 @@ module Curl
 
         max_connects.times do
           conf = urls_with_config.pop
-          add_free_handle.call conf, nil
+          add_free_handle.call(conf, nil) if conf
           break if urls_with_config.empty?
         end
 
@@ -152,7 +153,7 @@ module Curl
           if urls_with_config.size > 0 && free_handles.size > 0
             easy = free_handles.pop
             conf = urls_with_config.pop
-            add_free_handle.call conf, easy
+            add_free_handle.call(conf, easy) if conf
           end
         end
 

data/lib/curl.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'curb_core'
 require 'curl/easy'
 require 'curl/multi'

data/tests/helper.rb

@@ -2,6 +2,7 @@
 # Copyright (c)2006 Ross Bamford. See LICENSE.
 $CURB_TESTING = true
 require 'uri'
+require 'stringio'
 
 $TOPDIR = File.expand_path(File.join(File.dirname(__FILE__), '..'))
 $EXTDIR = File.join($TOPDIR, 'ext')
@@ -142,7 +143,6 @@ module TestServerMethods
   def server_setup(port=9129,servlet=TestServlet)
     @__port = port
     if (@server ||= nil).nil? and !File.exist?(locked_file)
-
       File.open(locked_file,'w') {|f| f << 'locked' }
       if TEST_SINGLE_THREADED
         rd, wr = IO.pipe

data/tests/tc_curl_easy.rb

@@ -10,6 +10,66 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     Curl.reset
   end
 
+  def test_curlopt_stderr_with_file
+    # does not work with Tempfile directly
+    path = Tempfile.new('curb_test_curlopt_stderr').path
+    File.open(path, 'w') do |file|
+      easy = Curl::Easy.new(TestServlet.url)
+      easy.verbose = true
+      easy.setopt(Curl::CURLOPT_STDERR, file)
+      easy.perform
+    end
+    output = File.read(path)
+
+    assert_match(/HTTP\/1\.1\ 200\ OK(?:\ )?/, output)
+    assert_match('Host: 127.0.0.1:9129', output)
+  end
+
+  def test_curlopt_stderr_with_io
+    path = Tempfile.new('curb_test_curlopt_stderr').path
+    fd = IO.sysopen(path, 'w')
+    io = IO.for_fd(fd)
+
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.verbose = true
+    easy.setopt(Curl::CURLOPT_STDERR, io)
+    easy.perform
+
+
+    output = File.read(path)
+
+    assert_match(output, 'HTTP/1.1 200 OK')
+    assert_match(output, 'Host: 127.0.0.1:9129')
+  end
+
+  def test_curlopt_stderr_fails_with_tempdir
+    Tempfile.open('curb_test_curlopt_stderr') do |tempfile|
+      easy = Curl::Easy.new(TestServlet.url)
+
+      assert_raise(TypeError) do
+        easy.setopt(Curl::CURLOPT_STDERR, tempfile)
+      end
+    end
+  end
+
+  def test_curlopt_stderr_fails_with_stringio
+    stringio = StringIO.new
+    easy = Curl::Easy.new(TestServlet.url)
+
+    assert_raise(TypeError) do
+      easy.setopt(Curl::CURLOPT_STDERR, stringio)
+    end
+  end
+
+  def test_curlopt_stderr_fails_with_string
+    string = String.new
+    easy = Curl::Easy.new(TestServlet.url)
+
+    assert_raise(TypeError) do
+      easy.setopt(Curl::CURLOPT_STDERR, string)
+    end
+  end
+
   def test_exception
     begin
       Curl.get('NOT_FOUND_URL')

data/tests/tc_curl_maxfilesize.rb

@@ -0,0 +1,12 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class TestCurbCurlMaxFileSize < Test::Unit::TestCase
+  def setup
+    @easy = Curl::Easy.new
+  end
+
+  def test_maxfilesize
+    @easy.set(Curl::CURLOPT_MAXFILESIZE, 5000000)
+  end
+
+end

data/tests/tc_curl_multi.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require 'set'
 
 class TestCurbCurlMulti < Test::Unit::TestCase
   def teardown
@@ -9,19 +10,58 @@ class TestCurbCurlMulti < Test::Unit::TestCase
   # for https://github.com/taf2/curb/issues/277
   # must connect to an external
   def test_connection_keepalive
-    # 0123456 default & reserved RubyVM. It will probably include 7 from Dir.glob
-    open_fds = lambda do 
-      `/usr/sbin/lsof -p #{Process.pid} | egrep "TCP|UDP" | wc -l`.strip.to_i
+    # this test fails with libcurl 7.22.0. I didn't investigate, but it may be related
+    # to CURLOPT_MAXCONNECTS bug fixed in 7.30.0:
+    # https://github.com/curl/curl/commit/e87e76e2dc108efb1cae87df496416f49c55fca0
+    omit("Skip, libcurl too old (< 7.22.0)") if Curl::CURL_VERSION.split('.')[1].to_i <= 22
+
+    @server.shutdown if @server
+    @test_thread.kill if @test_thread
+    @server = nil
+    File.unlink(locked_file)
+    Curl::Multi.autoclose = true
+    assert Curl::Multi.autoclose
+# XXX: thought maybe we can clean house here to have the full suite pass in osx... but for now running this test in isolate does pass
+#      additionally, if ss allows this to pass on linux without requesting google i think this is a good trade off... leaving some of the thoughts below
+#      in hopes that coming back to this later will find it and remember how to fix it
+#    types = Set.new
+#    close_types = Set.new([TCPServer,TCPSocket,Socket,Curl::Multi, Curl::Easy,WEBrick::Log])
+#    ObjectSpace.each_object {|o|
+#      if o.respond_to?(:close)
+#        types << o.class
+#      end
+#      if close_types.include?(o.class)
+#        o.close
+#      end
+#    }
+    #puts "unique types: #{types.to_a.join("\n")}"
+    GC.start # cleanup FDs left over from other tests
+    server_setup
+    GC.start # cleanup FDs left over from other tests
+
+    if `which ss`.strip.size == 0
+      # osx need lsof still :(
+      open_fds = lambda do
+        out = `/usr/sbin/lsof -p #{Process.pid} | egrep "TCP|UDP"`# | egrep ':#{TestServlet.port} ' | egrep ESTABLISHED`# | wc -l`.strip.to_i
+        #puts out.lines.join("\n")
+        out.lines.size
+      end
+    else
+      ss = `which ss`.strip
+      open_fds = lambda do
+        `#{ss} -n4 state established dport = :#{TestServlet.port} | wc -l`.strip.to_i
+      end
     end
+    Curl::Multi.autoclose = false
     before_open = open_fds.call
+    #puts "before_open: #{before_open.inspect}"
     assert !Curl::Multi.autoclose
     multi = Curl::Multi.new
     multi.max_connects = 1 # limit to 1 connection within the multi handle
 
     did_complete = false
     5.times do |n|
-      # NOTE: we use google here because connecting to our TEST_URL as a local host address appears to not register correctly with lsof as a socket... if anyone knows a better way would be great to not have an external dependency here in the test
-      easy = Curl::Easy.new("http://google.com/") do |curl|
+      easy = Curl::Easy.new(TestServlet.url) do |curl|
         curl.timeout = 5 # ensure we don't hang for ever connecting to an external host
         curl.on_complete {
           did_complete = true
@@ -33,18 +73,19 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     multi.perform
     assert did_complete
     after_open = open_fds.call
-    assert_equal (after_open - before_open), 1, "with max connections set to 1 at this point the connection to google should still be open"
+    #puts "after_open: #{after_open} before_open: #{before_open.inspect}"
+    assert_equal 1, (after_open - before_open), "with max connections set to 1 at this point the connection to google should still be open"
     multi.close
 
     after_open = open_fds.call
-    assert_equal (after_open - before_open), 0, "after closing the multi handle all connections should be closed"
+    #puts "after_open: #{after_open} before_open: #{before_open.inspect}"
+    assert_equal 0, (after_open - before_open), "after closing the multi handle all connections should be closed"
 
     Curl::Multi.autoclose = true
     multi = Curl::Multi.new
     did_complete = false
     5.times do |n|
-      # NOTE: we use google here because connecting to our TEST_URL as a local host address appears to not register correctly with lsof as a socket... if anyone knows a better way would be great to not have an external dependency here in the test
-      easy = Curl::Easy.new("http://google.com/") do |curl|
+      easy = Curl::Easy.new(TestServlet.url) do |curl|
         curl.timeout = 5 # ensure we don't hang for ever connecting to an external host
         curl.on_complete {
           did_complete = true
@@ -56,7 +97,8 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     multi.perform
     assert did_complete
     after_open = open_fds.call
-    assert_equal (after_open - before_open), 0, "auto close the connections"
+    #puts "after_open: #{after_open} before_open: #{before_open.inspect}"
+    assert_equal 0, (after_open - before_open), "auto close the connections"
   ensure
     Curl::Multi.autoclose = false # restore default
   end

data/tests/tc_curl_postfield.rb

@@ -2,63 +2,63 @@ require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
 
 class TestCurbCurlPostfield < Test::Unit::TestCase
   def test_private_new
-    assert_raise(NoMethodError) { Curl::PostField.new }  
+    assert_raise(NoMethodError) { Curl::PostField.new }
   end
-  
+
   def test_new_content_01
     pf = Curl::PostField.content('foo', 'bar')
-    
+
     assert_equal 'foo', pf.name
     assert_equal 'bar', pf.content
     assert_nil pf.content_type
     assert_nil pf.local_file
-    assert_nil pf.remote_file    
+    assert_nil pf.remote_file
     assert_nil pf.set_content_proc
   end
-    
+
   def test_new_content_02
     pf = Curl::PostField.content('foo', 'bar', 'text/html')
-    
+
     assert_equal 'foo', pf.name
     assert_equal 'bar', pf.content
     assert_equal 'text/html', pf.content_type
     assert_nil pf.local_file
     assert_nil pf.remote_file
-    assert_nil pf.set_content_proc    
-  end    
-  
+    assert_nil pf.set_content_proc
+  end
+
   def test_new_content_03
     l = lambda { |field| "never gets run" }
     pf = Curl::PostField.content('foo', &l)
-    
+
     assert_equal 'foo', pf.name
     assert_nil pf.content
     assert_nil pf.content_type
     assert_nil pf.local_file
     assert_nil pf.remote_file
-    
+
     # N.B. This doesn't just get the proc, but also removes it.
     assert_equal l, pf.set_content_proc
-  end    
+  end
 
   def test_new_content_04
     l = lambda { |field| "never gets run" }
     pf = Curl::PostField.content('foo', 'text/html', &l)
-    
+
     assert_equal 'foo', pf.name
     assert_nil pf.content
     assert_equal 'text/html', pf.content_type
     assert_nil pf.local_file
     assert_nil pf.remote_file
-    
+
     # N.B. This doesn't just get the proc, but also removes it.
     assert_equal l, pf.set_content_proc
-  end    
+  end
 
 
   def test_new_file_01
     pf = Curl::PostField.file('foo', 'localname')
-    
+
     assert_equal 'foo', pf.name
     assert_equal 'localname', pf.local_file
     assert_equal 'localname', pf.remote_file
@@ -67,44 +67,44 @@ class TestCurbCurlPostfield < Test::Unit::TestCase
     assert_nil pf.content
     assert_nil pf.set_content_proc
   end
-    
+
   def test_new_file_02
     pf = Curl::PostField.file('foo', 'localname', 'remotename')
-    
+
     assert_equal 'foo', pf.name
     assert_equal 'localname', pf.local_file
     assert_equal 'remotename', pf.remote_file
     assert_nil pf.content_type
     assert_nil pf.content
     assert_nil pf.set_content_proc
-  end    
-  
+  end
+
   def test_new_file_03
     l = lambda { |field| "never gets run" }
     pf = Curl::PostField.file('foo', 'remotename', &l)
-    
+
     assert_equal 'foo', pf.name
     assert_equal 'remotename', pf.remote_file
     assert_nil pf.local_file
     assert_nil pf.content_type
     assert_nil pf.content
-    
+
     # N.B. This doesn't just get the proc, but also removes it.
     assert_equal l, pf.set_content_proc
-  end    
+  end
 
   def test_new_file_04
     assert_raise(ArgumentError) do
       # no local name, no block
       Curl::PostField.file('foo')
     end
-    
+
     assert_raise(ArgumentError) do
       # no remote name with block
       Curl::PostField.file('foo') { |field| "never runs" }
     end
   end
-  
+
   def test_new_file_05
     # local gets ignored when supplying a block, but remote
     # is still set up properly.
@@ -118,15 +118,15 @@ class TestCurbCurlPostfield < Test::Unit::TestCase
     assert_nil pf.content
 
     assert_equal l, pf.set_content_proc
-  end    
-  
+  end
+
   def test_to_s_01
-    pf = Curl::PostField.content('foo', 'bar')    
+    pf = Curl::PostField.content('foo', 'bar')
     assert_equal "foo=bar", pf.to_s
   end
 
   def test_to_s_02
-    pf = Curl::PostField.content('foo', 'bar ton')    
+    pf = Curl::PostField.content('foo', 'bar ton')
     assert_equal "foo=bar%20ton", pf.to_s
   end
 

data/tests/tc_curl_protocols.rb

@@ -0,0 +1,37 @@
+class TestCurbCurlProtocols < Test::Unit::TestCase
+  include TestServerMethods
+
+  def setup
+    @easy = Curl::Easy.new
+    @easy.set :protocols, Curl::CURLPROTO_HTTP | Curl::CURLPROTO_HTTPS
+    @easy.follow_location = true
+    server_setup
+  end
+
+  def test_protocol_allowed
+    @easy.set :url, "http://127.0.0.1:9129/this_file_does_not_exist.html"
+    @easy.perform
+    assert_equal 404, @easy.response_code
+  end
+
+  def test_protocol_denied
+    @easy.set :url, "gopher://google.com/"
+    assert_raises Curl::Err::UnsupportedProtocolError do
+      @easy.perform
+    end
+  end
+
+  def test_redir_protocol_allowed
+    @easy.set :url, TestServlet.url + "/redirect"
+    @easy.set :redir_protocols, Curl::CURLPROTO_HTTP
+    @easy.perform
+  end
+
+  def test_redir_protocol_denied
+    @easy.set :url, TestServlet.url + "/redirect"
+    @easy.set :redir_protocols, Curl::CURLPROTO_HTTPS
+    assert_raises Curl::Err::UnsupportedProtocolError do
+      @easy.perform
+    end
+  end
+end

data/tests/timeout.rb

@@ -17,9 +17,13 @@ class TestCurbTimeouts < Test::Unit::TestCase
   def test_overall_timeout_on_dead_transfer
     curl = Curl::Easy.new(wait_url(2))
     curl.timeout = 1
-    assert_raise(Curl::Err::TimeoutError) do
+    exception = assert_raise(Curl::Err::TimeoutError) do
       curl.http_get
     end
+    assert_match(
+      /^Timeout was reached: Operation timed out after/,
+      exception.message
+    )
   end
 
   def test_overall_timeout_ms_on_dead_transfer
@@ -44,16 +48,20 @@ class TestCurbTimeouts < Test::Unit::TestCase
     curl = Curl::Easy.new(serve_url(100, 2, 3))
     curl.timeout = 1
     # transfer is aborted despite data being exchanged
-    assert_raise(Curl::Err::TimeoutError) do
+    exception = assert_raise(Curl::Err::TimeoutError) do
       curl.http_get
     end
+    assert_match(
+      /^Timeout was reached: Operation timed out after/,
+      exception.message
+    )
   end
   
   def test_low_speed_time_on_slow_transfer
     curl = Curl::Easy.new(serve_url(100, 1, 3))
     curl.low_speed_time = 2
     # use default low_speed_limit of 1
-    assert true, curl.http_get
+    assert_equal true, curl.http_get
   end
   
   def test_low_speed_time_on_very_slow_transfer
@@ -63,18 +71,26 @@ class TestCurbTimeouts < Test::Unit::TestCase
     # XXX for some reason this test fails if low speed limit is not specified
     curl.low_speed_limit = 1
     # use default low_speed_limit of 1
-    assert_raise(Curl::Err::TimeoutError) do
+    exception = assert_raise(Curl::Err::TimeoutError) do
       curl.http_get
     end
+    assert_match(
+      /^Timeout was reached: Operation too slow/,
+      exception.message
+    )
   end
   
   def test_low_speed_limit_on_slow_transfer
     curl = Curl::Easy.new(serve_url(10, 1, 3))
     curl.low_speed_time = 2
     curl.low_speed_limit = 1000
-    assert_raise(Curl::Err::TimeoutError) do
+    exception = assert_raise(Curl::Err::TimeoutError) do
       curl.http_get
     end
+    assert_match(
+      /^Timeout was reached: Operation too slow/,
+      exception.message
+    )
   end
   
   def test_clearing_low_speed_time

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: curb
 version: !ruby/object:Gem::Version
-  version: 0.9.8
+  version: 1.0.0
 platform: ruby
 authors:
 - Ross Bamford
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-28 00:00:00.000000000 Z
+date: 2022-01-14 00:00:00.000000000 Z
 dependencies: []
 description: Curb (probably CUrl-RuBy or something) provides Ruby-language bindings
   for the libcurl(3), a fully-featured client-side URL transfer library. cURL and
@@ -26,6 +26,7 @@ files:
 - README.markdown
 - Rakefile
 - doc.rb
+- ext/banned.h
 - ext/curb.c
 - ext/curb.h
 - ext/curb_easy.c
@@ -65,14 +66,16 @@ files:
 - tests/tc_curl_easy.rb
 - tests/tc_curl_easy_resolve.rb
 - tests/tc_curl_easy_setopt.rb
+- tests/tc_curl_maxfilesize.rb
 - tests/tc_curl_multi.rb
 - tests/tc_curl_postfield.rb
+- tests/tc_curl_protocols.rb
 - tests/timeout.rb
 - tests/timeout_server.rb
 - tests/unittests.rb
-homepage: http://curb.rubyforge.org/
+homepage: https://github.com/taf2/curb
 licenses:
-- Ruby
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options:
@@ -92,35 +95,36 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: curb
-rubygems_version: 2.7.7
+rubygems_version: 3.3.3
 signing_key: 
 specification_version: 4
 summary: Ruby libcurl bindings
 test_files:
-- tests/tc_curl_multi.rb
 - tests/alltests.rb
-- tests/tc_curl_easy_setopt.rb
-- tests/tc_curl.rb
-- tests/bug_postfields_crash.rb
-- tests/bug_crash_on_progress.rb
-- tests/helper.rb
-- tests/bug_postfields_crash2.rb
-- tests/bug_require_last_or_segfault.rb
-- tests/timeout.rb
 - tests/bug_crash_on_debug.rb
-- tests/unittests.rb
-- tests/bug_issue102.rb
+- tests/bug_crash_on_progress.rb
 - tests/bug_curb_easy_blocks_ruby_threads.rb
-- tests/bug_multi_segfault.rb
+- tests/bug_curb_easy_post_with_string_no_content_length_header.rb
 - tests/bug_instance_post_differs_from_class_post.rb
+- tests/bug_issue102.rb
+- tests/bug_multi_segfault.rb
+- tests/bug_postfields_crash.rb
+- tests/bug_postfields_crash2.rb
+- tests/bug_require_last_or_segfault.rb
+- tests/bugtests.rb
+- tests/helper.rb
+- tests/mem_check.rb
 - tests/require_last_or_segfault_script.rb
-- tests/timeout_server.rb
+- tests/signals.rb
+- tests/tc_curl.rb
 - tests/tc_curl_download.rb
 - tests/tc_curl_easy.rb
-- tests/mem_check.rb
-- tests/tc_curl_postfield.rb
-- tests/bugtests.rb
 - tests/tc_curl_easy_resolve.rb
-- tests/signals.rb
-- tests/bug_curb_easy_post_with_string_no_content_length_header.rb
+- tests/tc_curl_easy_setopt.rb
+- tests/tc_curl_maxfilesize.rb
+- tests/tc_curl_multi.rb
+- tests/tc_curl_postfield.rb
+- tests/tc_curl_protocols.rb
+- tests/timeout.rb
+- tests/timeout_server.rb
+- tests/unittests.rb