curb 0.7.15 → 1.0.0

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 */
 
@@ -48,14 +51,19 @@ typedef struct {
   long proxy_auth_types;
   long max_redirs;
   unsigned long timeout;
+  unsigned long timeout_ms;
   unsigned long connect_timeout;
+  unsigned long connect_timeout_ms;
   long dns_cache_timeout;
   unsigned long ftp_response_timeout;
   long low_speed_limit;
   long low_speed_time;
+  long max_send_speed_large;
+  long max_recv_speed_large;
   long ssl_version;
   long use_ssl;
   long ftp_filemethod;
+  unsigned short resolve_mode;
 
   /* bool flags */
   char proxy_tunnel;
@@ -70,8 +78,12 @@ typedef struct {
   char multipart_form_post;
   char enable_cookies;
   char ignore_content_length;
+  char callback_active;
+
   struct curl_slist *curl_headers;
+  struct curl_slist *curl_proxy_headers;
   struct curl_slist *curl_ftp_commands;
+  struct curl_slist *curl_resolve;
 
   int last_result; /* last result code from multi loop */
 

data/ext/curb_errors.c

@@ -21,6 +21,7 @@ VALUE eCurlErrFileError;
 VALUE eCurlErrLDAPError;
 VALUE eCurlErrTelnetError;
 VALUE eCurlErrTFTPError;
+VALUE eCurlErrRTSPError;
 
 /* Specific libcurl errors */
 VALUE eCurlErrOK; /* not really an error but a return code */
@@ -28,16 +29,17 @@ VALUE eCurlErrUnsupportedProtocol;
 VALUE eCurlErrFailedInit;
 VALUE eCurlErrMalformedURL;
 VALUE eCurlErrMalformedURLUser;
+VALUE eCurlErrNotBuiltIn;
 VALUE eCurlErrProxyResolution;
 VALUE eCurlErrHostResolution;
 VALUE eCurlErrConnectFailed;
-VALUE eCurlErrFTPWierdReply;
+VALUE eCurlErrFTPWeirdReply;
 VALUE eCurlErrFTPAccessDenied;
 VALUE eCurlErrFTPBadPassword;
-VALUE eCurlErrFTPWierdPassReply;
-VALUE eCurlErrFTPWierdUserReply;
-VALUE eCurlErrFTPWierdPasvReply;
-VALUE eCurlErrFTPWierd227Format;
+VALUE eCurlErrFTPWeirdPassReply;
+VALUE eCurlErrFTPWeirdUserReply;
+VALUE eCurlErrFTPWeirdPasvReply;
+VALUE eCurlErrFTPWeird227Format;
 VALUE eCurlErrFTPCantGetHost;
 VALUE eCurlErrFTPCantReconnect;
 VALUE eCurlErrFTPCouldntSetBinary;
@@ -117,12 +119,27 @@ VALUE mCurlErrBadEasyHandle;
 VALUE mCurlErrOutOfMemory;
 VALUE mCurlErrInternalError;
 VALUE mCurlErrBadSocket;
+#if HAVE_CURLM_ADDED_ALREADY
+VALUE mCurlErrAddedAlready;
+#endif
 VALUE mCurlErrUnknownOption;
 
 /* binding errors */
 VALUE eCurlErrInvalidPostField;
 
 
+/* new errors */
+VALUE eCurlErrFTPPRETFailed;
+VALUE eCurlErrRTSPCseqError;
+VALUE eCurlErrRTSPSessionError;
+VALUE eCurlErrFTPBadFileList;
+VALUE eCurlErrChunkFailed;
+VALUE eCurlErrNoConnectionAvailable;
+VALUE eCurlErrSSLPinnedPubKeyNotMatch;
+VALUE eCurlErrSSLInvalidCertStatus;
+VALUE eCurlErrHTTP2Stream;
+
+
 VALUE rb_curl_easy_error(CURLcode code) {
   VALUE exclz;
   const char *exmsg = NULL;
@@ -141,9 +158,15 @@ VALUE rb_curl_easy_error(CURLcode code) {
     case CURLE_URL_MALFORMAT:           /* 3 */
       exclz = eCurlErrMalformedURL;
       break;
+#ifdef HAVE_CURLE_NOT_BUILT_IN
+    case CURLE_NOT_BUILT_IN:            /* 4 - [was obsoleted in August 2007 for 7.17.0, reused in April 2011 for 7.21.5] */
+      exclz = eCurlErrNotBuiltIn;
+      break;
+#else
     case CURLE_URL_MALFORMAT_USER:      /* 4 (NOT USED) */
       exclz = eCurlErrMalformedURLUser;
       break;
+#endif
     case CURLE_COULDNT_RESOLVE_PROXY:   /* 5 */
       exclz = eCurlErrProxyResolution;
       break;
@@ -154,7 +177,7 @@ VALUE rb_curl_easy_error(CURLcode code) {
       exclz = eCurlErrConnectFailed;
       break;
     case CURLE_FTP_WEIRD_SERVER_REPLY:  /* 8 */
-      exclz = eCurlErrFTPWierdReply;
+      exclz = eCurlErrFTPWeirdReply;
       break;
     case CURLE_FTP_ACCESS_DENIED:       /* 9 denied due to lack of access. */
       exclz = eCurlErrFTPAccessDenied;
@@ -163,16 +186,16 @@ VALUE rb_curl_easy_error(CURLcode code) {
       exclz = eCurlErrFTPBadPassword;
       break;
     case CURLE_FTP_WEIRD_PASS_REPLY:    /* 11 */
-      exclz = eCurlErrFTPWierdPassReply;
+      exclz = eCurlErrFTPWeirdPassReply;
       break;
     case CURLE_FTP_WEIRD_USER_REPLY:    /* 12 */
-      exclz = eCurlErrFTPWierdUserReply;
+      exclz = eCurlErrFTPWeirdUserReply;
       break;
     case CURLE_FTP_WEIRD_PASV_REPLY:    /* 13 */
-      exclz = eCurlErrFTPWierdPasvReply;
+      exclz = eCurlErrFTPWeirdPasvReply;
       break;
     case CURLE_FTP_WEIRD_227_FORMAT:    /* 14 */
-      exclz = eCurlErrFTPWierd227Format;
+      exclz = eCurlErrFTPWeird227Format;
       break;
     case CURLE_FTP_CANT_GET_HOST:       /* 15 */
       exclz = eCurlErrFTPCantGetHost;
@@ -279,12 +302,16 @@ VALUE rb_curl_easy_error(CURLcode code) {
     case CURLE_TELNET_OPTION_SYNTAX:    /* 49 - Malformed telnet option */
       exclz = eCurlErrTelnetBadOptionSyntax;
       break;
+#ifdef HAVE_CURLE_OBSOLETE
     case CURLE_OBSOLETE:                /* 50 - NOT USED */
       exclz = eCurlErrObsolete;
       break;
+#endif
+#if LIBCURL_VERSION_NUM < 0x073e00
     case CURLE_SSL_PEER_CERTIFICATE:    /* 51 - peer's certificate wasn't ok */
       exclz = eCurlErrSSLPeerCertificate;
       break;
+#endif
     case CURLE_GOT_NOTHING:             /* 52 - when this is a specific error */
       exclz = eCurlErrGotNothing;
       break;
@@ -309,8 +336,13 @@ VALUE rb_curl_easy_error(CURLcode code) {
     case CURLE_SSL_CIPHER:              /* 59 - couldn't use specified cipher */
       exclz = eCurlErrSSLCipher;
       break;
+#if LIBCURL_VERSION_NUM >= 0x073e00
+    case CURLE_PEER_FAILED_VERIFICATION:              /* 60 - problem with the CA cert (path?) */
+      exclz = eCurlErrSSLPeerCertificate;
+#else
     case CURLE_SSL_CACERT:              /* 60 - problem with the CA cert (path?) */
       exclz = eCurlErrSSLCACertificate;
+#endif
       break;
     case CURLE_BAD_CONTENT_ENCODING:    /* 61 - Unrecognized transfer encoding */
       exclz = eCurlErrBadContentEncoding;
@@ -433,6 +465,61 @@ VALUE rb_curl_easy_error(CURLcode code) {
       exclz = eCurlErrSSLIssuerError;
       break;
 #endif
+
+#ifdef  HAVE_CURLE_FTP_PRET_FAILED
+    case CURLE_FTP_PRET_FAILED:  /* 84 */
+      exclz = eCurlErrFTPPRETFailed;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_RTSP_CSEQ_ERROR
+    case CURLE_RTSP_CSEQ_ERROR:  /* 85 */
+      exclz = eCurlErrRTSPCseqError;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_RTSP_SESSION_ERROR
+    case CURLE_RTSP_SESSION_ERROR:  /* 86 */
+      exclz = eCurlErrRTSPSessionError;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_FTP_BAD_FILE_LIST
+    case CURLE_FTP_BAD_FILE_LIST:  /* 87 */
+      exclz = eCurlErrFTPBadFileList;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_CHUNK_FAILED
+    case CURLE_CHUNK_FAILED:  /* 88 */
+      exclz = eCurlErrChunkFailed;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_NO_CONNECTION_AVAILABLE
+    case CURLE_NO_CONNECTION_AVAILABLE:  /* 89 */
+      exclz = eCurlErrNoConnectionAvailable;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_SSL_PINNEDPUBKEYNOTMATCH
+    case CURLE_SSL_PINNEDPUBKEYNOTMATCH:  /* 90 */
+      exclz = eCurlErrSSLPinnedPubKeyNotMatch;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_SSL_INVALIDCERTSTATUS
+    case CURLE_SSL_INVALIDCERTSTATUS:  /* 91 */
+      exclz = eCurlErrSSLInvalidCertStatus;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_HTTP2_STREAM
+    case CURLE_HTTP2_STREAM:  /* 92 */
+      exclz = eCurlErrHTTP2Stream;
+      break;
+#endif
+
     default:
       exclz = eCurlErrError;
       exmsg = "Unknown error result from libcurl";
@@ -450,7 +537,8 @@ VALUE rb_curl_easy_error(CURLcode code) {
 /* rb_raise an approriate exception for the supplied CURLcode */
 void raise_curl_easy_error_exception(CURLcode code) {
   VALUE obj = rb_curl_easy_error(code);
-  rb_raise(rb_ary_entry(obj,0), RSTRING_PTR(rb_ary_entry(obj,1)));
+  VALUE exmsg = rb_ary_entry(obj,1);
+  rb_raise(rb_ary_entry(obj,0), "CURLError: %s", StringValueCStr(exmsg));
 }
 VALUE rb_curl_multi_error(CURLMcode code) {
   VALUE exclz;
@@ -482,6 +570,11 @@ VALUE rb_curl_multi_error(CURLMcode code) {
     case CURLM_UNKNOWN_OPTION: /* 6 */
       exclz = mCurlErrUnknownOption;
       break;
+#endif
+#if HAVE_CURLM_ADDED_ALREADY
+    case CURLM_ADDED_ALREADY: /* 7 */
+      exclz = mCurlErrAddedAlready;
+      break;
 #endif
     default:
       exclz = eCurlErrError;
@@ -500,7 +593,8 @@ VALUE rb_curl_multi_error(CURLMcode code) {
 }
 void raise_curl_multi_error_exception(CURLMcode code) {
   VALUE obj = rb_curl_multi_error(code);
-  rb_raise(rb_ary_entry(obj,0), RSTRING_PTR(rb_ary_entry(obj,1)));
+  VALUE exmsg = rb_ary_entry(obj,1);
+  rb_raise(rb_ary_entry(obj,0), "CURLError: %s", StringValueCStr(exmsg));
 }
 
 void init_curb_errors() {
@@ -513,23 +607,25 @@ void init_curb_errors() {
   eCurlErrLDAPError = rb_define_class_under(mCurlErr, "LDAPError", eCurlErrError);
   eCurlErrTelnetError = rb_define_class_under(mCurlErr, "TelnetError", eCurlErrError);
   eCurlErrTFTPError = rb_define_class_under(mCurlErr, "TFTPError", eCurlErrError);
+  eCurlErrRTSPError = rb_define_class_under(mCurlErr, "RTSPError", eCurlErrError);
 
   eCurlErrOK = rb_define_class_under(mCurlErr, "CurlOK", eCurlErrError);
   eCurlErrUnsupportedProtocol = rb_define_class_under(mCurlErr, "UnsupportedProtocolError", eCurlErrError);
   eCurlErrFailedInit = rb_define_class_under(mCurlErr, "FailedInitError", eCurlErrError);
   eCurlErrMalformedURL = rb_define_class_under(mCurlErr, "MalformedURLError", eCurlErrError);
+  eCurlErrNotBuiltIn = rb_define_class_under(mCurlErr, "NotBuiltInError", eCurlErrError);
   eCurlErrMalformedURLUser = rb_define_class_under(mCurlErr, "MalformedURLUserError", eCurlErrError);
   eCurlErrProxyResolution = rb_define_class_under(mCurlErr, "ProxyResolutionError", eCurlErrError);
   eCurlErrHostResolution = rb_define_class_under(mCurlErr, "HostResolutionError", eCurlErrError);
   eCurlErrConnectFailed = rb_define_class_under(mCurlErr, "ConnectionFailedError", eCurlErrError);
 
-  eCurlErrFTPWierdReply = rb_define_class_under(mCurlErr, "WierdReplyError", eCurlErrFTPError);
+  eCurlErrFTPWeirdReply = rb_define_class_under(mCurlErr, "WeirdReplyError", eCurlErrFTPError);
   eCurlErrFTPAccessDenied = rb_define_class_under(mCurlErr, "AccessDeniedError", eCurlErrFTPError);
-  eCurlErrFTPBadPassword = rb_define_class_under(mCurlErr, "BadBasswordError", eCurlErrFTPError);
-  eCurlErrFTPWierdPassReply = rb_define_class_under(mCurlErr, "WierdPassReplyError", eCurlErrFTPError);
-  eCurlErrFTPWierdUserReply = rb_define_class_under(mCurlErr, "WierdUserReplyError", eCurlErrFTPError);
-  eCurlErrFTPWierdPasvReply = rb_define_class_under(mCurlErr, "WierdPasvReplyError", eCurlErrFTPError);
-  eCurlErrFTPWierd227Format = rb_define_class_under(mCurlErr, "Wierd227FormatError", eCurlErrFTPError);
+  eCurlErrFTPBadPassword = rb_define_class_under(mCurlErr, "BadPasswordError", eCurlErrFTPError);
+  eCurlErrFTPWeirdPassReply = rb_define_class_under(mCurlErr, "WeirdPassReplyError", eCurlErrFTPError);
+  eCurlErrFTPWeirdUserReply = rb_define_class_under(mCurlErr, "WeirdUserReplyError", eCurlErrFTPError);
+  eCurlErrFTPWeirdPasvReply = rb_define_class_under(mCurlErr, "WeirdPasvReplyError", eCurlErrFTPError);
+  eCurlErrFTPWeird227Format = rb_define_class_under(mCurlErr, "Weird227FormatError", eCurlErrFTPError);
   eCurlErrFTPCantGetHost = rb_define_class_under(mCurlErr, "CantGetHostError", eCurlErrFTPError);
   eCurlErrFTPCantReconnect = rb_define_class_under(mCurlErr, "CantReconnectError", eCurlErrFTPError);
   eCurlErrFTPCouldntSetBinary = rb_define_class_under(mCurlErr, "CouldntSetBinaryError", eCurlErrFTPError);
@@ -613,6 +709,9 @@ void init_curb_errors() {
   mCurlErrOutOfMemory        = rb_define_class_under(mCurlErr, "MultiOutOfMemory", eCurlErrError);
   mCurlErrInternalError      = rb_define_class_under(mCurlErr, "MultiInternalError", eCurlErrError);
   mCurlErrBadSocket          = rb_define_class_under(mCurlErr, "MultiBadSocket", eCurlErrError);
+#if HAVE_CURLM_ADDED_ALREADY
+  mCurlErrAddedAlready       = rb_define_class_under(mCurlErr, "MultiAddedAlready", eCurlErrError);
+#endif
   mCurlErrUnknownOption      = rb_define_class_under(mCurlErr, "MultiUnknownOption", eCurlErrError);
 
   eCurlErrLDAPInvalidURL = rb_define_class_under(mCurlErr, "InvalidLDAPURLError", eCurlErrLDAPError);
@@ -634,4 +733,14 @@ void init_curb_errors() {
   eCurlErrTFTPNoSuchUser = rb_define_class_under(mCurlErr, "NoSuchUserError", eCurlErrTFTPError);
 
   eCurlErrInvalidPostField = rb_define_class_under(mCurlErr, "InvalidPostFieldError", eCurlErrError);
+
+  eCurlErrFTPPRETFailed = rb_define_class_under(mCurlErr, "PPRETFailedError", eCurlErrFTPError);
+  eCurlErrRTSPCseqError = rb_define_class_under(mCurlErr, "CseqError", eCurlErrRTSPError);
+  eCurlErrRTSPSessionError = rb_define_class_under(mCurlErr, "SessionError", eCurlErrRTSPError);
+  eCurlErrFTPBadFileList = rb_define_class_under(mCurlErr, "BadFileListError", eCurlErrFTPError);
+  eCurlErrChunkFailed = rb_define_class_under(mCurlErr, "ChunkFailedError", eCurlErrError);
+  eCurlErrNoConnectionAvailable = rb_define_class_under(mCurlErr, "NoConnectionAvailableError", eCurlErrError);
+  eCurlErrSSLPinnedPubKeyNotMatch = rb_define_class_under(mCurlErr, "SSLPinnedPubKeyNotMatchError", eCurlErrError);
+  eCurlErrSSLInvalidCertStatus = rb_define_class_under(mCurlErr, "SSLInvalidCertStatusError", eCurlErrError);
+  eCurlErrHTTP2Stream = rb_define_class_under(mCurlErr, "HTTP2StreamError", eCurlErrHTTPError);
 }

data/ext/curb_errors.h

@@ -30,13 +30,13 @@ extern VALUE eCurlErrMalformedURLUser;
 extern VALUE eCurlErrProxyResolution;
 extern VALUE eCurlErrHostResolution;
 extern VALUE eCurlErrConnectFailed;
-extern VALUE eCurlErrFTPWierdReply;
+extern VALUE eCurlErrFTPWeirdReply;
 extern VALUE eCurlErrFTPAccessDenied;
 extern VALUE eCurlErrFTPBadPassword;
-extern VALUE eCurlErrFTPWierdPassReply;
-extern VALUE eCurlErrFTPWierdUserReply;
-extern VALUE eCurlErrFTPWierdPasvReply;
-extern VALUE eCurlErrFTPWierd227Format;
+extern VALUE eCurlErrFTPWeirdPassReply;
+extern VALUE eCurlErrFTPWeirdUserReply;
+extern VALUE eCurlErrFTPWeirdPasvReply;
+extern VALUE eCurlErrFTPWeird227Format;
 extern VALUE eCurlErrFTPCantGetHost;
 extern VALUE eCurlErrFTPCantReconnect;
 extern VALUE eCurlErrFTPCouldntSetBinary;
@@ -116,6 +116,9 @@ extern VALUE mCurlErrOutOfMemory;
 extern VALUE mCurlErrInternalError;
 extern VALUE mCurlErrBadSocket;
 extern VALUE mCurlErrUnknownOption;
+#if HAVE_CURLM_ADDED_ALREADY
+extern VALUE mCurlErrAddedAlready;
+#endif
 
 /* binding errors */
 extern VALUE eCurlErrInvalidPostField;

data/ext/curb_macros.h

@@ -8,6 +8,7 @@
 #ifndef __CURB_MACROS_H
 #define __CURB_MACROS_H
 
+#define rb_easy_sym(sym) ID2SYM(rb_intern(sym))
 #define rb_easy_hkey(key) ID2SYM(rb_intern(key))
 #define rb_easy_set(key,val) rb_hash_aset(rbce->opts, rb_easy_hkey(key) , val)
 #define rb_easy_get(key) rb_hash_aref(rbce->opts, rb_easy_hkey(key))
@@ -98,7 +99,7 @@
                                                                         \
             return oldproc;
 
-/* setter for numerics that are kept in c ints */
+/* setter for numerics that are kept in c longs */
 #define CURB_IMMED_SETTER(type, attr, nilval)                       \
             type *ptr;                                              \
                                                                     \
@@ -106,12 +107,12 @@
             if (attr == Qnil) {                                     \
               ptr->attr = nilval;                                   \
             } else {                                                \
-              ptr->attr = NUM2INT(attr);                            \
+              ptr->attr = NUM2LONG(attr);                           \
             }                                                       \
                                                                     \
             return attr;                                            \
 
-/* setter for numerics that are kept in c ints */
+/* setter for numerics that are kept in c longs */
 #define CURB_IMMED_GETTER(type, attr, nilval)                       \
             type *ptr;                                              \
                                                                     \
@@ -119,7 +120,7 @@
             if (ptr->attr == nilval) {                              \
               return Qnil;                                          \
             } else {                                                \
-              return INT2NUM(ptr->attr);                            \
+              return LONG2NUM(ptr->attr);                           \
             }
 
 /* special setter for port / port ranges */
@@ -130,7 +131,7 @@
             if (attr == Qnil) {                                     \
               ptr->attr = 0;                                        \
             } else {                                                \
-              int port = FIX2INT(attr);                             \
+              int port = NUM2INT(attr);                             \
                                                                     \
               if ((port) && ((port & 0xFFFF) == port)) {            \
                 ptr->attr = port;                                   \
@@ -149,7 +150,10 @@
             if (ptr->attr == 0) {                                   \
               return Qnil;                                          \
             } else {                                                \
-              return INT2FIX(ptr->attr);                            \
+              return INT2NUM(ptr->attr);                            \
             }
 
+#define CURB_DEFINE(name) \
+  rb_define_const(mCurl, #name, LONG2NUM(name))
+
 #endif