curb 0.9.7 → 1.0.1

data/ext/curb_easy.h

@@ -36,6 +36,9 @@ typedef struct {
   /* The handler */
   CURL *curl;
 
+  /* Buffer for error details from CURLOPT_ERRORBUFFER */
+  char err_buf[CURL_ERROR_SIZE];
+
   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 */
 
@@ -55,6 +58,8 @@ typedef struct {
   unsigned long ftp_response_timeout;
   long low_speed_limit;
   long low_speed_time;
+  long max_send_speed_large;
+  long max_recv_speed_large;
   long ssl_version;
   long use_ssl;
   long ftp_filemethod;
@@ -76,6 +81,7 @@ typedef struct {
   char callback_active;
 
   struct curl_slist *curl_headers;
+  struct curl_slist *curl_proxy_headers;
   struct curl_slist *curl_ftp_commands;
   struct curl_slist *curl_resolve;
 

data/ext/curb_multi.c

@@ -37,6 +37,7 @@ static VALUE idCall;
 VALUE cCurlMulti;
 
 static long cCurlMutiDefaulttimeout = 100; /* milliseconds */
+static char cCurlMutiAutoClose = 0;
 
 static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy);
 static void rb_curl_multi_read_info(VALUE self, CURLM *mptr);
@@ -44,69 +45,41 @@ static void rb_curl_multi_run(VALUE self, CURLM *multi_handle, int *still_runnin
 
 static VALUE callback_exception(VALUE unused) {
   return Qfalse;
-} 
-
-static void curl_multi_mark(ruby_curl_multi *rbcm) {
-  if (!NIL_P(rbcm->requests)) rb_gc_mark(rbcm->requests);
-}
-
-/* Hash#foreach callback for curl_multi_free */
-static int curl_multi_flush_easy(VALUE key, VALUE easy, ruby_curl_multi *rbcm) {
-  CURLMcode result;
-  ruby_curl_easy *rbce;
-
-  // sometimes the type is T_ZOMBIE, e.g. after Ruby has received the SIGTERM signal
-  if (rb_type(easy) == T_DATA) {
-    Data_Get_Struct(easy, ruby_curl_easy, rbce);
-
-    result = curl_multi_remove_handle(rbcm->handle, rbce->curl);
-    if (result != 0) {
-      raise_curl_multi_error_exception(result);
-    }
-  }
-
-  return ST_DELETE;
 }
 
 void curl_multi_free(ruby_curl_multi *rbcm) {
-  VALUE hash = rbcm->requests;
-
-  if (!NIL_P(hash) && rb_type(hash) == T_HASH && RHASH_SIZE(hash) > 0) {
-
-    rb_hash_foreach(hash, curl_multi_flush_easy, (VALUE)rbcm);
-    /* rb_hash_clear(rbcm->requests); */
+  curl_multi_cleanup(rbcm->handle);
+  free(rbcm);
+}
 
-    rbcm->requests = Qnil;
+static void ruby_curl_multi_init(ruby_curl_multi *rbcm) {
+  rbcm->handle = curl_multi_init();
+  if (!rbcm->handle) {
+    rb_raise(mCurlErrFailedInit, "Failed to initialize multi handle");
   }
 
-  curl_multi_cleanup(rbcm->handle);
-  free(rbcm);
+  rbcm->active = 0;
+  rbcm->running = 0;
 }
 
 /*
  * call-seq:
- *   Curl::Multi.new                                   => #<Curl::Easy...>
+ *   Curl::Multi.new                                   => #<Curl::Easy...>
  *
  * Create a new Curl::Multi instance
  */
 VALUE ruby_curl_multi_new(VALUE klass) {
-  VALUE new_curlm;
-
   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();
-
-  rbcm->active = 0;
-  rbcm->running = 0;
+  ruby_curl_multi_init(rbcm);
 
-  new_curlm = Data_Wrap_Struct(klass, curl_multi_mark, curl_multi_free, rbcm);
-
-  return new_curlm;
+  /*
+   * The mark routine will be called by the garbage collector during its ``mark'' phase.
+   * If your structure references other Ruby objects, then your mark function needs to
+   * identify these objects using rb_gc_mark(value). If the structure doesn't reference
+   * other Ruby objects, you can simply pass 0 as a function pointer.
+  */
+  return Data_Wrap_Struct(klass, 0, curl_multi_free, rbcm);
 }
 
 /*
@@ -133,52 +106,36 @@ VALUE ruby_curl_multi_get_default_timeout(VALUE klass) {
   return LONG2NUM(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);
-  
-  return ST_CONTINUE;
+/*
+ * call-seq:
+ *   Curl::Multi.autoclose = true => true
+ *
+ * Automatically close open connections after each request. Otherwise, the connection will remain open 
+ * for reuse until the next GC
+ *
+ */
+VALUE ruby_curl_multi_set_autoclose(VALUE klass, VALUE onoff) {
+  cCurlMutiAutoClose = ((onoff == Qtrue) ? 1 : 0);
+  return onoff;
 }
 
 /*
  * call-seq:
- *   multi.requests                                   => [#&lt;Curl::Easy...&gt;, ...]
- * 
- * Returns an array containing all the active requests on this Curl::Multi object.
+ *   Curl::Multi.autoclose => true|false
+ *
+ * Get the global default autoclose setting for all Curl::Multi Handles.
+ *
  */
-static VALUE ruby_curl_multi_requests(VALUE self) {
-  ruby_curl_multi *rbcm;
-  VALUE result_array;
-
-  Data_Get_Struct(self, ruby_curl_multi, rbcm);
-  
-  result_array = rb_ary_new();
-  
-  /* iterate over the requests hash, and stuff references into the array. */
-  rb_hash_foreach(rbcm->requests, ruby_curl_multi_requests_callback, result_array);
-  
-  return result_array;
+VALUE ruby_curl_multi_get_autoclose(VALUE klass) {
+  return cCurlMutiAutoClose == 1 ? Qtrue : Qfalse;
 }
 
 /*
  * call-seq:
- *   multi.idle?                                      => true or false
+ *   multi.requests                                   => [#<Curl::Easy...>, ...]
  * 
- * Returns whether or not this Curl::Multi handle is processing any requests.  E.g. this returns
- * true when multi.requests.length == 0.
+ * Returns an array containing all the active requests on this Curl::Multi object.
  */
-static VALUE ruby_curl_multi_idle(VALUE self) {
-  ruby_curl_multi *rbcm;
-  
-  Data_Get_Struct(self, ruby_curl_multi, rbcm);
-  
-  if (RHASH_SIZE(rbcm->requests) == 0) {
-    return Qtrue;
-  } else {
-    return Qfalse;
-  }
-}
-
 /*
  * call-seq:
  * multi = Curl::Multi.new
@@ -241,19 +198,12 @@ static VALUE ruby_curl_multi_pipeline(VALUE self, VALUE method) {
  */
 VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
   CURLMcode mcode;
-  VALUE r;
   ruby_curl_easy *rbce;
   ruby_curl_multi *rbcm;
 
   Data_Get_Struct(self, ruby_curl_multi, rbcm);
   Data_Get_Struct(easy, ruby_curl_easy, rbce);
 
-  // check if this curl handle has been added before adding again
-  r = rb_hash_aref(rbcm->requests, LONG2NUM((long)rbce->curl));
-  if ( r != Qnil ) {
-    return Qnil;
-  }
-
   /* setup the easy handle */
   ruby_curl_easy_setup( rbce );
 
@@ -271,8 +221,6 @@ VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
   /* track a reference to associated multi handle */
   rbce->multi = self;
 
-  rb_hash_aset( rbcm->requests, LONG2NUM((long)rbce->curl), easy );
-
   return self;
 }
 
@@ -290,28 +238,20 @@ VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
  *
  * Will raise an exception if the easy handle is not found
  */
-VALUE ruby_curl_multi_remove(VALUE self, VALUE easy) {
+VALUE ruby_curl_multi_remove(VALUE self, VALUE rb_easy_handle) {
   ruby_curl_multi *rbcm;
 
   Data_Get_Struct(self, ruby_curl_multi, rbcm);
 
-  rb_curl_multi_remove(rbcm,easy);
+  rb_curl_multi_remove(rbcm, rb_easy_handle);
 
   return self;
 }
 static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy) {
   CURLMcode result;
   ruby_curl_easy *rbce;
-  VALUE r;
 
   Data_Get_Struct(easy, ruby_curl_easy, rbce);
-
-  // check if this curl handle has been added before removing
-  r = rb_hash_aref(rbcm->requests, LONG2NUM((long)rbce->curl));
-  if ( r == Qnil ) {
-    return;
-  }
-
   result = curl_multi_remove_handle(rbcm->handle, rbce->curl);
   if (result != 0) {
     raise_curl_multi_error_exception(result);
@@ -320,36 +260,6 @@ static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy) {
   rbcm->active--;
 
   ruby_curl_easy_cleanup( easy, rbce );
-
-  // active should equal LONG2NUM(RHASH(rbcm->requests)->tbl->num_entries)
-  r = rb_hash_delete( rbcm->requests, LONG2NUM((long)rbce->curl) );
-  if( r != easy || r == Qnil ) {
-    rb_warn("Possibly lost track of Curl::Easy VALUE, it may not be reclaimed by GC");
-  }
-}
-
-/* Hash#foreach callback for ruby_curl_multi_cancel */
-static int ruby_curl_multi_cancel_callback(VALUE key, VALUE value, ruby_curl_multi *rbcm) {
-  rb_curl_multi_remove(rbcm, value);
-  
-  return ST_CONTINUE;
-}
-
-/*
- * call-seq:
- *   multi.cancel!
- * 
- * Cancels all requests currently being made on this Curl::Multi handle.  
- */
-static VALUE ruby_curl_multi_cancel(VALUE self) {
-  ruby_curl_multi *rbcm;
-
-  Data_Get_Struct(self, ruby_curl_multi, rbcm);
-  
-  rb_hash_foreach( rbcm->requests, ruby_curl_multi_cancel_callback, (VALUE)rbcm );
-  
-  /* for chaining */
-  return self;
 }
 
 // on_success, on_failure, on_complete
@@ -361,7 +271,6 @@ static VALUE call_status_handler2(VALUE ary) {
 }
 
 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;
@@ -373,7 +282,8 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
 
   rbce->last_result = result; /* save the last easy result code */
 
-  ruby_curl_multi_remove( self, easy );
+  // remove the easy handle from multi on completion so it can be reused again
+  rb_funcall(self, rb_intern("remove"), 1, easy);
 
   /* after running a request cleanup the headers, these are set before each request */
   if (rbce->curl_headers) {
@@ -390,10 +300,14 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
     rbce->callback_active = 1;
     val = rb_rescue(call_status_handler1, callargs, callback_exception, Qnil);
     rbce->callback_active = 0;
-    //rb_funcall( rb_easy_get("complete_proc"), idCall, 1, easy );
   }
 
+#ifdef HAVE_CURLINFO_RESPONSE_CODE
   curl_easy_getinfo(rbce->curl, CURLINFO_RESPONSE_CODE, &response_code);
+#else
+  // old libcurl
+  curl_easy_getinfo(rbce->curl, CURLINFO_HTTP_CODE, &response_code);
+#endif
 
   if (result != 0) {
     if (!rb_easy_nil("failure_proc")) {
@@ -403,8 +317,7 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
       rbce->callback_active = 0;
       //rb_funcall( rb_easy_get("failure_proc"), idCall, 2, easy, rb_curl_easy_error(result) );
     }
-  }
-  else if (!rb_easy_nil("success_proc") &&
+  } 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 */
     callargs = rb_ary_new3(2, rb_easy_get("success_proc"), easy);
@@ -412,22 +325,19 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
     val = rb_rescue(call_status_handler1, callargs, callback_exception, Qnil);
     rbce->callback_active = 0;
     //rb_funcall( rb_easy_get("success_proc"), idCall, 1, easy );
-  }
-  else if (!rb_easy_nil("redirect_proc") &&
+  } else if (!rb_easy_nil("redirect_proc") &&
           (response_code >= 300 && response_code < 400)) {
     rbce->callback_active = 1;
     callargs = rb_ary_new3(3, rb_easy_get("redirect_proc"), easy, rb_curl_easy_error(result));
     rbce->callback_active = 0;
     val = rb_rescue(call_status_handler2, callargs, callback_exception, Qnil);
-  }
-  else if (!rb_easy_nil("missing_proc") &&
+  } else if (!rb_easy_nil("missing_proc") &&
           (response_code >= 400 && response_code < 500)) {
     rbce->callback_active = 1;
     callargs = rb_ary_new3(3, rb_easy_get("missing_proc"), easy, rb_curl_easy_error(result));
     rbce->callback_active = 0;
     val = rb_rescue(call_status_handler2, callargs, callback_exception, Qnil);
-  }
-  else if (!rb_easy_nil("failure_proc") &&
+  } else if (!rb_easy_nil("failure_proc") &&
           (response_code >= 500 && response_code <= 999)) {
     callargs = rb_ary_new3(3, rb_easy_get("failure_proc"), easy, rb_curl_easy_error(result));
     rbce->callback_active = 1;
@@ -439,19 +349,27 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
 }
 
 static void rb_curl_multi_read_info(VALUE self, CURLM *multi_handle) {
-  int msgs_left, result;
-  CURLMsg *msg;
-  CURL *easy_handle;
-
-  /* check for finished easy handles and remove from the multi handle */
-  while ((msg = curl_multi_info_read(multi_handle, &msgs_left))) {
-    if (msg->msg == CURLMSG_DONE) {
-      easy_handle = msg->easy_handle;
-      result = msg->data.result;
-      if (easy_handle) {
-        rb_curl_mutli_handle_complete(self, easy_handle, result);
-      }
-    }
+  int msgs_left;
+
+  CURLcode c_easy_result;
+  CURLMsg *c_multi_result; // for picking up messages with the transfer status
+  CURL *c_easy_handle;
+
+  /* Check for finished easy handles and remove from the multi handle.
+   * curl_multi_info_read will query for messages from individual handles.
+   *
+   * The messages fetched with this function are removed from the curl internal
+   * queue and when there are no messages left it will return NULL (and break
+   * the loop effectively).
+   */
+  while ((c_multi_result = curl_multi_info_read(multi_handle, &msgs_left))) {
+    // A message is there, but we really care only about transfer completetion.
+    if (c_multi_result->msg != CURLMSG_DONE) continue;
+
+    c_easy_handle = c_multi_result->easy_handle;
+    c_easy_result = c_multi_result->data.result; /* return code for transfer */
+
+    rb_curl_mutli_handle_complete(self, c_easy_handle, c_easy_result);
   }
 }
 
@@ -459,14 +377,32 @@ static void rb_curl_multi_read_info(VALUE self, CURLM *multi_handle) {
 static void rb_curl_multi_run(VALUE self, CURLM *multi_handle, int *still_running) {
   CURLMcode mcode;
 
+  /*
+   * curl_multi_perform will return CURLM_CALL_MULTI_PERFORM only when it wants to be called again immediately.
+   * When things are fine and there is nothing immediate it wants done, it'll return CURLM_OK.
+   *
+   * It will perform all pending actions on all added easy handles attached to this multi handle. We will loop
+   * here as long as mcode is CURLM_CALL_MULTIPERFORM.
+   */
   do {
     mcode = curl_multi_perform(multi_handle, still_running);
   } while (mcode == CURLM_CALL_MULTI_PERFORM);
 
+  /*
+   * Nothing more to do, check if an error occured in the loop above and raise an exception if necessary.
+   */
+
   if (mcode != CURLM_OK) {
     raise_curl_multi_error_exception(mcode);
   }
-  
+
+  /*
+   * Everything is ok, but this does not mean all the transfers are completed.
+   * There is no data to read or write available for Curl at the moment.
+   *
+   * At this point we can return control to the caller to do something else while
+   * curl is waiting for more actions to queue.
+   */
 }
 
 #ifdef _WIN32
@@ -537,6 +473,7 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
 #endif
   long timeout_milliseconds;
   struct timeval tv = {0, 0};
+  struct timeval tv_100ms = {0, 100000};
   VALUE block = Qnil;
 #if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
   struct _select_set fdset_args;
@@ -548,10 +485,23 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
 
   timeout_milliseconds = cCurlMutiDefaulttimeout;
 
+  // Run curl_multi_perform for the first time to get the ball rolling
   rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
+
+  // Check the easy handles for new messages one more time before yielding
+  // control to passed ruby block.
+  //
+  // This call will block until all queued messages are processed and if any
+  // handle completed the transfer we will run the on_complete callback here too.
   rb_curl_multi_read_info( self, rbcm->handle );
-  if (block != Qnil) { rb_funcall(block, rb_intern("call"), 1, self);  }
- 
+
+  // There are no more messages to handle by curl and we can run the ruby block
+  // passed to perform method.
+  // When the block completes curl will resume.
+  if (block != Qnil) {
+    rb_funcall(block, rb_intern("call"), 1, self);
+  }
+
   do {
     while (rbcm->running) {
 
@@ -593,7 +543,7 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
 
       if (maxfd == -1) {
         /* libcurl recommends sleeping for 100ms */
-        rb_thread_wait_for(rb_time_timeval(DBL2NUM(0.1)));
+        rb_thread_wait_for(tv_100ms);
         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);  }
@@ -606,12 +556,15 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
       create_crt_fd(&fdexcep, &crt_fdexcep);
 #endif
 
-#if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
+
+#if (defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL))
       fdset_args.maxfd = maxfd+1;
       fdset_args.fdread = &fdread;
       fdset_args.fdwrite = &fdwrite;
       fdset_args.fdexcep = &fdexcep;
       fdset_args.tv = &tv;
+#endif
+
 #ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL
       rc = (int)(VALUE) rb_thread_call_without_gvl((void *(*)(void *))curb_select, &fdset_args, RUBY_UBF_IO, 0);
 #elif HAVE_RB_THREAD_BLOCKING_REGION
@@ -622,8 +575,6 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
       rc = rb_thread_select(maxfd+1, &fdread, &fdwrite, &fdexcep, &tv);
 #endif
 
-#endif
-
 #ifdef _WIN32
       cleanup_crt_fd(&fdread, &crt_fdread);
       cleanup_crt_fd(&fdwrite, &crt_fdwrite);
@@ -649,30 +600,44 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
 
   rb_curl_multi_read_info( self, rbcm->handle );
   if (block != Qnil) { rb_funcall(block, rb_intern("call"), 1, self);  }
-    
+  if (cCurlMutiAutoClose  == 1) {
+    rb_funcall(self, rb_intern("close"), 0);
+  }
   return Qtrue;
 }
 
+/*
+ * call-seq:
+ *
+ * multi.close
+ * after closing the multi handle all connections will be closed and the handle will no longer be usable
+ *
+ */
+VALUE ruby_curl_multi_close(VALUE self) {
+  ruby_curl_multi *rbcm;
+  Data_Get_Struct(self, ruby_curl_multi, rbcm);
+  curl_multi_cleanup(rbcm->handle);
+  ruby_curl_multi_init(rbcm);
+  return self;
+}
+
+
 /* =================== INIT LIB =====================*/
 void init_curb_multi() {
   idCall = rb_intern("call");
-
   cCurlMulti = rb_define_class_under(mCurl, "Multi", rb_cObject);
 
   /* 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);
-  rb_define_method(cCurlMulti, "idle?", ruby_curl_multi_idle, 0);
-  
+  rb_define_singleton_method(cCurlMulti, "autoclose=", ruby_curl_multi_set_autoclose, 1);
+  rb_define_singleton_method(cCurlMulti, "autoclose", ruby_curl_multi_get_autoclose, 0);
   /* Instance methods */
   rb_define_method(cCurlMulti, "max_connects=", ruby_curl_multi_max_connects, 1);
   rb_define_method(cCurlMulti, "pipeline=", ruby_curl_multi_pipeline, 1);
-  rb_define_method(cCurlMulti, "add", ruby_curl_multi_add, 1);
-  rb_define_method(cCurlMulti, "remove", ruby_curl_multi_remove, 1);
-  rb_define_method(cCurlMulti, "cancel!", ruby_curl_multi_cancel, 0);
+  rb_define_method(cCurlMulti, "_add", ruby_curl_multi_add, 1);
+  rb_define_method(cCurlMulti, "_remove", ruby_curl_multi_remove, 1);
   rb_define_method(cCurlMulti, "perform", ruby_curl_multi_perform, -1);
+  rb_define_method(cCurlMulti, "_close", ruby_curl_multi_close, 0);
 }

data/ext/curb_multi.h

@@ -14,7 +14,6 @@
 typedef struct {
   int active;
   int running;
-  VALUE requests; /* hash of handles currently added */
   CURLM *handle;
 } ruby_curl_multi;
 

data/ext/curb_postfield.c

@@ -195,9 +195,9 @@ void curl_postfield_free(ruby_curl_postfield *rbcpf) {
 
 /*
  * 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
@@ -241,9 +241,9 @@ static VALUE ruby_curl_postfield_new_content(int argc, VALUE *argv, VALUE klass)
 
 /*
  * 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).
@@ -399,7 +399,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