ghazel-curb 0.6.2.3 → 0.7.9.1

data/ext/curb_easy.h

@@ -11,6 +11,24 @@
 
 #include <curl/easy.h>
 
+#ifdef CURL_VERSION_SSL
+#if LIBCURL_VERSION_NUM >= 0x070b00
+#  if LIBCURL_VERSION_NUM <= 0x071004
+#    define CURB_FTPSSL         CURLOPT_FTP_SSL
+#    define CURB_FTPSSL_ALL     CURLFTPSSL_ALL
+#    define CURB_FTPSSL_TRY     CURLFTPSSL_TRY
+#    define CURB_FTPSSL_CONTROL CURLFTPSSL_CONTROL
+#    define CURB_FTPSSL_NONE    CURLFTPSSL_NONE
+#  else
+#    define CURB_FTPSSL         CURLOPT_USE_SSL
+#    define CURB_FTPSSL_ALL     CURLUSESSL_ALL
+#    define CURB_FTPSSL_TRY     CURLUSESSL_TRY
+#    define CURB_FTPSSL_CONTROL CURLUSESSL_CONTROL
+#    define CURB_FTPSSL_NONE    CURLUSESSL_NONE
+#  endif
+#endif
+#endif
+
 /* a lot of this *could* be kept in the handler itself,
  * but then we lose the ability to query it's status.
  */
