curb 0.1.2 → 0.1.4

data/Rakefile

@@ -11,7 +11,7 @@ rescue LoadError
 end
 
 CLEAN.include '**/*.o'
-CLEAN.include '**/*.so'
+CLEAN.include "**/*.#{Config::MAKEFILE_CONFIG['DLEXT']}"
 CLOBBER.include 'doc'
 CLOBBER.include '**/*.log'
 CLOBBER.include '**/Makefile'
@@ -45,6 +45,8 @@ end
 MAKECMD = ENV['MAKE_CMD'] || 'make'
 MAKEOPTS = ENV['MAKE_OPTS'] || ''
 
+CURB_SO = "ext/curb_core.#{Config::MAKEFILE_CONFIG['DLEXT']}"
+
 file 'ext/Makefile' => 'ext/extconf.rb' do
   Dir.chdir('ext') do
     ruby "extconf.rb #{ENV['EXTCONF_OPTS']}"
@@ -53,20 +55,19 @@ end
 
 def make(target = '')
   Dir.chdir('ext') do 
-    pid = fork { exec "#{MAKECMD} #{MAKEOPTS} #{target}" }
-    Process.waitpid pid
+    pid = system("#{MAKECMD} #{MAKEOPTS} #{target}")
     $?.exitstatus
   end    
 end
 
 # Let make handle dependencies between c/o/so - we'll just run it. 
-file 'ext/curb_core.so' => 'ext/Makefile' do
+file CURB_SO => 'ext/Makefile' do
   m = make
   fail "Make failed (status #{m})" unless m == 0
 end
 
 desc "Compile the shared object"
-task :compile => 'ext/curb_core.so'
+task :compile => CURB_SO
 
 desc "Install to your site_ruby directory"
 task :install => :alltests do

data/ext/curb.h

@@ -18,11 +18,11 @@
 #include "curb_macros.h"
 
 // These should be managed from the Rake 'release' task.
-#define CURB_VERSION   "0.1.2"
-#define CURB_VER_NUM   120
+#define CURB_VERSION   "0.1.4"
+#define CURB_VER_NUM   140
 #define CURB_VER_MAJ   0
 #define CURB_VER_MIN   1
-#define CURB_VER_MIC   2
+#define CURB_VER_MIC   4
 #define CURB_VER_PATCH 0
 
 

data/ext/curb.rb

@@ -27,8 +27,8 @@ module Curl
       # returns a size that differs from the data chunk size - in this case, the 
       # offending chunk will *not* be written to the file, the file will be closed,
       # and a Curl::Err::AbortedByCallbackError will be raised.
