curb 0.7.15 → 0.8.0

data/ext/curb_easy.h

@@ -56,6 +56,7 @@ typedef struct {
   long ssl_version;
   long use_ssl;
   long ftp_filemethod;
+  unsigned short resolve_mode;
 
   /* bool flags */
   char proxy_tunnel;

data/ext/curb_errors.c

@@ -28,6 +28,7 @@ VALUE eCurlErrUnsupportedProtocol;
 VALUE eCurlErrFailedInit;
 VALUE eCurlErrMalformedURL;
 VALUE eCurlErrMalformedURLUser;
+VALUE eCurlErrNotBuiltIn;
 VALUE eCurlErrProxyResolution;
 VALUE eCurlErrHostResolution;
 VALUE eCurlErrConnectFailed;
@@ -141,9 +142,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;
@@ -279,9 +286,11 @@ 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
     case CURLE_SSL_PEER_CERTIFICATE:    /* 51 - peer's certificate wasn't ok */
       exclz = eCurlErrSSLPeerCertificate;
       break;
@@ -518,6 +527,7 @@ void init_curb_errors() {
   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);

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))
@@ -152,4 +153,7 @@
               return INT2FIX(ptr->attr);                            \
             }
 
+#define CURB_DEFINE(name) \
+  rb_define_const(mCurl, #name, INT2FIX(name))
+
 #endif

data/ext/curb_multi.c

@@ -3,7 +3,6 @@
  * Licensed under the Ruby License. See LICENSE for details.
  *
  */
-
 #include "curb_config.h"
 #ifdef HAVE_RUBY19_ST_H
   #include <ruby.h>
@@ -39,13 +38,12 @@ static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy);
 static void rb_curl_multi_read_info(VALUE self, CURLM *mptr);
 static void rb_curl_multi_run(VALUE self, CURLM *multi_handle, int *still_running);
 
-static void rb_curl_multi_mark_all_easy(VALUE key, VALUE rbeasy, ruby_curl_multi *rbcm) {
-  rb_gc_mark(rbeasy);
-}
+static VALUE callback_exception(VALUE unused) {
+  return Qfalse;
+} 
 
 static void curl_multi_mark(ruby_curl_multi *rbcm) {
   rb_gc_mark(rbcm->requests);
-  rb_hash_foreach( rbcm->requests, (int (*)())rb_curl_multi_mark_all_easy, (VALUE)rbcm );
 }
 
 static void curl_multi_flush_easy(VALUE key, VALUE easy, ruby_curl_multi *rbcm) {
@@ -245,8 +243,6 @@ VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
 
   rb_hash_aset( rbcm->requests, easy, easy );
 
-  rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
-
   return self;
 }
 
@@ -323,11 +319,20 @@ static VALUE ruby_curl_multi_cancel(VALUE self) {
   return self;
 }
 