@@ -19,6 +37,7 @@ typedef struct {
   CURL *curl;
 
   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 */
 
   /* Other opts */
   unsigned short local_port;       // 0 is no port
@@ -32,6 +51,11 @@ typedef struct {
   unsigned long connect_timeout;
   long dns_cache_timeout;
   unsigned long ftp_response_timeout;
+  long low_speed_limit;
+  long low_speed_time;
+  long ssl_version;
+  long use_ssl;
+  long ftp_filemethod;
 
   /* bool flags */
   char proxy_tunnel;
@@ -45,7 +69,9 @@ typedef struct {
   char verbose;
   char multipart_form_post;
   char enable_cookies;
+  char ignore_content_length;
   struct curl_slist *curl_headers;
+  struct curl_slist *curl_ftp_commands;
 
   int last_result; /* last result code from multi loop */
 
@@ -53,8 +79,8 @@ typedef struct {
 
 extern VALUE cCurlEasy;
 
-VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce, struct curl_slist **headers);
-VALUE ruby_curl_easy_cleanup(VALUE self, ruby_curl_easy *rbce, struct curl_slist *headers);
+VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce);
+VALUE ruby_curl_easy_cleanup(VALUE self, ruby_curl_easy *rbce);
 
 void init_curb_easy();
 

data/ext/curb_errors.c

@@ -110,6 +110,7 @@ VALUE eCurlErrSSLCRLBadfile;
 VALUE eCurlErrSSLIssuerError;
 
 /* multi errors */
+VALUE mCurlErrFailedInit;
 VALUE mCurlErrCallMultiPerform;
 VALUE mCurlErrBadHandle;
 VALUE mCurlErrBadEasyHandle;
@@ -605,6 +606,7 @@ void init_curb_errors() {
   eCurlErrSSLShutdownFailed  = rb_define_class_under(mCurlErr, "SSLShutdownFailed", eCurlErrError);
   eCurlErrSSH                = rb_define_class_under(mCurlErr, "SSH", eCurlErrError);
 
+  mCurlErrFailedInit         = rb_define_class_under(mCurlErr, "MultiInitError", eCurlErrError);
   mCurlErrCallMultiPerform   = rb_define_class_under(mCurlErr, "MultiPerform", eCurlErrError);
   mCurlErrBadHandle          = rb_define_class_under(mCurlErr, "MultiBadHandle", eCurlErrError);
   mCurlErrBadEasyHandle      = rb_define_class_under(mCurlErr, "MultiBadEasyHandle", eCurlErrError);

data/ext/curb_errors.h

@@ -108,6 +108,7 @@ extern VALUE eCurlErrSSLCRLBadfile;
 extern VALUE eCurlErrSSLIssuerError;
 
 /* multi errors */
+extern VALUE mCurlErrFailedInit;
 extern VALUE mCurlErrCallMultiPerform;
 extern VALUE mCurlErrBadHandle;
 extern VALUE mCurlErrBadEasyHandle;

data/ext/curb_macros.h

@@ -12,7 +12,7 @@
 #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))
 #define rb_easy_del(key) rb_hash_delete(rbce->opts, rb_easy_hkey(key))
-#define rb_easy_nil(key) (rb_hash_lookup_187(rbce->opts, rb_easy_hkey(key)) == Qnil)
+#define rb_easy_nil(key) (rb_hash_aref(rbce->opts, rb_easy_hkey(key)) == Qnil)
 #define rb_easy_type_check(key,type) (rb_type(rb_hash_aref(rbce->opts, rb_easy_hkey(key))) == type)
 
 // TODO: rb_sym_to_s may not be defined?

data/ext/curb_multi.c

@@ -19,6 +19,11 @@
 
 #include <errno.h>
 
+#ifdef _WIN32
+  // for O_RDWR and O_BINARY
+  #include <fcntl.h>
+#endif
+
 extern VALUE mCurl;
 static VALUE idCall;
 
@@ -28,8 +33,11 @@ static VALUE idCall;
 
 VALUE cCurlMulti;
 
+static long cCurlMutiDefaulttimeout = 100; /* milliseconds */
+
 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);
@@ -81,6 +89,9 @@ VALUE ruby_curl_multi_new(VALUE klass) {
   ruby_curl_multi *rbcm = ALLOC(ruby_curl_multi);
 
   rbcm->handle = curl_multi_init();
+  if (!rbcm->handle) {
+    rb_raise(mCurlErrFailedInit, "Failed to initialize multi handle");
+  }
 
   rbcm->requests = rb_hash_new();
 
@@ -92,6 +103,30 @@ VALUE ruby_curl_multi_new(VALUE klass) {
   return new_curlm;
 }
 
+/*
+ * call-seq:
+ *   Curl::Multi.default_timeout = 4 => 4
+ *
+ * Set the global default time out for all Curl::Multi Handles.  This value is used
+ * when libcurl cannot determine a timeout value when calling curl_multi_timeout.
+ *
+ */
+VALUE ruby_curl_multi_set_default_timeout(VALUE klass, VALUE timeout) {
+  cCurlMutiDefaulttimeout = FIX2LONG(timeout);
+  return timeout;
+}
+
+/*
+ * call-seq:
+ *   Curl::Multi.default_timeout = 4 => 4
+ *
+ * Get the global default time out for all Curl::Multi Handles.
+ *
+ */
+VALUE ruby_curl_multi_get_default_timeout(VALUE klass) {
+  return INT2FIX(cCurlMutiDefaulttimeout);
+}
+
 /* Hash#foreach callback for ruby_curl_multi_requests */
 static int ruby_curl_multi_requests_callback(VALUE key, VALUE value, VALUE result_array) {
   rb_ary_push(result_array, value);
@@ -194,14 +229,14 @@ VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
   Data_Get_Struct(self, ruby_curl_multi, rbcm);
   Data_Get_Struct(easy, ruby_curl_easy, rbce);
 
+  /* setup the easy handle */
+  ruby_curl_easy_setup( rbce );
+
   mcode = curl_multi_add_handle(rbcm->handle, rbce->curl);
   if (mcode != CURLM_CALL_MULTI_PERFORM && mcode != CURLM_OK) {
     raise_curl_multi_error_exception(mcode);
   }
 
-  /* setup the easy handle */
-  ruby_curl_easy_setup( rbce, &(rbce->curl_headers) );
-
   rbcm->active++;
 
   /* Increase the running count, so that the perform loop keeps running.
@@ -210,6 +245,8 @@ 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;
 }
 
@@ -253,7 +290,7 @@ static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy) {
 
   rbcm->active--;
 
-  ruby_curl_easy_cleanup( easy, rbce, rbce->curl_headers );
+  ruby_curl_easy_cleanup( easy, rbce );
 
   // active should equal INT2FIX(RHASH(rbcm->requests)->tbl->num_entries)
   r = rb_hash_delete( rbcm->requests, easy );
@@ -296,14 +333,20 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
 
   Data_Get_Struct(easy, ruby_curl_easy, rbce);
 
-  if (ecode != 0) {
-    raise_curl_easy_error_exception(ecode);
-  }
-
   rbce->last_result = result; /* save the last easy result code */
 
   ruby_curl_multi_remove( self, easy );
 
+  /* after running a request cleanup the headers, these are set before each request */
+  if (rbce->curl_headers) {
+    curl_slist_free_all(rbce->curl_headers);
+    rbce->curl_headers = NULL;
+  }
+
+  if (ecode != 0) {
+    raise_curl_easy_error_exception(ecode);
+  }
+
   if (!rb_easy_nil("complete_proc")) {
     rb_funcall( rb_easy_get("complete_proc"), idCall, 1, easy );
   }
@@ -324,6 +367,7 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
           (response_code >= 300 && response_code <= 999)) {
     rb_funcall( rb_easy_get("failure_proc"), idCall, 2, easy, rb_curl_easy_error(result) );
   }
+
 }
 
 static void rb_curl_multi_read_info(VALUE self, CURLM *multi_handle) {
@@ -354,10 +398,38 @@ static void rb_curl_multi_run(VALUE self, CURLM *multi_handle, int *still_runnin
   if (mcode != CURLM_OK) {
     raise_curl_multi_error_exception(mcode);
   }
+  
+}
 
-  rb_curl_multi_read_info( self, multi_handle );
+#ifdef _WIN32
+void create_crt_fd(fd_set *os_set, fd_set *crt_set)
+{
+  int i;
+  crt_set->fd_count = os_set->fd_count;
+  for (i = 0; i < os_set->fd_count; i++) {
+    WSAPROTOCOL_INFO wsa_pi;
+    // dupicate the SOCKET
+    int r = WSADuplicateSocket(os_set->fd_array[i], GetCurrentProcessId(), &wsa_pi);
+    SOCKET s = WSASocket(wsa_pi.iAddressFamily, wsa_pi.iSocketType, wsa_pi.iProtocol, &wsa_pi, 0, 0);
+    // create the CRT fd so ruby can get back to the SOCKET
+    int fd = _open_osfhandle(s, O_RDWR|O_BINARY);
+    os_set->fd_array[i] = s;
+    crt_set->fd_array[i] = fd;
+  }
 }
 
+void cleanup_crt_fd(fd_set *os_set, fd_set *crt_set)
+{
+  int i;
+  for (i = 0; i < os_set->fd_count; i++) {
+    // cleanup the CRT fd
+    _close(crt_set->fd_array[i]);
+    // cleanup the duplicated SOCKET
+    closesocket(os_set->fd_array[i]);
+  }
+}
+#endif
+
 /*
  * call-seq:
  * multi = Curl::Multi.new
@@ -378,6 +450,9 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
   ruby_curl_multi *rbcm;
   int maxfd, rc;
   fd_set fdread, fdwrite, fdexcep;
+#ifdef _WIN32
+  fd_set crt_fdread, crt_fdwrite, crt_fdexcep;
+#endif
 
   long timeout_milliseconds;
   struct timeval tv = {0, 0};
@@ -387,66 +462,85 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
 
   Data_Get_Struct(self, ruby_curl_multi, rbcm);
 
-  rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
-
-  while(rbcm->running) {
-    FD_ZERO(&fdread);
-    FD_ZERO(&fdwrite);
-    FD_ZERO(&fdexcep);
+  timeout_milliseconds = cCurlMutiDefaulttimeout;
 
-    /* load the fd sets from the multi handle */
-    mcode = curl_multi_fdset(rbcm->handle, &fdread, &fdwrite, &fdexcep, &maxfd);
-    if (mcode != CURLM_OK) {
-      raise_curl_multi_error_exception(mcode);
-    }
+  rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
+ 
+  do {
+    while (rbcm->running) {
 
 #ifdef HAVE_CURL_MULTI_TIMEOUT
-    /* get the curl suggested time out */
-    mcode = curl_multi_timeout(rbcm->handle, &timeout_milliseconds);
-    if (mcode != CURLM_OK) {
-      raise_curl_multi_error_exception(mcode);
-    }
+      /* get the curl suggested time out */
+      mcode = curl_multi_timeout(rbcm->handle, &timeout_milliseconds);
+      if (mcode != CURLM_OK) {
+        raise_curl_multi_error_exception(mcode);
+      }
 #else
-    /* libcurl doesn't have a timeout method defined... make a wild guess */
-    timeout_milliseconds = -1;
+      /* libcurl doesn't have a timeout method defined, initialize to -1 we'll pick up the default later */
+      timeout_milliseconds = -1;
 #endif
-    //printf("libcurl says wait: %ld ms or %ld s\n", timeout_milliseconds, timeout_milliseconds/1000);
 
-    if (timeout_milliseconds == 0) { /* no delay */
-      rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
-      continue;
-    }
-    else if(timeout_milliseconds < 0) {
-      timeout_milliseconds = 500; /* wait half a second, libcurl doesn't know how long to wait */
-    }
-#ifdef __APPLE_CC__
-    if(timeout_milliseconds > 1000) {
-      timeout_milliseconds = 1000; /* apple libcurl sometimes reports huge timeouts... let's cap it */
-    }
-#endif
+      if (timeout_milliseconds == 0) { /* no delay */
+        rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
+        continue;
+      }
+      else if (timeout_milliseconds < 0) {
+        timeout_milliseconds = cCurlMutiDefaulttimeout; /* libcurl doesn't know how long to wait, use a default timeout */
+      }
 
-    tv.tv_sec = timeout_milliseconds / 1000; // convert milliseconds to seconds
-    tv.tv_usec = (timeout_milliseconds % 1000) * 1000; // get the remainder of milliseconds and convert to micro seconds
-
-    rc = rb_thread_select(maxfd+1, &fdread, &fdwrite, &fdexcep, &tv);
-    switch(rc) {
-    case -1:
-      rb_raise(rb_eRuntimeError, "select(): %s", strerror(errno));
-      break;
-    case 0:
-      if (block != Qnil) {
-        rb_funcall(block, rb_intern("call"), 1, self); 
+      if (timeout_milliseconds > cCurlMutiDefaulttimeout) {
+        timeout_milliseconds = cCurlMutiDefaulttimeout; /* buggy versions libcurl sometimes reports huge timeouts... let's cap it */
       }
-//      if (rb_block_given_p()) {
-//        rb_yield(self);
-//      }
-    default: 
-      rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
-      break;
-    }
 
-  }
+      tv.tv_sec  = 0; /* never wait longer than 1 second */
+      tv.tv_usec = (int)(timeout_milliseconds * 1000); /* XXX: int is the right type for OSX, what about linux? */
 
+      if (timeout_milliseconds == 0) { /* no delay */
+        rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
+        continue;
+      }
+
+      if (block != Qnil) { rb_funcall(block, rb_intern("call"), 1, self);  }
+
+      FD_ZERO(&fdread);
+      FD_ZERO(&fdwrite);
+      FD_ZERO(&fdexcep);
+      /* load the fd sets from the multi handle */
+      mcode = curl_multi_fdset(rbcm->handle, &fdread, &fdwrite, &fdexcep, &maxfd);
+      if (mcode != CURLM_OK) {
+        raise_curl_multi_error_exception(mcode);
+      }
+
+#ifdef _WIN32
+      create_crt_fd(&fdread, &crt_fdread);
+      create_crt_fd(&fdwrite, &crt_fdrwrite);
+      create_crt_fd(&fdexcep, &crt_fdexcep);
+#endif
+
+      rc = rb_thread_select(maxfd+1, &fdread, &fdwrite, &fdexcep, &tv);
+
+#ifdef _WIN32
+      cleanup_crt_fd(&fdread, &crt_fdread);
+      cleanup_crt_fd(&fdwrite, &crt_fdrwrite);
+      cleanup_crt_fd(&fdexcep, &crt_fdexcep);
+#endif
+
+      switch(rc) {
+      case -1:
+        rb_raise(rb_eRuntimeError, "select(): %s", strerror(errno));
+        break;
+      case 0:
+        rb_curl_multi_read_info( self, rbcm->handle );
+        if (block != Qnil) { rb_funcall(block, rb_intern("call"), 1, self);  }
+      default: 
+        rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
+        break;
+      }
+    }
+    rb_curl_multi_read_info( self, rbcm->handle );
+    if (block != Qnil) { rb_funcall(block, rb_intern("call"), 1, self);  }
+  } while( rbcm->running );
+    
   return Qtrue;
 }
 
@@ -458,6 +552,8 @@ void init_curb_multi() {
 
   /* Class methods */
   rb_define_singleton_method(cCurlMulti, "new", ruby_curl_multi_new, 0);
+  rb_define_singleton_method(cCurlMulti, "default_timeout=", ruby_curl_multi_set_default_timeout, 1);
+  rb_define_singleton_method(cCurlMulti, "default_timeout", ruby_curl_multi_get_default_timeout, 0);
   
   /* "Attributes" */
   rb_define_method(cCurlMulti, "requests", ruby_curl_multi_requests, 0);

data/ext/curb_postfield.c

@@ -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), 
@@ -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,55 +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) {
+      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__);
+    }
 