-      def download(url, filename = url.split(/\?/).first.split(/\//).last)
-        curl = Curl::Easy.new(url) { |curl| yield curl if block_given? }
+      def download(url, filename = url.split(/\?/).first.split(/\//).last, &blk)
+        curl = Curl::Easy.new(url, &blk)
         
         File.open(filename, "wb") do |output|
           old_on_body = curl.on_body do |data| 

data/ext/curb_easy.c

@@ -156,7 +156,8 @@ static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
   /* bool opts */
   rbce->proxy_tunnel = 0;
   rbce->fetch_file_time = 0;
-  rbce->ssl_verify_peer = 0;
+  rbce->ssl_verify_peer = 1;
+  rbce->ssl_verify_host = 1;
   rbce->header_in_body = 0;
   rbce->use_netrc = 0;
   rbce->follow_location = 0;
@@ -715,7 +716,14 @@ static VALUE ruby_curl_easy_fetch_file_time_q(VALUE self) {
  *   ssl_verify_peer = boolean                        => boolean
  * 
  * Configure whether this Curl instance will verify the SSL peer
- * certificate.
+ * certificate. When true (the default), and the verification fails to 
+ * prove that the certificate is authentic, the connection fails. When 
+ * false, the connection succeeds regardless.
+ * 
+ * Authenticating the certificate is not by itself very useful. You 
+ * typically want to ensure that the server, as authentically identified 
+ * by its certificate, is the server you mean to be talking to. 
+ * The ssl_verify_host? options controls that.
  */
 static VALUE ruby_curl_easy_ssl_verify_peer_set(VALUE self, VALUE ssl_verify_peer) {
   CURB_BOOLEAN_SETTER(ruby_curl_easy, ssl_verify_peer);
@@ -732,6 +740,34 @@ static VALUE ruby_curl_easy_ssl_verify_peer_q(VALUE self) {
   CURB_BOOLEAN_GETTER(ruby_curl_easy, ssl_verify_peer);
 }
 
+/*
+ * call-seq:
+ *   ssl_verify_host = boolean                        => boolean
+ * 
+ * Configure whether this Curl instance will verify that the server cert 
+ * is for the server it is known as. When true (the default) the server 
+ * certificate must indicate that the server is the server to which you 
+ * meant to connect, or the connection fails. When false, the connection
+ * will succeed regardless of the names in the certificate.
+ * 
+ * this option controls is of the identity that the server claims. 
+ * The server could be lying. To control lying, see ssl_verify_peer? .
+ */
+static VALUE ruby_curl_easy_ssl_verify_host_set(VALUE self, VALUE ssl_verify_host) {
+  CURB_BOOLEAN_SETTER(ruby_curl_easy, ssl_verify_host);
+}
+
+/*
+ * call-seq:
+ *   ssl_verify_host?                                 => boolean
+ * 
+ * Determine whether this Curl instance will verify that the server cert 
+ * is for the server it is known as.
+ */
+static VALUE ruby_curl_easy_ssl_verify_host_q(VALUE self) {
+  CURB_BOOLEAN_GETTER(ruby_curl_easy, ssl_verify_host);
+}
+
 /*
  * call-seq:
  *   header_in_body = boolean                         => boolean
@@ -984,7 +1020,7 @@ static VALUE ruby_curl_easy_on_debug_set(int argc, VALUE *argv, VALUE self) {
 static VALUE cb_each_http_header(VALUE header, struct curl_slist **list) {
   VALUE header_str = Qnil;
   
-  rb_p(header);
+  //rb_p(header);
   
   if (rb_type(header) == T_ARRAY) {
     // we're processing a hash, header is [name, val]
@@ -1001,7 +1037,7 @@ static VALUE cb_each_http_header(VALUE header, struct curl_slist **list) {
     header_str = rb_obj_as_string(header);
   }
   
-  rb_p(header_str);
+  //rb_p(header_str);
   
   *list = curl_slist_append(*list, StringValuePtr(header_str));
   return header_str;  
@@ -1108,6 +1144,7 @@ static VALUE handle_perform(ruby_curl_easy *rbce) {
     curl_easy_setopt(curl, CURLOPT_HTTPPROXYTUNNEL, rbce->proxy_tunnel);
     curl_easy_setopt(curl, CURLOPT_FILETIME, rbce->fetch_file_time);
     curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, rbce->ssl_verify_peer);
+    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, rbce->ssl_verify_peer);
             
     if ((rbce->use_netrc != Qnil) && (rbce->use_netrc != Qfalse)) {
       curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, CURL_NETRC_OPTIONAL);
@@ -1263,8 +1300,9 @@ static VALUE ruby_curl_easy_perform_get(VALUE self) {
  *   easy.perform                                     => true
  * 
  * Transfer the currently configured URL using the options set for this
- * Curl::Easy instance. If this is a HTTP URL, it will be transferred via
- * the GET request method.
+ * Curl::Easy instance. If this is an HTTP URL, it will be transferred via
+ * the GET request method (i.e. this method is a synonym for +http_get+ 
+ * when using HTTP URLs).
  */
 static VALUE ruby_curl_easy_perform(VALUE self) {  
   return ruby_curl_easy_perform_get(self);
@@ -1861,7 +1899,7 @@ static VALUE ruby_curl_easy_os_errno_get(VALUE self) {
     
 /*
  * call-seq:
- *   easy.os_errno                                    => integer
+ *   easy.num_connects                                    => integer
  * 
  * Retrieve the number of new connections libcurl had to create to achieve 
  * the previous transfer (only the successful connects are counted). 
@@ -2041,10 +2079,10 @@ static VALUE ruby_curl_easy_class_perform_get(int argc, VALUE *argv, VALUE klass
 
 /*
  * call-seq:
- *   Curl::Easy.http_post("url=encoded%20form%20data;and=so%20on") => true
- *   Curl::Easy.http_post("url=encoded%20form%20data", "and=so%20on", ...) => true
- *   Curl::Easy.http_post("url=encoded%20form%20data", Curl::PostField, "and=so%20on", ...) => true
- *   Curl::Easy.http_post(Curl::PostField, Curl::PostField ..., Curl::PostField) => true
+ *   Curl::Easy.http_post(url, "some=urlencoded%20form%20data&and=so%20on") => true
+ *   Curl::Easy.http_post(url, "some=urlencoded%20form%20data", "and=so%20on", ...) => true
+ *   Curl::Easy.http_post(url, "some=urlencoded%20form%20data", Curl::PostField, "and=so%20on", ...) => true
+ *   Curl::Easy.http_post(url, Curl::PostField, Curl::PostField ..., Curl::PostField) => true
  * 
  * POST the specified formdata to the currently configured URL using 
  * the current options set for this Curl::Easy instance. This method 
@@ -2133,6 +2171,8 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "fetch_file_time?", ruby_curl_easy_fetch_file_time_q, 0);
   rb_define_method(cCurlEasy, "ssl_verify_peer=", ruby_curl_easy_ssl_verify_peer_set, 1);
   rb_define_method(cCurlEasy, "ssl_verify_peer?", ruby_curl_easy_ssl_verify_peer_q, 0);
+  rb_define_method(cCurlEasy, "ssl_verify_host=", ruby_curl_easy_ssl_verify_host_set, 1);
+  rb_define_method(cCurlEasy, "ssl_verify_host?", ruby_curl_easy_ssl_verify_host_q, 0);
   rb_define_method(cCurlEasy, "header_in_body=", ruby_curl_easy_header_in_body_set, 1);
   rb_define_method(cCurlEasy, "header_in_body?", ruby_curl_easy_header_in_body_q, 0);
   rb_define_method(cCurlEasy, "use_netrc=", ruby_curl_easy_use_netrc_set, 1);

data/ext/curb_easy.h

@@ -51,6 +51,7 @@ typedef struct {
   char proxy_tunnel;
   char fetch_file_time;
   char ssl_verify_peer;
+  char ssl_verify_host;
   char header_in_body;
   char use_netrc;
   char follow_location;

data/tests/tc_curl_easy.rb

@@ -378,9 +378,16 @@ class TestCurbCurlEasy < Test::Unit::TestCase
   
   def test_ssl_verify_peer
     c = Curl::Easy.new    
-    assert !c.ssl_verify_peer?
-    assert c.ssl_verify_peer = true
     assert c.ssl_verify_peer?
+    assert !c.ssl_verify_peer = false
+    assert !c.ssl_verify_peer?
+  end
+  
+  def test_ssl_verify_host
+    c = Curl::Easy.new    
+    assert c.ssl_verify_host?
+    assert !c.ssl_verify_host = false
+    assert !c.ssl_verify_host?
   end
   
   def test_header_in_body

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: curb
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
-date: 2007-01-14 00:00:00 +00:00
+  version: 0.1.4
+date: 2007-08-08 00:00:00 +01:00
 summary: Ruby bindings for the libcurl(3) URL transfer library.
 require_paths: 
 - lib