curb 0.8.4 → 0.9.11

data/ext/curb.c

@@ -219,6 +219,22 @@ static VALUE ruby_curl_conv_q(VALUE mod) {
 #endif
 }
 
+/*
+ * call-seq:
+ *   Curl.http2?                                       => true or false
+ *
+ * Returns true if the installed libcurl was built with support for HTTP2.
+ * For libcurl versions < 7.33.0, always returns false.
+ */
+static VALUE ruby_curl_http2_q(VALUE mod) {
+#ifdef HAVE_CURL_VERSION_HTTP2
+  curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);
+  return((ver->features & CURL_VERSION_HTTP2) ? Qtrue : Qfalse);
+#else
+  return Qfalse;
+#endif
+}
+
 void Init_curb_core() {
   // TODO we need to call curl_global_cleanup at exit!
   curl_version_info_data *ver;
@@ -242,121 +258,156 @@ void Init_curb_core() {
   rb_define_const(mCurl, "CURL_LONG_VERSION", curllongver);
 
   /* Passed to on_debug handler to indicate that the data is informational text. */
-  rb_define_const(mCurl, "CURLINFO_TEXT", INT2FIX(CURLINFO_TEXT));
+  rb_define_const(mCurl, "CURLINFO_TEXT", LONG2NUM(CURLINFO_TEXT));
 
   /* Passed to on_debug handler to indicate that the data is header (or header-like) data received from the peer. */
-  rb_define_const(mCurl, "CURLINFO_HEADER_IN", INT2FIX(CURLINFO_HEADER_IN));
+  rb_define_const(mCurl, "CURLINFO_HEADER_IN", LONG2NUM(CURLINFO_HEADER_IN));
 
   /* Passed to on_debug handler to indicate that the data is header (or header-like) data sent to the peer. */
-  rb_define_const(mCurl, "CURLINFO_HEADER_OUT", INT2FIX(CURLINFO_HEADER_OUT));
+  rb_define_const(mCurl, "CURLINFO_HEADER_OUT", LONG2NUM(CURLINFO_HEADER_OUT));
 
   /* Passed to on_debug handler to indicate that the data is protocol data received from the peer. */
-  rb_define_const(mCurl, "CURLINFO_DATA_IN", INT2FIX(CURLINFO_DATA_IN));
+  rb_define_const(mCurl, "CURLINFO_DATA_IN", LONG2NUM(CURLINFO_DATA_IN));
 
   /* Passed to on_debug handler to indicate that the data is protocol data sent to the peer. */
-  rb_define_const(mCurl, "CURLINFO_DATA_OUT", INT2FIX(CURLINFO_DATA_OUT));
+  rb_define_const(mCurl, "CURLINFO_DATA_OUT", LONG2NUM(CURLINFO_DATA_OUT));
 
-#ifdef HAVE_CURLFTPMETHOD_MULTICWD 
-  rb_define_const(mCurl, "CURL_MULTICWD",  INT2FIX(CURLFTPMETHOD_MULTICWD));
+#ifdef HAVE_CURLFTPMETHOD_MULTICWD
+  rb_define_const(mCurl, "CURL_MULTICWD",  LONG2NUM(CURLFTPMETHOD_MULTICWD));
 #endif
 
-#ifdef HAVE_CURLFTPMETHOD_NOCWD 
-  rb_define_const(mCurl, "CURL_NOCWD",     INT2FIX(CURLFTPMETHOD_NOCWD));
+#ifdef HAVE_CURLFTPMETHOD_NOCWD
+  rb_define_const(mCurl, "CURL_NOCWD",     LONG2NUM(CURLFTPMETHOD_NOCWD));
 #endif
 
-#ifdef HAVE_CURLFTPMETHOD_SINGLECWD 
-  rb_define_const(mCurl, "CURL_SINGLECWD", INT2FIX(CURLFTPMETHOD_SINGLECWD));
+#ifdef HAVE_CURLFTPMETHOD_SINGLECWD
+  rb_define_const(mCurl, "CURL_SINGLECWD", LONG2NUM(CURLFTPMETHOD_SINGLECWD));
 #endif
 
   /* When passed to Curl::Easy#proxy_type , indicates that the proxy is an HTTP proxy. (libcurl >= 7.10) */
 #ifdef HAVE_CURLPROXY_HTTP
-  rb_define_const(mCurl, "CURLPROXY_HTTP", INT2FIX(CURLPROXY_HTTP));
+  rb_define_const(mCurl, "CURLPROXY_HTTP", LONG2NUM(CURLPROXY_HTTP));
 #else
-  rb_define_const(mCurl, "CURLPROXY_HTTP", INT2FIX(-1));
+  rb_define_const(mCurl, "CURLPROXY_HTTP", LONG2NUM(-1));
 #endif
 
 #ifdef CURL_VERSION_SSL
-  rb_define_const(mCurl, "CURL_SSLVERSION_DEFAULT", INT2FIX(CURL_SSLVERSION_DEFAULT));
-  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1",   INT2FIX(CURL_SSLVERSION_TLSv1));
-  rb_define_const(mCurl, "CURL_SSLVERSION_SSLv2",   INT2FIX(CURL_SSLVERSION_SSLv2));
-  rb_define_const(mCurl, "CURL_SSLVERSION_SSLv3",   INT2FIX(CURL_SSLVERSION_SSLv3));
-
-  rb_define_const(mCurl, "CURL_USESSL_CONTROL", INT2FIX(CURB_FTPSSL_CONTROL));
-  rb_define_const(mCurl, "CURL_USESSL_NONE", INT2FIX(CURB_FTPSSL_NONE));
-  rb_define_const(mCurl, "CURL_USESSL_TRY", INT2FIX(CURB_FTPSSL_TRY));
-  rb_define_const(mCurl, "CURL_USESSL_ALL", INT2FIX(CURB_FTPSSL_ALL));
+  rb_define_const(mCurl, "CURL_SSLVERSION_DEFAULT", LONG2NUM(CURL_SSLVERSION_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));
+#endif
+#if HAVE_CURL_SSLVERSION_TLSV1_1
+  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_1",   LONG2NUM(CURL_SSLVERSION_TLSv1_1));
+#endif
+#if HAVE_CURL_SSLVERSION_TLSV1_2
+  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_2",   LONG2NUM(CURL_SSLVERSION_TLSv1_2));
+#endif
+
+  rb_define_const(mCurl, "CURL_USESSL_CONTROL", LONG2NUM(CURB_FTPSSL_CONTROL));
+  rb_define_const(mCurl, "CURL_USESSL_NONE", LONG2NUM(CURB_FTPSSL_NONE));
+  rb_define_const(mCurl, "CURL_USESSL_TRY", LONG2NUM(CURB_FTPSSL_TRY));
+  rb_define_const(mCurl, "CURL_USESSL_ALL", LONG2NUM(CURB_FTPSSL_ALL));
 #else
-  rb_define_const(mCurl, "CURL_SSLVERSION_DEFAULT", INT2FIX(-1));
-  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1",   INT2FIX(-1));
-  rb_define_const(mCurl, "CURL_SSLVERSION_SSLv2",   INT2FIX(-1));
-  rb_define_const(mCurl, "CURL_SSLVERSION_SSLv3",   INT2FIX(-1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_DEFAULT", LONG2NUM(-1));
+  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1",   LONG2NUM(-1));
+  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));
+#endif
+#if HAVE_CURL_SSLVERSION_TLSv1_1
+  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_1", LONG2NUM(-1));
+#endif
+#if HAVE_CURL_SSLVERSION_TLSv1_2
+  rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1_2", LONG2NUM(-1));
+#endif
 
-  rb_define_const(mCurl, "CURL_USESSL_CONTROL", INT2FIX(-1));
-  rb_define_const(mCurl, "CURL_USESSL_NONE", INT2FIX(-1));
-  rb_define_const(mCurl, "CURL_USESSL_TRY", INT2FIX(-1));
-  rb_define_const(mCurl, "CURL_USESSL_ALL", INT2FIX(-1));
+  rb_define_const(mCurl, "CURL_USESSL_CONTROL", LONG2NUM(-1));
+  rb_define_const(mCurl, "CURL_USESSL_NONE", LONG2NUM(-1));
+  rb_define_const(mCurl, "CURL_USESSL_TRY", LONG2NUM(-1));
+  rb_define_const(mCurl, "CURL_USESSL_ALL", LONG2NUM(-1));
 #endif
 
   /* When passed to Curl::Easy#proxy_type , indicates that the proxy is a SOCKS4 proxy. (libcurl >= 7.15.2) */
 #ifdef HAVE_CURLPROXY_SOCKS4
-  rb_define_const(mCurl, "CURLPROXY_SOCKS4", INT2FIX(CURLPROXY_SOCKS4));
+  rb_define_const(mCurl, "CURLPROXY_SOCKS4", LONG2NUM(CURLPROXY_SOCKS4));
+#else
+  rb_define_const(mCurl, "CURLPROXY_SOCKS4", LONG2NUM(-2));
+#endif
+
+  /* When passed to Curl::Easy#proxy_type , indicates that the proxy is a SOCKS4A proxy. (libcurl >= 7.18.0) */
+#ifdef HAVE_CURLPROXY_SOCKS4A
+  rb_define_const(mCurl, "CURLPROXY_SOCKS4A", LONG2NUM(CURLPROXY_SOCKS4A));
 #else
-  rb_define_const(mCurl, "CURLPROXY_SOCKS4", INT2FIX(-2));
+  rb_define_const(mCurl, "CURLPROXY_SOCKS4A", LONG2NUM(-2));
 #endif
 
   /* When passed to Curl::Easy#proxy_type , indicates that the proxy is a SOCKS5 proxy. (libcurl >= 7.10) */
 #ifdef HAVE_CURLPROXY_SOCKS5
-  rb_define_const(mCurl, "CURLPROXY_SOCKS5", INT2FIX(CURLPROXY_SOCKS5));
+  rb_define_const(mCurl, "CURLPROXY_SOCKS5", LONG2NUM(CURLPROXY_SOCKS5));
+#else
+  rb_define_const(mCurl, "CURLPROXY_SOCKS5", LONG2NUM(-2));
+#endif
+
+  /* When passed to Curl::Easy#proxy_type , indicates that the proxy is a SOCKS5 proxy (and that the proxy should resolve the hostname). (libcurl >= 7.17.2) */
+#ifdef HAVE_CURLPROXY_SOCKS5_HOSTNAME
+  rb_define_const(mCurl, "CURLPROXY_SOCKS5_HOSTNAME", LONG2NUM(CURLPROXY_SOCKS5_HOSTNAME));
 #else
-  rb_define_const(mCurl, "CURLPROXY_SOCKS5", INT2FIX(-2));
+  rb_define_const(mCurl, "CURLPROXY_SOCKS5_HOSTNAME", LONG2NUM(-2));
 #endif
 
   /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, directs libcurl to use Basic authentication. */
 #ifdef HAVE_CURLAUTH_BASIC
-  rb_define_const(mCurl, "CURLAUTH_BASIC", INT2FIX(CURLAUTH_BASIC));
+  rb_define_const(mCurl, "CURLAUTH_BASIC", LONG2NUM(CURLAUTH_BASIC));
 #else
-  rb_define_const(mCurl, "CURLAUTH_BASIC", INT2FIX(0));
+  rb_define_const(mCurl, "CURLAUTH_BASIC", LONG2NUM(0));
 #endif
 
   /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, directs libcurl to use Digest authentication. */
 #ifdef HAVE_CURLAUTH_DIGEST
-  rb_define_const(mCurl, "CURLAUTH_DIGEST", INT2FIX(CURLAUTH_DIGEST));
+  rb_define_const(mCurl, "CURLAUTH_DIGEST", LONG2NUM(CURLAUTH_DIGEST));
 #else
-  rb_define_const(mCurl, "CURLAUTH_DIGEST", INT2FIX(0));
+  rb_define_const(mCurl, "CURLAUTH_DIGEST", LONG2NUM(0));
 #endif
 
   /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, directs libcurl to use GSS Negotiate authentication. Requires a suitable GSS-API library. */
 #ifdef HAVE_CURLAUTH_GSSNEGOTIATE
-  rb_define_const(mCurl, "CURLAUTH_GSSNEGOTIATE", INT2FIX(CURLAUTH_GSSNEGOTIATE));
+  rb_define_const(mCurl, "CURLAUTH_GSSNEGOTIATE", LONG2NUM(CURLAUTH_GSSNEGOTIATE));
 #else
-  rb_define_const(mCurl, "CURLAUTH_GSSNEGOTIATE", INT2FIX(0));
+  rb_define_const(mCurl, "CURLAUTH_GSSNEGOTIATE", LONG2NUM(0));
 #endif
 
   /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, directs libcurl to use HTTP NTLM authentication. Requires MS Windows or OpenSSL support. */
 #ifdef HAVE_CURLAUTH_NTLM
-  rb_define_const(mCurl, "CURLAUTH_NTLM", INT2FIX(CURLAUTH_NTLM));
+  rb_define_const(mCurl, "CURLAUTH_NTLM", LONG2NUM(CURLAUTH_NTLM));
 #else
-  rb_define_const(mCurl, "CURLAUTH_NTLM", INT2FIX(0));
+  rb_define_const(mCurl, "CURLAUTH_NTLM", LONG2NUM(0));
 #endif
 
   /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, allows libcurl to select any suitable authentication method except basic. */
 #ifdef HAVE_CURLAUTH_ANYSAFE
-  rb_define_const(mCurl, "CURLAUTH_ANYSAFE", INT2FIX(CURLAUTH_ANYSAFE));
+  rb_define_const(mCurl, "CURLAUTH_ANYSAFE", LONG2NUM(CURLAUTH_ANYSAFE));
 #else
-  rb_define_const(mCurl, "CURLAUTH_ANYSAFE", INT2FIX(0));
+  rb_define_const(mCurl, "CURLAUTH_ANYSAFE", LONG2NUM(0));
 #endif
 
   /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, allows libcurl to select any suitable authentication method. */
 #ifdef HAVE_CURLAUTH_ANY
-  rb_define_const(mCurl, "CURLAUTH_ANY", INT2FIX(CURLAUTH_ANY));
+  rb_define_const(mCurl, "CURLAUTH_ANY", LONG2NUM(CURLAUTH_ANY));
 #else
-  rb_define_const(mCurl, "CURLAUTH_ANY", INT2FIX(0));
+  rb_define_const(mCurl, "CURLAUTH_ANY", LONG2NUM(0));
 #endif
 
   CURB_DEFINE(CURLOPT_VERBOSE);
   CURB_DEFINE(CURLOPT_HEADER);
   CURB_DEFINE(CURLOPT_NOPROGRESS);
   CURB_DEFINE(CURLOPT_NOSIGNAL);
+#if HAVE_CURLOPT_PATH_AS_IS
+  CURB_DEFINE(CURLOPT_PATH_AS_IS);
+#endif
   CURB_DEFINE(CURLOPT_WRITEFUNCTION);
   CURB_DEFINE(CURLOPT_WRITEDATA);
   CURB_DEFINE(CURLOPT_READFUNCTION);
@@ -541,6 +592,9 @@ void Init_curb_core() {
   CURB_DEFINE(CURLOPT_REFERER);
   CURB_DEFINE(CURLOPT_USERAGENT);
   CURB_DEFINE(CURLOPT_HTTPHEADER);
+#if HAVE_CURLOPT_PROXYHEADER
+  CURB_DEFINE(CURLOPT_PROXYHEADER);
+#endif
 #if HAVE_CURLOPT_HTTP200ALIASES
   CURB_DEFINE(CURLOPT_HTTP200ALIASES);
 #endif
@@ -562,6 +616,12 @@ void Init_curb_core() {
     CURB_DEFINE(CURL_HTTP_VERSION_NONE);
     CURB_DEFINE(CURL_HTTP_VERSION_1_0);
     CURB_DEFINE(CURL_HTTP_VERSION_1_1);
+#if LIBCURL_VERSION_NUM >= 0x072100 /* 7.33.0 */
+    CURB_DEFINE(CURL_HTTP_VERSION_2_0);
+#endif
+#if LIBCURL_VERSION_NUM >= 0x072f00 /* 7.47.0 */
+    CURB_DEFINE(CURL_HTTP_VERSION_2TLS);
+#endif
 #if HAVE_CURLOPT_IGNORE_CONTENT_LENGTH
   CURB_DEFINE(CURLOPT_IGNORE_CONTENT_LENGTH);
 #endif
@@ -863,6 +923,15 @@ void Init_curb_core() {
 #if HAVE_CURL_SSLVERSION_SSLv3
   CURB_DEFINE(CURL_SSLVERSION_SSLv3);
 #endif
+#if HAVE_CURL_SSLVERSION_TLSv1_0
+  CURB_DEFINE(CURL_SSLVERSION_TLSv1_0);
+#endif
+#if HAVE_CURL_SSLVERSION_TLSv1_1
+  CURB_DEFINE(CURL_SSLVERSION_TLSv1_1);
+#endif
+#if HAVE_CURL_SSLVERSION_TLSv1_2
+  CURB_DEFINE(CURL_SSLVERSION_TLSv1_2);
+#endif
 #if HAVE_CURLOPT_SSL_VERIFYPEER
   CURB_DEFINE(CURLOPT_SSL_VERIFYPEER);
 #endif
@@ -951,10 +1020,55 @@ void Init_curb_core() {
   CURB_DEFINE(CURLOPT_TELNETOPTIONS);
 #endif
 
+#if HAVE_CURLOPT_GSSAPI_DELEGATION
+  CURB_DEFINE(CURLOPT_GSSAPI_DELEGATION);
+#endif
+
+#if HAVE_CURLGSSAPI_DELEGATION_FLAG
+  CURB_DEFINE(CURLGSSAPI_DELEGATION_FLAG);
+#endif
+
+#if HAVE_CURLGSSAPI_DELEGATION_POLICY_FLAG
+  CURB_DEFINE(CURLGSSAPI_DELEGATION_POLICY_FLAG);
+#endif
+
+#if HAVE_CURLOPT_UNIX_SOCKET_PATH
+  CURB_DEFINE(CURLOPT_UNIX_SOCKET_PATH);
+#endif
+
+#if HAVE_CURLOPT_PIPEWAIT
+  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 LIBCURL_VERSION_NUM >= 0x072B00 /* 7.43.0 */
+  CURB_DEFINE(CURLPIPE_NOTHING);
+  CURB_DEFINE(CURLPIPE_HTTP1);
+  CURB_DEFINE(CURLPIPE_MULTIPLEX);
+
+  rb_define_const(mCurl, "PIPE_NOTHING", LONG2NUM(CURLPIPE_NOTHING));
+  rb_define_const(mCurl, "PIPE_HTTP1", LONG2NUM(CURLPIPE_HTTP1));
+  rb_define_const(mCurl, "PIPE_MULTIPLEX", LONG2NUM(CURLPIPE_MULTIPLEX));
+#endif
+
+#if LIBCURL_VERSION_NUM >= 0x072100 /* 7.33.0 */
+  rb_define_const(mCurl, "HTTP_2_0", LONG2NUM(CURL_HTTP_VERSION_2_0));
+#endif
   rb_define_const(mCurl, "HTTP_1_1", LONG2NUM(CURL_HTTP_VERSION_1_1));
   rb_define_const(mCurl, "HTTP_1_0", LONG2NUM(CURL_HTTP_VERSION_1_0));
   rb_define_const(mCurl, "HTTP_NONE", LONG2NUM(CURL_HTTP_VERSION_NONE));
 
+
+
   rb_define_singleton_method(mCurl, "ipv6?", ruby_curl_ipv6_q, 0);
   rb_define_singleton_method(mCurl, "kerberos4?", ruby_curl_kerberos4_q, 0);
   rb_define_singleton_method(mCurl, "ssl?", ruby_curl_ssl_q, 0);
@@ -968,6 +1082,7 @@ void Init_curb_core() {
   rb_define_singleton_method(mCurl, "idn?", ruby_curl_idn_q, 0);
   rb_define_singleton_method(mCurl, "sspi?", ruby_curl_sspi_q, 0);
   rb_define_singleton_method(mCurl, "conv?", ruby_curl_conv_q, 0);
+  rb_define_singleton_method(mCurl, "http2?", ruby_curl_http2_q, 0);
 
   init_curb_errors();
   init_curb_easy();

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.8.4"
-#define CURB_VER_NUM   804
+#define CURB_VERSION   "0.9.11"
+#define CURB_VER_NUM   9011
 #define CURB_VER_MAJ   0
-#define CURB_VER_MIN   8
-#define CURB_VER_MIC   4
+#define CURB_VER_MIN   9
+#define CURB_VER_MIC   11
 #define CURB_VER_PATCH 0
 
 
@@ -37,12 +45,8 @@
   #define RSTRING_PTR(x) RSTRING(x)->ptr
 #endif
 
-#ifndef RHASH_LEN
-#ifdef HAVE_RUBY19_HASH
-  #define RHASH_LEN(hash) RHASH(hash)->ntbl->num_entries
-#else
-  #define RHASH_LEN(hash) RHASH(hash)->tbl->num_entries
-#endif
+#ifndef RHASH_SIZE
+  #define RHASH_SIZE(hash) RHASH(hash)->tbl->num_entries
 #endif
 
 extern VALUE mCurl;