-      char *tmpchrs = curl_escape(RSTRING_PTR(rbcpf->name), RSTRING_LEN(rbcpf->name));
+    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 name `%s'", tmpchrs);
+        rb_raise(eCurlErrInvalidPostField, "Failed to url-encode content `%s'", tmpchrs);
       } else {
-        VALUE tmpcontent = Qnil;
-        VALUE escd_name = rb_str_new2(tmpchrs);
+        VALUE escd_content = 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("");
-        }
-        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), 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); 
-        }            
+        result = escd_name;
+        rb_str_cat(result, "=", 1);
+        rb_str_concat(result, escd_content); 
       }
-    } else {
-      rb_raise(eCurlErrInvalidPostField, "Cannot convert unnamed field to string %s:%d", __FILE__, __LINE__);
-    }      
-  } else {
-    rb_raise(eCurlErrInvalidPostField, "Cannot convert non-content field to string %s:%d", __FILE__, __LINE__);
-  }  
+    }
   
   return result;
 }

data/ext/curb_upload.c

@@ -11,7 +11,7 @@ VALUE cCurlUpload;
 #endif
 
 static void curl_upload_mark(ruby_curl_upload *rbcu) {
-  if (rbcu->stream) rb_gc_mark(rbcu->stream);
+  if (rbcu->stream && !NIL_P(rbcu->stream)) rb_gc_mark(rbcu->stream);
 }
 static void curl_upload_free(ruby_curl_upload *rbcu) {
   free(rbcu);
@@ -56,7 +56,7 @@ 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 = FIX2INT(offset);
+  rbcu->offset = FIX2LONG(offset);
   return offset;
 }
 /*

data/ext/extconf.rb

@@ -1,10 +1,9 @@
 require 'mkmf'
-puts $CFLAGS.inspect
 
 dir_config('curl')
 
 if find_executable('curl-config')
-  $CFLAGS << " #{`curl-config --cflags`.strip}"
+  $CFLAGS << " #{`curl-config --cflags`.strip} -g"
   if ENV['STATIC_BUILD']
     $LIBS << " #{`curl-config --static-libs`.strip}"
   else
@@ -114,10 +113,16 @@ 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"