+// on_success, on_failure, on_complete
+static VALUE call_status_handler1(VALUE ary) {
+  return rb_funcall(rb_ary_entry(ary, 0), idCall, 1, rb_ary_entry(ary, 1));
+}
+static VALUE call_status_handler2(VALUE ary) {
+  return rb_funcall(rb_ary_entry(ary, 0), idCall, 2, rb_ary_entry(ary, 1), rb_ary_entry(ary, 2));
+}
+
 static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int result) {
 
   long response_code = -1;
   VALUE easy;
   ruby_curl_easy *rbce = NULL;
+  VALUE callargs, val = Qtrue;
 
   CURLcode ecode = curl_easy_getinfo(easy_handle, CURLINFO_PRIVATE, (char**)&easy);
 
@@ -348,24 +353,48 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
   }
 
   if (!rb_easy_nil("complete_proc")) {
-    rb_funcall( rb_easy_get("complete_proc"), idCall, 1, easy );
+    callargs = rb_ary_new3(2, rb_easy_get("complete_proc"), easy);
+    val = rb_rescue(call_status_handler1, callargs, callback_exception, Qnil);
+    //rb_funcall( rb_easy_get("complete_proc"), idCall, 1, easy );
   }
 
   curl_easy_getinfo(rbce->curl, CURLINFO_RESPONSE_CODE, &response_code);
 
   if (result != 0) {
     if (!rb_easy_nil("failure_proc")) {
-      rb_funcall( rb_easy_get("failure_proc"), idCall, 2, easy, rb_curl_easy_error(result) );
+      callargs = rb_ary_new3(3, rb_easy_get("failure_proc"), easy, rb_curl_easy_error(result));
+      val = rb_rescue(call_status_handler2, callargs, callback_exception, Qnil);
+      //rb_funcall( rb_easy_get("failure_proc"), idCall, 2, easy, rb_curl_easy_error(result) );
     }
   }
   else if (!rb_easy_nil("success_proc") &&
           ((response_code >= 200 && response_code < 300) || response_code == 0)) {
     /* NOTE: we allow response_code == 0, in the case of non http requests e.g. reading from disk */
-    rb_funcall( rb_easy_get("success_proc"), idCall, 1, easy );
+    callargs = rb_ary_new3(2, rb_easy_get("success_proc"), easy);
+    val = rb_rescue(call_status_handler1, callargs, callback_exception, Qnil);
+    //rb_funcall( rb_easy_get("success_proc"), idCall, 1, easy );
+  }
+  else if (!rb_easy_nil("redirect_proc") &&
+          (response_code >= 300 && response_code < 400)) {
+    callargs = rb_ary_new3(3, rb_easy_get("redirect_proc"), easy, rb_curl_easy_error(result));
+    val = rb_rescue(call_status_handler2, callargs, callback_exception, Qnil);
+  }
+  else if (!rb_easy_nil("missing_proc") &&
+          (response_code >= 400 && response_code < 500)) {
+    callargs = rb_ary_new3(3, rb_easy_get("missing_proc"), easy, rb_curl_easy_error(result));
+    val = rb_rescue(call_status_handler2, callargs, callback_exception, Qnil);
   }
   else if (!rb_easy_nil("failure_proc") &&
-          (response_code >= 300 && response_code <= 999)) {
-    rb_funcall( rb_easy_get("failure_proc"), idCall, 2, easy, rb_curl_easy_error(result) );
+          (response_code >= 500 && response_code <= 999)) {
+    callargs = rb_ary_new3(3, rb_easy_get("failure_proc"), easy, rb_curl_easy_error(result));
+    val = rb_rescue(call_status_handler2, callargs, callback_exception, Qnil);
+    //rb_funcall( rb_easy_get("failure_proc"), idCall, 2, easy, rb_curl_easy_error(result) );
+  }
+
+  if (val == Qfalse) {
+    rb_warn("uncaught exception from callback");
+      // exception was raised?
+    //fprintf(stderr, "exception raised from callback\n");
   }
 
 }
