curb 0.1.4 → 0.7.15

data/ext/curb_postfield.c

@@ -41,7 +41,7 @@ void append_to_form(VALUE self,
       // is a file upload field
       if (rbcpf->content_proc != Qnil) {
         // with content proc
-        rbcpf->buffer_str = rb_funcall(rbcpf->content_proc, idCall, self);
+        rbcpf->buffer_str = rb_funcall(rbcpf->content_proc, idCall, 1, self);
         
         if (rbcpf->remote_file == Qnil) {
           rb_raise(eCurlErrInvalidPostField, "Cannot post file upload field with no filename");
@@ -109,7 +109,7 @@ void append_to_form(VALUE self,
     } else {
       // is a content field
       if (rbcpf->content_proc != Qnil) {
-        rbcpf->buffer_str = rb_funcall(rbcpf->content_proc, idCall, self);
+        rbcpf->buffer_str = rb_funcall(rbcpf->content_proc, idCall, 1, self);
         
         if (rbcpf->content_type == Qnil) {
           result = curl_formadd(first, last, CURLFORM_PTRNAME, StringValuePtr(rbcpf->name), 
@@ -143,7 +143,7 @@ void append_to_form(VALUE self,
   }
   
   if (result != 0) {
-    char *reason;
+    const char *reason = NULL;
     
     switch (result) {
       case CURL_FORMADD_MEMORY:
@@ -209,11 +209,11 @@ void curl_postfield_free(ruby_curl_postfield *rbcpf) {
  */
 static VALUE ruby_curl_postfield_new_content(int argc, VALUE *argv, VALUE klass) {
   ruby_curl_postfield *rbcpf = ALLOC(ruby_curl_postfield);
-  
+ 
   // wierdness - we actually require two args, unless a block is provided, but
   // we have to work that out below.
   rb_scan_args(argc, argv, "12&", &rbcpf->name, &rbcpf->content, &rbcpf->content_type, &rbcpf->content_proc);
-  
+
   // special handling if theres a block, second arg is actually content_type
   if (rbcpf->content_proc != Qnil) {
     if (rbcpf->content != Qnil) {
@@ -235,7 +235,7 @@ static VALUE ruby_curl_postfield_new_content(int argc, VALUE *argv, VALUE klass)
   rbcpf->local_file = Qnil;
   rbcpf->remote_file = Qnil;
   rbcpf->buffer_str = Qnil;
-  
+ 
   return Data_Wrap_Struct(cCurlPostField, curl_postfield_mark, curl_postfield_free, rbcpf);
 }
 
@@ -253,11 +253,11 @@ static VALUE ruby_curl_postfield_new_content(int argc, VALUE *argv, VALUE klass)
  * data.
  */
 static VALUE ruby_curl_postfield_new_file(int argc, VALUE *argv, VALUE klass) {
-  // TODO needs to handle content-type too 
+  // TODO needs to handle content-type too
   ruby_curl_postfield *rbcpf = ALLOC(ruby_curl_postfield);
-  
+
   rb_scan_args(argc, argv, "21&", &rbcpf->name, &rbcpf->local_file, &rbcpf->remote_file, &rbcpf->content_proc);
-  
+
   // special handling if theres a block, second arg is actually remote name.
   if (rbcpf->content_proc != Qnil) {
     if (rbcpf->local_file != Qnil) {
@@ -267,7 +267,7 @@ static VALUE ruby_curl_postfield_new_file(int argc, VALUE *argv, VALUE klass) {
         // (correct block call form)
         rbcpf->remote_file = rbcpf->local_file;
       }
-      
+ 
       // Shouldn't get a local file, so can ignore it.
       rbcpf->local_file = Qnil;
     }
@@ -275,13 +275,13 @@ static VALUE ruby_curl_postfield_new_file(int argc, VALUE *argv, VALUE klass) {
     if (rbcpf->remote_file == Qnil) {
       rbcpf->remote_file = rbcpf->local_file;
     }
-  }    
-      
+  }
+ 
   /* assoc objects */
   rbcpf->content = Qnil;
   rbcpf->content_type = Qnil;
   rbcpf->buffer_str = Qnil;
-  
+ 
   return Data_Wrap_Struct(cCurlPostField, curl_postfield_mark, curl_postfield_free, rbcpf);
 }
 
@@ -424,45 +424,67 @@ static VALUE ruby_curl_postfield_to_str(VALUE self) {
   // FIXME This is using the deprecated curl_escape func
   ruby_curl_postfield *rbcpf;
   VALUE result = Qnil;
+  VALUE name = Qnil;
+  char *tmpchrs;
   
   Data_Get_Struct(self, ruby_curl_postfield, rbcpf);
 
-  if ((rbcpf->local_file == Qnil) && (rbcpf->remote_file == Qnil)) {
     if (rbcpf->name != Qnil) {
-      char *tmpchrs;
+      name = rbcpf->name;
+      if (rb_type(name) == T_STRING) {
+        name = rbcpf->name;
+      } else if (rb_respond_to(name,rb_intern("to_s"))) {
+        name = rb_funcall(name, rb_intern("to_s"), 0);
+      }
+      else {
+        name = Qnil; // we can't handle this object
+      }
+    }
+    if (name == Qnil) {
+      rb_raise(eCurlErrInvalidPostField, "Cannot convert unnamed field to string %s:%d, make sure your field name responds_to :to_s", __FILE__, __LINE__);
+    }
+
+    tmpchrs = curl_escape(StringValuePtr(name), (int)RSTRING_LEN(name));
+    
+    if (!tmpchrs) {
+      rb_raise(eCurlErrInvalidPostField, "Failed to url-encode name `%s'", tmpchrs);
+    } else {
+      VALUE tmpcontent = Qnil;
+      VALUE escd_name = rb_str_new2(tmpchrs);
+      curl_free(tmpchrs);
       
-      if ((tmpchrs = curl_escape(StringValuePtr(rbcpf->name), RSTRING_LEN(rbcpf->name))) == NULL) {
-        rb_raise(eCurlErrInvalidPostField, "Failed to url-encode name `%s'", tmpchrs);
+      if (rbcpf->content_proc != Qnil) {
+        tmpcontent = rb_funcall(rbcpf->content_proc, idCall, 1, self);
+      } else if (rbcpf->content != Qnil) {
+        tmpcontent = rbcpf->content;
+      } else if (rbcpf->local_file != Qnil) {
+        tmpcontent = rbcpf->local_file;
+      } else if (rbcpf->remote_file != Qnil) {
+        tmpcontent = rbcpf->remote_file;
       } else {
-        VALUE tmpcontent = Qnil;
-        VALUE escd_name = rb_str_new2(tmpchrs);
-        curl_free(tmpchrs);
-        
-        if (rbcpf->content_proc != Qnil) {
-          tmpcontent = rb_funcall(rbcpf->content_proc, idCall, 1, self);
-        } else if (rbcpf->content != Qnil) {
-          tmpcontent = rbcpf->content;
-        } else {
-          tmpcontent = rb_str_new2("");
+        tmpcontent = rb_str_new2("");
+      }
+      if (TYPE(tmpcontent) != T_STRING) {
+        if (rb_respond_to(tmpcontent, rb_intern("to_s"))) {
+          tmpcontent = rb_funcall(tmpcontent, rb_intern("to_s"), 0);
+        }
+        else {
+          rb_raise(rb_eRuntimeError, "postfield(%s) is not a string and does not respond_to to_s", RSTRING_PTR(escd_name) );
         }
+      }
+      //fprintf(stderr, "encoding content: %ld - %s\n", RSTRING_LEN(tmpcontent), RSTRING_PTR(tmpcontent) );
+      tmpchrs = curl_escape(RSTRING_PTR(tmpcontent), (int)RSTRING_LEN(tmpcontent));
+      if (!tmpchrs) {
+        rb_raise(eCurlErrInvalidPostField, "Failed to url-encode content `%s'", tmpchrs);
+      } else {
+        VALUE escd_content = rb_str_new2(tmpchrs);
+        curl_free(tmpchrs);
         
-        if ((tmpchrs = curl_escape(StringValuePtr(tmpcontent), RSTRING_LEN(tmpcontent))) == NULL) {
-          rb_raise(eCurlErrInvalidPostField, "Failed to url-encode content `%s'", tmpchrs);
-        } else {
-          VALUE escd_content = rb_str_new2(tmpchrs);
-          curl_free(tmpchrs);
-          
-          result = escd_name;
-          rb_str_cat(result, "=", 1);
-          rb_str_concat(result, escd_content); 
-        }            
+        result = escd_name;
+        rb_str_cat(result, "=", 1);
+        rb_str_concat(result, escd_content); 
       }
-    } else {
-      rb_raise(eCurlErrInvalidPostField, "Cannot convert unnamed field to string");
-    }      
-  } else {
-    rb_raise(eCurlErrInvalidPostField, "Cannot convert non-content field to string");
-  }  
+    }
   
   return result;
 }
@@ -470,6 +492,8 @@ static VALUE ruby_curl_postfield_to_str(VALUE self) {
 
 /* =================== INIT LIB =====================*/
 void init_curb_postfield() {
+  VALUE sc;
+
   idCall = rb_intern("call");
   
   cCurlPostField = rb_define_class_under(mCurl, "PostField", rb_cObject);
@@ -478,7 +502,7 @@ void init_curb_postfield() {
   rb_define_singleton_method(cCurlPostField, "content", ruby_curl_postfield_new_content, -1);
   rb_define_singleton_method(cCurlPostField, "file", ruby_curl_postfield_new_file, -1);
   
-  VALUE sc = rb_singleton_class(cCurlPostField);
+  sc = rb_singleton_class(cCurlPostField);
   rb_undef(sc, rb_intern("new"));
   
   rb_define_method(cCurlPostField, "name=", ruby_curl_postfield_name_set, 1);

data/ext/curb_upload.c

@@ -0,0 +1,80 @@
+/* curb_upload.c - Curl upload handle
+ * Copyright (c)2009 Todd A Fisher. 
+ * Licensed under the Ruby License. See LICENSE for details.
+ */
+#include "curb_upload.h"
+extern VALUE mCurl;
+VALUE cCurlUpload;
+
+#ifdef RDOC_NEVER_DEFINED
+  mCurl = rb_define_module("Curl");
+#endif
+
+static void curl_upload_mark(ruby_curl_upload *rbcu) {
+  if (rbcu->stream && !NIL_P(rbcu->stream)) rb_gc_mark(rbcu->stream);
+}
+static void curl_upload_free(ruby_curl_upload *rbcu) {
+  free(rbcu);
+}
+
+/*
+ * call-seq:
+ *   internal class for sending large file uploads
+ */
+VALUE ruby_curl_upload_new(VALUE klass) {
+  VALUE upload;
+  ruby_curl_upload *rbcu = ALLOC(ruby_curl_upload);
+  rbcu->stream = Qnil;
+  rbcu->offset = 0;
+  upload = Data_Wrap_Struct(klass, curl_upload_mark, curl_upload_free, rbcu);
+  return upload;
+}
+
+/*
+ * call-seq:
+ *   internal class for sending large file uploads
+ */
+VALUE ruby_curl_upload_stream_set(VALUE self, VALUE stream) {
+  ruby_curl_upload *rbcu;
+  Data_Get_Struct(self, ruby_curl_upload, rbcu);
+  rbcu->stream = stream;
+  return stream;
+}
+/*
+ * call-seq:
+ *   internal class for sending large file uploads
+ */
+VALUE ruby_curl_upload_stream_get(VALUE self) {
+  ruby_curl_upload *rbcu;
+  Data_Get_Struct(self, ruby_curl_upload, rbcu);
+  return rbcu->stream;
+}
+/*
+ * call-seq:
+ *   internal class for sending large file uploads
+ */
+VALUE ruby_curl_upload_offset_set(VALUE self, VALUE offset) {
+  ruby_curl_upload *rbcu;
+  Data_Get_Struct(self, ruby_curl_upload, rbcu);
+  rbcu->offset = FIX2LONG(offset);
+  return offset;
+}
+/*
+ * call-seq:
+ *   internal class for sending large file uploads
+ */
+VALUE ruby_curl_upload_offset_get(VALUE self) {
+  ruby_curl_upload *rbcu;
+  Data_Get_Struct(self, ruby_curl_upload, rbcu);
+  return INT2FIX(rbcu->offset);
+}
+
+/* =================== INIT LIB =====================*/
+void init_curb_upload() {
+  cCurlUpload = rb_define_class_under(mCurl, "Upload", rb_cObject);
+  rb_define_singleton_method(cCurlUpload, "new", ruby_curl_upload_new, 0);
+  rb_define_method(cCurlUpload, "stream=", ruby_curl_upload_stream_set, 1);
+  rb_define_method(cCurlUpload, "stream", ruby_curl_upload_stream_get, 0);
+  rb_define_method(cCurlUpload, "offset=", ruby_curl_upload_offset_set, 1);
+  rb_define_method(cCurlUpload, "offset", ruby_curl_upload_offset_get, 0);
+}

data/ext/curb_upload.h

@@ -0,0 +1,30 @@
+/* curb_upload.h - Curl upload handle
+ * Copyright (c)2009 Todd A Fisher. 
+ * Licensed under the Ruby License. See LICENSE for details.
+ */
+#ifndef __CURB_UPLOAD_H
+#define __CURB_UPLOAD_H
+
+#include "curb.h"
+
+#include <curl/easy.h>
+
+/*
+ * Maintain the state of an upload e.g. for putting large streams with very little memory
+ * out to a server. via PUT requests
+ */
+typedef struct {
+  VALUE stream;
+  size_t offset;
+} ruby_curl_upload;
+
+extern VALUE cCurlUpload;
+void init_curb_upload();
+
+VALUE ruby_curl_upload_new(VALUE klass);
+VALUE ruby_curl_upload_stream_set(VALUE self, VALUE stream);
+VALUE ruby_curl_upload_stream_get(VALUE self);
+VALUE ruby_curl_upload_offset_set(VALUE self, VALUE offset);
+VALUE ruby_curl_upload_offset_get(VALUE self);
+
+#endif

data/ext/extconf.rb

@@ -2,23 +2,175 @@ require 'mkmf'
 
 dir_config('curl')
 
-unless have_library('curl') &&
-       have_header('curl/curl.h')
+if find_executable('curl-config')
+  $CFLAGS << " #{`curl-config --cflags`.strip} -g"
+  if ENV['STATIC_BUILD']
+    $LIBS << " #{`curl-config --static-libs`.strip}"
+  else
+    $LIBS << " #{`curl-config --libs`.strip}"
+  end
+  ca_bundle_path=`curl-config --ca`.strip
+  if !ca_bundle_path.nil? and ca_bundle_path != ''
+    $defs.push( %{-D HAVE_CURL_CONFIG_CA} )
+    $defs.push( %{-D CURL_CONFIG_CA='#{ca_bundle_path.inspect}'} )
+  end
+elsif !have_library('curl') or !have_header('curl/curl.h')
   fail <<-EOM
   Can't find libcurl or curl/curl.h
-  
+
   Try passing --with-curl-dir or --with-curl-lib and --with-curl-include
   options to extconf.
   EOM
 end
 
-#install_rb("curb.rb", "$(RUBYLIBDIR)", '../lib')
-#install_rb("curl.rb", "$(RUBYLIBDIR)", '../lib')
-$INSTALLFILES = [["curb.rb", "$(RUBYLIBDIR)", "../ext"], ["curl.rb", "$(RUBYLIBDIR)", "../ext"]]
+# Check arch flags
+# TODO: detect mismatched arch types when libcurl mac ports is mixed with native mac ruby or vice versa
+#archs = $CFLAGS.scan(/-arch\s(.*?)\s/).first # get the first arch flag
+#if archs and archs.size >= 1
+#  # need to reduce the number of archs...
+#  # guess the first one is correct... at least the first one is probably the ruby installed arch...
+#  # this could lead to compiled binaries that crash at runtime...
+#  $CFLAGS.gsub!(/-arch\s(.*?)\s/,' ')
+#  $CFLAGS << " -arch #{archs.first}"
+#  puts "Selected arch: #{archs.first}"
+#end
+
+def define(s)
+  $defs.push( format("-D HAVE_%s", s.to_s.upcase) )
+end
+
+def have_constant(name)
+  checking_for name do
+    src = %{
+      #include <curl/curl.h>
+      int main() {
+        int test = (int)#{name.upcase};
+        return 0;
+      }
+    }
+    if try_compile(src,"#{$CFLAGS} #{$LIBS}")
+      define name
+      true
+    else
+      false
+    end
+  end
+end
+
+have_constant "curlinfo_redirect_time"
+have_constant "curlinfo_response_code"
+have_constant "curlinfo_filetime"
+have_constant "curlinfo_redirect_count"
+have_constant "curlinfo_os_errno"
+have_constant "curlinfo_num_connects"
+have_constant "curlinfo_ftp_entry_path"
+have_constant "curl_version_ssl"
+have_constant "curl_version_libz"
+have_constant "curl_version_ntlm"
+have_constant "curl_version_gssnegotiate"
+have_constant "curl_version_debug"
+have_constant "curl_version_asynchdns"
+have_constant "curl_version_spnego"
+have_constant "curl_version_largefile"
+have_constant "curl_version_idn"
+have_constant "curl_version_sspi"
+have_constant "curl_version_conv"
+have_constant "curlproxy_http"
+have_constant "curlproxy_socks4"
+have_constant "curlproxy_socks5"
+have_constant "curlauth_basic"
+have_constant "curlauth_digest"
+have_constant "curlauth_gssnegotiate"
+have_constant "curlauth_ntlm"
+have_constant "curlauth_anysafe"
+have_constant "curlauth_any"
+have_constant "curle_tftp_notfound"
+have_constant "curle_tftp_perm"
+have_constant "curle_tftp_diskfull"
+have_constant "curle_tftp_illegal"
+have_constant "curle_tftp_unknownid"
+have_constant "curle_tftp_exists"
+have_constant "curle_tftp_nosuchuser"
+# older versions of libcurl 7.12
+have_constant "curle_send_fail_rewind"
+have_constant "curle_ssl_engine_initfailed"
+have_constant "curle_login_denied"
+
+# older than 7.16.3
+have_constant "curlmopt_maxconnects"
+
+# additional consts
+have_constant "curle_conv_failed"
+have_constant "curle_conv_reqd"
+have_constant "curle_ssl_cacert_badfile"
+have_constant "curle_remote_file_not_found"
+have_constant "curle_ssh"
+have_constant "curle_ssl_shutdown_failed"
+have_constant "curle_again"
+have_constant "curle_ssl_crl_badfile"
+have_constant "curle_ssl_issuer_error"
+
+# username/password added in 7.19.1
+have_constant "curlopt_username"
+have_constant "curlopt_password"
+have_constant "curlinfo_primary_ip"
+
+# ie quirk added in 7.19.3
+have_constant "curlauth_digest_ie"
+
+# added in 7.15.1
+have_constant "curlftpmethod_multicwd"
+have_constant "curlftpmethod_nocwd"
+have_constant "curlftpmethod_singlecwd"
+
+# centos 4.5 build of libcurl
+have_constant "curlm_bad_socket"
+have_constant "curlm_unknown_option"
+have_func("curl_multi_timeout")
+have_func("curl_multi_fdset")
+have_func("curl_multi_perform")
 
 if try_compile('int main() { return 0; }','-Wall')
   $CFLAGS << ' -Wall'
 end
 
-create_makefile('curb_core')
+# do some checking to detect ruby 1.8 hash.c vs ruby 1.9 hash.c
+def test_for(name, const, src)
+  checking_for name do
+    if try_compile(src,"#{$CFLAGS} #{$LIBS}")
+      define const
+      true
+    else
+      false
+    end
+  end
+end
+test_for("Ruby 1.9 Hash", "RUBY19_HASH", %{
+  #include <ruby.h>
+  int main() {
+    VALUE hash = rb_hash_new();
+    if( RHASH(hash)->ntbl->num_entries ) {
+      return 0;
+    }
+    return 1;
+  }
+})
+test_for("Ruby 1.9 st.h", "RUBY19_ST_H", %{
+  #include <ruby.h>
+  #include <ruby/st.h>
+  int main() {
+    return 0;
+  }
+})
 
+test_for("curl_easy_escape", "CURL_EASY_ESCAPE", %{
+  #include <curl/curl.h>
+  int main() {
+    CURL *easy = curl_easy_init();
+    curl_easy_escape(easy,"hello",5);
+    return 0;
+  }
+})
+
+create_header('curb_config.h')
+create_makefile('curb_core')