curb 0.8.4 → 1.3.5

data/ext/curb_multi.h

@@ -8,19 +8,26 @@
 #define __CURB_MULTI_H
 
 #include "curb.h"
-#include "curb_easy.h"
 #include <curl/multi.h>
 
+struct st_table;
+
 typedef struct {
   int active;
   int running;
-  VALUE requests; /* hash of handles currently added */
+  char closed;
+  char perform_active;
+  char callback_active;
+  char allow_close_during_perform;
   CURLM *handle;
+  struct st_table *attached;
 } ruby_curl_multi;
 
 extern VALUE cCurlMulti;
+extern const rb_data_type_t ruby_curl_multi_data_type;
+
 void init_curb_multi();
-VALUE ruby_curl_multi_new(VALUE klass);
+void rb_curl_multi_forget_easy(ruby_curl_multi *rbcm, void *rbce_ptr);
 
 
 #endif

data/ext/curb_postfield.c

@@ -32,7 +32,7 @@ void append_to_form(VALUE self,
   ruby_curl_postfield *rbcpf;
   CURLFORMcode result = -1;
   
-  Data_Get_Struct(self, ruby_curl_postfield, rbcpf);
+  TypedData_Get_Struct(self, ruby_curl_postfield, &ruby_curl_postfield_data_type, rbcpf);
   
   if (rbcpf->name == Qnil) {
     rb_raise(eCurlErrInvalidPostField, "Cannot post unnamed field");
@@ -177,27 +177,52 @@ void append_to_form(VALUE self,
 
 
 /* ================== MARK/FREE FUNC ==================*/
-void curl_postfield_mark(ruby_curl_postfield *rbcpf) {
-  rb_gc_mark(rbcpf->name);
-  rb_gc_mark(rbcpf->content);
-  rb_gc_mark(rbcpf->content_type);
-  rb_gc_mark(rbcpf->local_file);
-  rb_gc_mark(rbcpf->remote_file);
-  rb_gc_mark(rbcpf->buffer_str);
+static void curl_postfield_mark(void *ptr) {
+  ruby_curl_postfield *rbcpf = (ruby_curl_postfield *)ptr;
+  if (rbcpf) {
+    rb_gc_mark(rbcpf->name);
+    rb_gc_mark(rbcpf->content);
+    rb_gc_mark(rbcpf->content_type);
+    rb_gc_mark(rbcpf->content_proc);
+    rb_gc_mark(rbcpf->local_file);
+    rb_gc_mark(rbcpf->remote_file);
+    rb_gc_mark(rbcpf->buffer_str);
+  }
 }
 
-void curl_postfield_free(ruby_curl_postfield *rbcpf) {
-  free(rbcpf);
+static void curl_postfield_free(void *ptr) {
+  if (ptr) free(ptr);
 }
 
+static size_t curl_postfield_memsize(const void *ptr) {
+  (void)ptr;
+  return sizeof(ruby_curl_postfield);
+}
+
+const rb_data_type_t ruby_curl_postfield_data_type = {
+  "Curl::PostField",
+  {
+    curl_postfield_mark,
+    curl_postfield_free,
+    curl_postfield_memsize,
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    NULL, /* compact */
+#endif
+  },
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+  NULL, NULL, /* parent, data */
+  RUBY_TYPED_FREE_IMMEDIATELY
+#endif
+};
+
 
 /* ================= ALLOC METHODS ====================*/
 
 /*
  * call-seq:
- *   Curl::PostField.content(name, content) => #<Curl::PostField...>
- *   Curl::PostField.content(name, content, content_type = nil) => #<Curl::PostField...>
- *   Curl::PostField.content(name, content_type = nil) { |field| ... } => #<Curl::PostField...>
+ *   Curl::PostField.content(name, content) => #<Curl::PostField...>
+ *   Curl::PostField.content(name, content, content_type = nil) => #<Curl::PostField...>
+ *   Curl::PostField.content(name, content_type = nil) { |field| ... } => #<Curl::PostField...>
  * 
  * Create a new Curl::PostField, supplying the field name, content,
  * and, optionally, Content-type (curl will attempt to determine this if
@@ -208,7 +233,11 @@ void curl_postfield_free(ruby_curl_postfield *rbcpf) {
  * data.
  */
 static VALUE ruby_curl_postfield_new_content(int argc, VALUE *argv, VALUE klass) {
-  ruby_curl_postfield *rbcpf = ALLOC(ruby_curl_postfield);
+  VALUE self;
+  ruby_curl_postfield *rbcpf;
+
+  self = TypedData_Make_Struct(klass, ruby_curl_postfield, &ruby_curl_postfield_data_type, rbcpf);
+  MEMZERO(rbcpf, ruby_curl_postfield, 1);
  
   // wierdness - we actually require two args, unless a block is provided, but
   // we have to work that out below.
@@ -236,14 +265,14 @@ static VALUE ruby_curl_postfield_new_content(int argc, VALUE *argv, VALUE klass)
   rbcpf->remote_file = Qnil;
   rbcpf->buffer_str = Qnil;
  
-  return Data_Wrap_Struct(cCurlPostField, curl_postfield_mark, curl_postfield_free, rbcpf);
+  return self;
 }
 
 /*
  * call-seq:
- *   Curl::PostField.file(name, local_file_name) => #&lt;Curl::PostField...&gt;
- *   Curl::PostField.file(name, local_file_name, remote_file_name = local_file_name) => #&lt;Curl::PostField...&gt;
- *   Curl::PostField.file(name, remote_file_name) { |field| ... } => #&lt;Curl::PostField...&gt;
+ *   Curl::PostField.file(name, local_file_name) => #<Curl::PostField...>
+ *   Curl::PostField.file(name, local_file_name, remote_file_name = local_file_name) => #<Curl::PostField...>
+ *   Curl::PostField.file(name, remote_file_name) { |field| ... } => #<Curl::PostField...>
  * 
  * Create a new Curl::PostField for a file upload field, supplying the local filename
  * to read from, and optionally the remote filename (defaults to the local name).
@@ -254,7 +283,11 @@ static VALUE ruby_curl_postfield_new_content(int argc, VALUE *argv, VALUE klass)
  */
 static VALUE ruby_curl_postfield_new_file(int argc, VALUE *argv, VALUE klass) {
   // TODO needs to handle content-type too
-  ruby_curl_postfield *rbcpf = ALLOC(ruby_curl_postfield);
+  VALUE self;
+  ruby_curl_postfield *rbcpf;
+
+  self = TypedData_Make_Struct(klass, ruby_curl_postfield, &ruby_curl_postfield_data_type, rbcpf);
+  MEMZERO(rbcpf, ruby_curl_postfield, 1);
 
   rb_scan_args(argc, argv, "21&", &rbcpf->name, &rbcpf->local_file, &rbcpf->remote_file, &rbcpf->content_proc);
 
@@ -282,7 +315,7 @@ static VALUE ruby_curl_postfield_new_file(int argc, VALUE *argv, VALUE klass) {
   rbcpf->content_type = Qnil;
   rbcpf->buffer_str = Qnil;
  
-  return Data_Wrap_Struct(cCurlPostField, curl_postfield_mark, curl_postfield_free, rbcpf);
+  return self;
 }
 
 /* ================= ATTRIBUTES ====================*/
@@ -399,7 +432,7 @@ static VALUE ruby_curl_postfield_remote_file_get(VALUE self) {
 
 /*
  * call-seq:
- *   field.set_content_proc { |field| ... }           => &lt;old proc&gt;
+ *   field.set_content_proc { |field| ... }           => <old proc>
  * 
  * Set a content proc for this field. This proc will be called during the
  * perform to supply the content for this field, overriding any setting
@@ -421,71 +454,108 @@ static VALUE ruby_curl_postfield_content_proc_set(int argc, VALUE *argv, VALUE s
  * Only content fields may be converted to strings.
  */
 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);
+#ifdef HAVE_CURL_EASY_ESCAPE
+  CURL *curl_handle = NULL;
+#endif
+
+  TypedData_Get_Struct(self, ruby_curl_postfield, &ruby_curl_postfield_data_type, rbcpf);
 
-    if (rbcpf->name != Qnil) {
-      name = rbcpf->name;
-      if (rb_type(name) == T_STRING) {
-        name = rbcpf->name;
-      } else if (rb_respond_to(name,rb_intern("to_s"))) {
+  if (rbcpf->name != Qnil) {
+    name = rbcpf->name;
+    if (TYPE(name) != T_STRING) {
+      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__);
+      else
+        name = Qnil;
     }
+  }
+  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__);
+  }
+  /* Force field name to UTF-8 before escaping */
+  VALUE name_utf8 = rb_str_export_to_enc(name, rb_utf8_encoding());
 
-    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 (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 {
-        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);
-        
-        result = escd_name;
-        rb_str_cat(result, "=", 1);
-        rb_str_concat(result, escd_content); 
-      }
+#ifdef HAVE_CURL_EASY_ESCAPE
+  curl_handle = curl_easy_init();
+  if (!curl_handle) {
+    rb_raise(eCurlErrInvalidPostField, "Failed to initialize curl handle for escaping");
+  }
+  tmpchrs = curl_easy_escape(curl_handle, StringValuePtr(name_utf8), (int)RSTRING_LEN(name_utf8));
+  if (!tmpchrs) {
+    curl_easy_cleanup(curl_handle);
+    rb_raise(eCurlErrInvalidPostField, "Failed to url-encode name");
+  }
+#else
+  tmpchrs = curl_escape(StringValuePtr(name_utf8), (int)RSTRING_LEN(name_utf8));
+  if (!tmpchrs) {
+    rb_raise(eCurlErrInvalidPostField, "Failed to url-encode name");
+  }
+#endif
+
+  VALUE escd_name = rb_str_new2(tmpchrs);
+#ifdef HAVE_CURL_EASY_ESCAPE
+  curl_free(tmpchrs);
+#else
+  curl_free(tmpchrs);
+#endif
+
+  VALUE tmpcontent = Qnil;
+  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 {
+    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 {
+#ifdef HAVE_CURL_EASY_ESCAPE
+      curl_easy_cleanup(curl_handle);
+#endif
+      rb_raise(rb_eRuntimeError,
+               "postfield(%s) is not a string and does not respond_to to_s",
+               RSTRING_PTR(escd_name));
     }
-  
+  }
+  /* Force content to UTF-8 before escaping */
+  VALUE content_utf8 = rb_str_export_to_enc(tmpcontent, rb_utf8_encoding());
+#ifdef HAVE_CURL_EASY_ESCAPE
+  tmpchrs = curl_easy_escape(curl_handle, StringValuePtr(content_utf8), (int)RSTRING_LEN(content_utf8));
+  if (!tmpchrs) {
+    curl_easy_cleanup(curl_handle);
+    rb_raise(eCurlErrInvalidPostField, "Failed to url-encode content");
+  }
+#else
+  tmpchrs = curl_escape(StringValuePtr(content_utf8), (int)RSTRING_LEN(content_utf8));
+  if (!tmpchrs) {
+    rb_raise(eCurlErrInvalidPostField, "Failed to url-encode content");
+  }
+#endif
+
+  VALUE escd_content = rb_str_new2(tmpchrs);
+#ifdef HAVE_CURL_EASY_ESCAPE
+  curl_free(tmpchrs);
+  curl_easy_cleanup(curl_handle);
+#else
+  curl_free(tmpchrs);
+#endif
+
+  result = escd_name;
+  rb_str_cat(result, "=", 1);
+  rb_str_concat(result, escd_content);
+
   return result;
 }
 
@@ -498,6 +568,8 @@ void init_curb_postfield() {
   
   cCurlPostField = rb_define_class_under(mCurl, "PostField", rb_cObject);
 
+  rb_undef_alloc_func(cCurlPostField);
+
   /* Class methods */
   rb_define_singleton_method(cCurlPostField, "content", ruby_curl_postfield_new_content, -1);
   rb_define_singleton_method(cCurlPostField, "file", ruby_curl_postfield_new_file, -1);

data/ext/curb_postfield.h

@@ -30,6 +30,7 @@ typedef struct {
 } ruby_curl_postfield;
 
 extern VALUE cCurlPostField;
+extern const rb_data_type_t ruby_curl_postfield_data_type;
 
 void append_to_form(VALUE self, 
                     struct curl_httppost **first, 

data/ext/curb_upload.c

@@ -10,13 +10,36 @@ VALUE cCurlUpload;
   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_mark(void *ptr) {
+  ruby_curl_upload *rbcu = (ruby_curl_upload *)ptr;
+  if (rbcu && rbcu->stream && !NIL_P(rbcu->stream)) rb_gc_mark(rbcu->stream);
 }
-static void curl_upload_free(ruby_curl_upload *rbcu) {
-  free(rbcu);
+
+static void curl_upload_free(void *ptr) {
+  if (ptr) free(ptr);
+}
+
+static size_t curl_upload_memsize(const void *ptr) {
+  (void)ptr;
+  return sizeof(ruby_curl_upload);
 }
 
+const rb_data_type_t ruby_curl_upload_data_type = {
+  "Curl::Upload",
+  {
+    curl_upload_mark,
+    curl_upload_free,
+    curl_upload_memsize,
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    NULL, /* compact */
+#endif
+  },
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+  NULL, NULL, /* parent, data */
+  RUBY_TYPED_FREE_IMMEDIATELY
+#endif
+};
+
 /*
  * call-seq:
  *   internal class for sending large file uploads
@@ -24,9 +47,12 @@ static void curl_upload_free(ruby_curl_upload *rbcu) {
 VALUE ruby_curl_upload_new(VALUE klass) {
   VALUE upload;
   ruby_curl_upload *rbcu = ALLOC(ruby_curl_upload);
+  if (!rbcu) {
+    rb_raise(rb_eNoMemError, "Failed to allocate memory for Curl::Upload");
+  }
   rbcu->stream = Qnil;
   rbcu->offset = 0;
-  upload = Data_Wrap_Struct(klass, curl_upload_mark, curl_upload_free, rbcu);
+  upload = TypedData_Wrap_Struct(klass, &ruby_curl_upload_data_type, rbcu);
   return upload;
 }
 
@@ -36,7 +62,7 @@ VALUE ruby_curl_upload_new(VALUE klass) {
  */
 VALUE ruby_curl_upload_stream_set(VALUE self, VALUE stream) {
   ruby_curl_upload *rbcu;
-  Data_Get_Struct(self, ruby_curl_upload, rbcu);
+  TypedData_Get_Struct(self, ruby_curl_upload, &ruby_curl_upload_data_type, rbcu);
   rbcu->stream = stream;
   return stream;
 }
@@ -46,7 +72,7 @@ VALUE ruby_curl_upload_stream_set(VALUE self, VALUE stream) {
  */
 VALUE ruby_curl_upload_stream_get(VALUE self) {
   ruby_curl_upload *rbcu;
-  Data_Get_Struct(self, ruby_curl_upload, rbcu);
+  TypedData_Get_Struct(self, ruby_curl_upload, &ruby_curl_upload_data_type, rbcu);
   return rbcu->stream;
 }
 /*
@@ -55,8 +81,8 @@ VALUE ruby_curl_upload_stream_get(VALUE self) {
  */
 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);
+  TypedData_Get_Struct(self, ruby_curl_upload, &ruby_curl_upload_data_type, rbcu);
+  rbcu->offset = NUM2LONG(offset);
   return offset;
 }
 /*
@@ -65,13 +91,14 @@ VALUE ruby_curl_upload_offset_set(VALUE self, VALUE offset) {
  */
 VALUE ruby_curl_upload_offset_get(VALUE self) {
   ruby_curl_upload *rbcu;
-  Data_Get_Struct(self, ruby_curl_upload, rbcu);
-  return INT2FIX(rbcu->offset);
+  TypedData_Get_Struct(self, ruby_curl_upload, &ruby_curl_upload_data_type, rbcu);
+  return LONG2NUM(rbcu->offset);
 }
 
 /* =================== INIT LIB =====================*/
 void init_curb_upload() {
   cCurlUpload = rb_define_class_under(mCurl, "Upload", rb_cObject);
+  rb_undef_alloc_func(cCurlUpload);
   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);

data/ext/curb_upload.h

@@ -19,6 +19,8 @@ typedef struct {
 } ruby_curl_upload;
 
 extern VALUE cCurlUpload;
+extern const rb_data_type_t ruby_curl_upload_data_type;
+
 void init_curb_upload();
 
 VALUE ruby_curl_upload_new(VALUE klass);