@@ -430,6 +459,20 @@ void cleanup_crt_fd(fd_set *os_set, fd_set *crt_set)
 }
 #endif
 
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+struct _select_set {
+  int maxfd;
+  fd_set *fdread, *fdwrite, *fdexcep;
+  struct timeval *tv;
+};
+
+static VALUE curb_select(void *args) {
+  struct _select_set* set = args;
+  int rc = select(set->maxfd, set->fdread, set->fdwrite, set->fdexcep, set->tv);
+  return INT2FIX(rc);
+}
+#endif
+
 /*
  * call-seq:
  * multi = Curl::Multi.new
@@ -453,10 +496,12 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
 #ifdef _WIN32
   fd_set crt_fdread, crt_fdwrite, crt_fdexcep;
 #endif
-
   long timeout_milliseconds;
   struct timeval tv = {0, 0};
   VALUE block = Qnil;
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+  struct _select_set fdset_args;
+#endif
 
   rb_scan_args(argc, argv, "0&", &block);
 
@@ -465,6 +510,8 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
   timeout_milliseconds = cCurlMutiDefaulttimeout;
 
   rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
+  rb_curl_multi_read_info( self, rbcm->handle );
+  if (block != Qnil) { rb_funcall(block, rb_intern("call"), 1, self);  }
  
   do {
     while (rbcm->running) {
@@ -511,7 +558,16 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
       create_crt_fd(&fdexcep, &crt_fdexcep);
 #endif
 
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+      fdset_args.maxfd = maxfd+1;
+      fdset_args.fdread = &fdread;
+      fdset_args.fdwrite = &fdwrite;
+      fdset_args.fdexcep = &fdexcep;
+      fdset_args.tv = &tv;
+      rc = rb_thread_blocking_region(curb_select, &fdset_args, RUBY_UBF_IO, 0);
+#else
       rc = rb_thread_select(maxfd+1, &fdread, &fdwrite, &fdexcep, &tv);
+#endif
 
 #ifdef _WIN32
       cleanup_crt_fd(&fdread, &crt_fdread);

data/ext/extconf.rb

@@ -35,16 +35,17 @@ end
 #  puts "Selected arch: #{archs.first}"
 #end
 
-def define(s)
-  $defs.push( format("-D HAVE_%s", s.to_s.upcase) )
+def define(s, v=1)
+  $defs.push( format("-D HAVE_%s=%d", s.to_s.upcase, v) )
 end
 
 def have_constant(name)
+  sname = name.is_a?(Symbol) ? name.to_s : name.upcase
   checking_for name do
     src = %{
       #include <curl/curl.h>
       int main() {
-        int test = (int)#{name.upcase};
+        int test = (int)#{sname};
         return 0;
       }
     }
@@ -52,6 +53,7 @@ def have_constant(name)
       define name
       true
     else
+      #define name, 0
       false
     end
   end
@@ -99,6 +101,13 @@ have_constant "curle_login_denied"
 # older than 7.16.3
 have_constant "curlmopt_maxconnects"
 
+have_constant "curlopt_seekfunction"
+have_constant "curlopt_seekdata"
+have_constant "curlopt_sockoptfunction"
+have_constant "curlopt_sockoptdata"
+have_constant "curlopt_opensocketfunction"
+have_constant "curlopt_opensocketdata"
+
 # additional consts
 have_constant "curle_conv_failed"
 have_constant "curle_conv_reqd"
@@ -130,6 +139,215 @@ have_func("curl_multi_timeout")
 have_func("curl_multi_fdset")
 have_func("curl_multi_perform")
 
+# constants
+have_constant "curlopt_interleavefunction"
+have_constant "curlopt_interleavedata"
+have_constant "curlopt_chunk_bgn_function"
+have_constant "curlopt_chunk_end_function"
+have_constant "curlopt_chunk_data"
+have_constant "curlopt_fnmatch_function"
+have_constant "curlopt_fnmatch_data"
+have_constant "curlopt_errorbuffer"
+have_constant "curlopt_stderr"
+have_constant "curlopt_failonerror"
+have_constant "curlopt_url"
+have_constant "curlopt_protocols"
+have_constant "curlopt_redir_protocols"
+have_constant "curlopt_proxy"
+have_constant "curlopt_proxyport"
+have_constant "curlopt_proxytype"
+have_constant "curlopt_noproxy"
+have_constant "curlopt_httpproxytunnel"
+have_constant "curlopt_socks5_gssapi_service"
+have_constant "curlopt_socks5_gssapi_nec"
+have_constant "curlopt_interface"
+have_constant "curlopt_localport"
+have_constant "curlopt_dns_cache_timeout"
+have_constant "curlopt_dns_use_global_cache"
+have_constant "curlopt_buffersize"
+have_constant "curlopt_port"
+have_constant "curlopt_tcp_nodelay"
+have_constant "curlopt_address_scope"
+have_constant "curlopt_netrc"
+have_constant "curl_netrc_optional"
+have_constant "curl_netrc_ignored"
+have_constant "curl_netrc_required"
+have_constant "curlopt_netrc_file"
+have_constant "curlopt_userpwd"
+have_constant "curlopt_proxyuserpwd"
+have_constant "curlopt_username"
+have_constant "curlopt_password"
+have_constant "curlopt_password"
+have_constant "curlopt_password"
+have_constant "curlopt_httpauth"
+have_constant "curlauth_digest_ie"
+have_constant "curlauth_only"
+have_constant "curlopt_tlsauth_type"
+have_constant "curlopt_tlsauth_srp"
+have_constant "curlopt_tlsauth_username"
+have_constant "curlopt_tlsauth_password"
+have_constant "curlopt_proxyauth"
+have_constant "curlopt_autoreferer"
+have_constant "curlopt_encoding"
+have_constant "curlopt_followlocation"
+have_constant "curlopt_unrestricted_auth"
+have_constant "curlopt_maxredirs"
+have_constant "curlopt_postredir"
+have_constant "curlopt_put"
+have_constant "curlopt_post"
+have_constant "curlopt_postfields"
+have_constant "curlopt_postfieldsize"
+have_constant "curlopt_postfieldsize_large"
+have_constant "curlopt_copypostfields"
+have_constant "curlopt_httppost"
+have_constant "curlopt_referer"
+have_constant "curlopt_useragent"
+have_constant "curlopt_httpheader"
+have_constant "curlopt_http200aliases"
+have_constant "curlopt_cookie"
+have_constant "curlopt_cookiefile"
+have_constant "curlopt_cookiejar"
+have_constant "curlopt_cookiesession"
+have_constant "curlopt_cookielist"
+have_constant "curlopt_httpget"
+have_constant "curlopt_http_version"
+have_constant "curl_http_version_none"
+have_constant "curl_http_version_1_0"
+have_constant "curl_http_version_1_1"
+have_constant "curlopt_ignore_content_length"
+have_constant "curlopt_http_content_decoding"
+have_constant "curlopt_http_transfer_decoding"
+have_constant "curlopt_mail_from"
+have_constant "curlopt_mail_rcpt"
+have_constant "curlopt_tftp_blksize"
+have_constant "curlopt_ftpport"
+have_constant "curlopt_quote"
+have_constant "curlopt_postquote"
+have_constant "curlopt_prequote"
+have_constant "curlopt_dirlistonly"
+have_constant "curlopt_append"
+have_constant "curlopt_ftp_use_eprt"
+have_constant "curlopt_ftp_use_epsv"
+have_constant "curlopt_ftp_use_pret"
+have_constant "curlopt_ftp_create_missing_dirs"
+have_constant "curlopt_ftp_response_timeout"
+have_constant "curlopt_ftp_alternative_to_user"
+have_constant "curlopt_ftp_skip_pasv_ip"
+have_constant "curlopt_ftpsslauth"
+have_constant "curlftpauth_default"
+have_constant "curlftpauth_ssl"
+have_constant "curlftpauth_tls"
+have_constant "curlopt_ftp_ssl_ccc"
+have_constant "curlftpssl_ccc_none"
+have_constant "curlftpssl_ccc_passive"
+have_constant "curlftpssl_ccc_active"
+have_constant "curlopt_ftp_account"
+have_constant "curlopt_ftp_filemethod"
+have_constant "curlftpmethod_multicwd"
+have_constant "curlftpmethod_nocwd"
+have_constant "curlftpmethod_singlecwd"
+have_constant "curlopt_rtsp_request"
+have_constant "curl_rtspreq_options"
+have_constant "curl_rtspreq_describe"
+have_constant "curl_rtspreq_announce"
+have_constant "curl_rtspreq_setup"
+have_constant "curl_rtspreq_play"
+have_constant "curl_rtspreq_pause"
+have_constant "curl_rtspreq_teardown"
+have_constant "curl_rtspreq_get_parameter"
+have_constant "curl_rtspreq_set_parameter"
+have_constant "curl_rtspreq_record"
+have_constant "curl_rtspreq_receive"
+have_constant "curlopt_rtsp_session_id"
+have_constant "curlopt_rtsp_stream_uri"
+have_constant "curlopt_rtsp_transport"
+have_constant "curlopt_rtsp_header"
+have_constant "curlopt_rtsp_client_cseq"
+have_constant "curlopt_rtsp_server_cseq"
+have_constant "curlopt_transfertext"
+have_constant "curlopt_proxy_transfer_mode"
+have_constant "curlopt_crlf"
+have_constant "curlopt_range"
+have_constant "curlopt_resume_from"
+have_constant "curlopt_resume_from_large"
+have_constant "curlopt_customrequest"
+have_constant "curlopt_filetime"
+have_constant "curlopt_nobody"
+have_constant "curlopt_infilesize"
+have_constant "curlopt_infilesize_large"
+have_constant "curlopt_upload"
+have_constant "curlopt_maxfilesize"
+have_constant "curlopt_maxfilesize_large"
+have_constant "curlopt_timecondition"
+have_constant "curlopt_timevalue"
+have_constant "curlopt_timeout"
+have_constant "curlopt_timeout_ms"
+have_constant "curlopt_low_speed_limit"
+have_constant "curlopt_low_speed_time"
+have_constant "curlopt_max_send_speed_large"
+have_constant "curlopt_max_recv_speed_large"
+have_constant "curlopt_maxconnects"
+have_constant "curlopt_closepolicy"
+have_constant "curlopt_fresh_connect"
+have_constant "curlopt_forbid_reuse"
+have_constant "curlopt_connecttimeout"
+have_constant "curlopt_connecttimeout_ms"
+have_constant "curlopt_ipresolve"
+have_constant "curl_ipresolve_whatever"
+have_constant "curl_ipresolve_v4"
+have_constant "curl_ipresolve_v6"
+have_constant "curlopt_connect_only"
+have_constant "curlopt_use_ssl"
+have_constant "curlusessl_none"
+have_constant "curlusessl_try"
+have_constant "curlusessl_control"
+have_constant "curlusessl_all"
+have_constant "curlopt_resolve"
+have_constant "curlopt_sslcert"
+have_constant "curlopt_sslcerttype"
+have_constant "curlopt_sslkey"
+have_constant "curlopt_sslkeytype"
+have_constant "curlopt_keypasswd"
+have_constant "curlopt_sslengine"
+have_constant "curlopt_sslengine_default"
+have_constant "curlopt_sslversion"
+have_constant "curl_sslversion_default"
+have_constant :CURL_SSLVERSION_TLSv1
+have_constant :CURL_SSLVERSION_SSLv2
+have_constant :CURL_SSLVERSION_SSLv3
+have_constant "curlopt_ssl_verifypeer"
+have_constant "curlopt_cainfo"
+have_constant "curlopt_issuercert"
+have_constant "curlopt_capath"
+have_constant "curlopt_crlfile"
+have_constant "curlopt_ssl_verifyhost"
+have_constant "curlopt_certinfo"
+have_constant "curlopt_random_file"
+have_constant "curlopt_egdsocket"
+have_constant "curlopt_ssl_cipher_list"
+have_constant "curlopt_ssl_sessionid_cache"
+have_constant "curlopt_krblevel"
+have_constant "curlopt_ssh_auth_types"
+have_constant "curlopt_ssh_host_public_key_md5"
+have_constant "curlopt_ssh_public_keyfile"
+have_constant "curlopt_ssh_private_keyfile"
+have_constant "curlopt_ssh_knownhosts"
+have_constant "curlopt_ssh_keyfunction"
+have_constant "curlkhstat_fine_add_to_file"
+have_constant "curlkhstat_fine"
+have_constant "curlkhstat_reject"
+have_constant "curlkhstat_defer"
+have_constant "curlopt_ssh_keydata"
+have_constant "curlopt_private"
+have_constant "curlopt_share"
+have_constant "curlopt_new_file_perms"
+have_constant "curlopt_new_directory_perms"
+have_constant "curlopt_telnetoptions"
+# was obsoleted in August 2007 for 7.17.0, reused in April 2011 for 7.21.5
+have_constant "curle_not_built_in"
+
+have_constant "curle_obsolete" # removed in 7.24 ?
+
 if try_compile('int main() { return 0; }','-Wall')
   $CFLAGS << ' -Wall'
 end
@@ -172,5 +390,7 @@ test_for("curl_easy_escape", "CURL_EASY_ESCAPE", %{
   }
 })
 
+have_func('rb_thread_blocking_region')
+
 create_header('curb_config.h')
 create_makefile('curb_core')