Class: Curl::Easy
- Inherits:
-
Object
- Object
- Curl::Easy
- Defined in:
- lib/curl/easy.rb,
ext/curb_easy.c
Class Method Summary collapse
-
.download(url, filename = url.split(/\?/).first.split(/\//).last, &blk) ⇒ Object
call-seq: Curl::Easy.download(url, filename = url.split(/?/).first.split(///).last) { |curl| … } Stream the specified url (via perform) and save the data directly to the supplied filename (defaults to the last component of the URL path, which will usually be the filename most simple urls).
-
.Curl::Easy.error(code) ⇒ String
translate an internal libcurl error to ruby error class.
-
.http_delete(*args) {|c| ... } ⇒ Object
call-seq: Curl::Easy.http_delete(url) { |easy| … } => #<Curl::Easy…>.
-
.http_get(*args) {|c| ... } ⇒ Object
call-seq: Curl::Easy.http_get(url) { |easy| … } => #<Curl::Easy…>.
-
.http_head(*args) {|c| ... } ⇒ Object
call-seq: Curl::Easy.http_head(url) { |easy| … } => #<Curl::Easy…>.
-
.http_post(*args) {|c| ... } ⇒ Object
call-seq: 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.
-
.http_put(url, data) {|c| ... } ⇒ Object
call-seq: Curl::Easy.http_put(url, data) {|c| … }.
-
.new(*args) ⇒ Object
Create a new Curl::Easy instance, optionally supplying the URL.
-
.perform(*args) {|c| ... } ⇒ Object
call-seq: Curl::Easy.perform(url) { |easy| … } => #<Curl::Easy…>.
Instance Method Summary collapse
-
#autoreferer=(autoreferer) ⇒ Object
easy = Curl::Easy.new easy.autoreferer=true.
-
#body_str ⇒ Object
Return the response body from the previous call to
perform
. -
#cacert ⇒ String
Obtain the cacert file to use for this Curl::Easy instance.
-
#cacert=(string) ⇒ Object
Set a cacert bundle to use for this Curl::Easy instance.
-
#cert ⇒ String
Obtain the cert file to use for this Curl::Easy instance.
-
#cert=(string) ⇒ Object
Set a cert file to use for this Curl::Easy instance.
-
#cert_key ⇒ Object
Obtain the cert key file to use for this Curl::Easy instance.
-
#cert_key=(cert_key) ⇒ Object
Set a cert key to use for this Curl::Easy instance.
-
#certpassword=(string) ⇒ Object
Set a password used to open the specified cert.
-
#certtype ⇒ String
Obtain the cert type used for this Curl::Easy instance.
-
#certtype=(certtype) ⇒ Object
Set a cert type to use for this Curl::Easy instance.
-
#clone ⇒ Object
(also: #dup)
Clone this Curl::Easy instance, creating a new instance.
-
#close ⇒ nil
Close the Curl::Easy instance.
-
#connect_time ⇒ Float
Retrieve the time, in seconds, it took from the start until the connect to the remote host (or proxy) was completed.
-
#connect_timeout ⇒ Fixnum?
Obtain the maximum time in seconds that you allow the connection to the server to take.
-
#connect_timeout=(fixnum) ⇒ Fixnum?
Set the maximum time in seconds that you allow the connection to the server to take.
-
#content_type ⇒ nil
Retrieve the content-type of the downloaded object.
-
#cookiefile ⇒ String
Obtain the cookiefile file for this Curl::Easy instance.
-
#cookiefile=(value) ⇒ Object
call-seq: easy.cookiefile = string => string.
-
#cookiejar ⇒ String
Obtain the cookiejar file to use for this Curl::Easy instance.
-
#cookiejar=(value) ⇒ Object
call-seq: easy.cookiejar = string => string.
-
#cookies ⇒ Object
Obtain the cookies for this Curl::Easy instance.
-
#cookies=(value) ⇒ Object
call-seq: easy.cookies = “name1=content1; name2=content2;” => string.
-
#delete ⇒ Object
call-seq: easy.http_delete.
-
#delete=(onoff) ⇒ Object
call-seq: easy = Curl::Easy.new(“url”) do|c| c.delete = true end easy.perform.
-
#dns_cache_timeout ⇒ Fixnum?
Obtain the dns cache timeout in seconds.
-
#dns_cache_timeout=(fixnum) ⇒ Fixnum?
Set the dns cache timeout in seconds.
-
#download_speed ⇒ Float
Retrieve the average download speed that curl measured for the preceeding complete download.
-
#downloaded_bytes ⇒ Float
Retrieve the total amount of bytes that were downloaded in the preceeding transfer.
-
#downloaded_content_length ⇒ Float
Retrieve the content-length of the download.
-
#enable_cookies=(boolean) ⇒ Boolean
Configure whether the libcurl cookie engine is enabled for this Curl::Easy instance.
-
#enable_cookies? ⇒ Boolean
Determine whether the libcurl cookie engine is enabled for this Curl::Easy instance.
-
#encoding ⇒ String
Get the set encoding types.
-
#encoding=(string) ⇒ String
Set the accepted encoding types, curl will handle all of the decompression.
-
#escape("some text") ⇒ Object
Convert the given input string to a URL encoded string and return the result.
-
#fetch_file_time=(boolean) ⇒ Boolean
Configure whether this Curl instance will fetch remote file times, if available.
-
#fetch_file_time? ⇒ Boolean
Determine whether this Curl instance will fetch remote file times, if available.
-
#file_time ⇒ Fixnum
Retrieve the remote time of the retrieved document (in number of seconds since 1 jan 1970 in the GMT/UTC time zone).
-
#follow_location=(onoff) ⇒ Object
call-seq: easy.follow_location = boolean => boolean.
-
#follow_location? ⇒ Boolean
Determine whether this Curl instance will follow Location: headers in HTTP responses.
-
#ftp_commands ⇒ Object
call-seq easy.ftp_commands => array or nil.
-
#ftp_commands=(ftp_commands) ⇒ Object
Explicitly sets the list of commands to execute on the FTP server when calling perform.
-
#ftp_entry_path ⇒ nil
Retrieve the path of the entry path.
-
#ftp_filemethod(ftp_filemethod) ⇒ Object
call-seq easy.ftp_filemethod => fixnum.
-
#ftp_filemethod=(value) ⇒ Fixnum?
Controls how libcurl reaches files on the server.
-
#ftp_response_timeout ⇒ Fixnum?
Obtain the maximum time that libcurl will wait for FTP command responses.
-
#ftp_response_timeout=(fixnum) ⇒ Fixnum?
Set a timeout period (in seconds) on the amount of time that the server is allowed to take in order to generate a response message for a command before the session is considered hung.
-
#get ⇒ Object
call-seq: easy.http_get => true.
-
#Fixnum ⇒ Object
Iniital access to libcurl curl_easy_getinfo, remember getinfo doesn’t return the same values as setopt.
-
#head=(onoff) ⇒ Object
call-seq: easy = Curl::Easy.new(“url”) do|c| c.head = true end easy.perform.
-
#header_in_body=(boolean) ⇒ Boolean
Configure whether this Curl instance will return HTTP headers combined with body data.
-
#header_in_body? ⇒ Boolean
Determine whether this Curl instance will return HTTP headers combined with body data.
-
#header_size ⇒ Fixnum
Retrieve the total size of all the headers received in the preceeding transfer.
-
#header_str ⇒ Object
Return the response header from the previous call to
perform
. -
#headers ⇒ Hash, ...
Obtain the custom HTTP headers for following requests.
-
#headers=(headers) ⇒ Object
easy.headers = => “val” …, “Header” => “val” => val”, … easy.headers = [“Header: val” …, “Header: val”] => [“Header: val”, …].
-
#http(verb) ⇒ Object
Send an HTTP request with method set to verb, using the current options set for this Curl::Easy instance.
-
#http_auth_types ⇒ Fixnum?
Obtain the HTTP authentication types that may be used for the following
perform
calls. -
#http_auth_types=(*args) ⇒ Object
VALUE self, VALUE http_auth_types) {.
-
#http_connect_code ⇒ Fixnum
Retrieve the last received proxy response code to a CONNECT request.
-
#http_delete ⇒ Object
call-seq: easy.http_delete.
-
#http_get ⇒ Object
call-seq: easy.http_get => true.
-
#http_head ⇒ Object
call-seq: easy.http_head => true.
-
#http_post(*args) ⇒ Object
POST the specified formdata to the currently configured URL using the current options set for this Curl::Easy instance.
-
#http_put(data) ⇒ true
PUT the supplied data to the currently configured URL using the current options set for this Curl::Easy instance.
-
#ignore_content_length=(boolean) ⇒ Object
Configure whether this Curl::Easy instance should ignore the content length header.
-
#ignore_content_length? ⇒ Boolean
Determine whether this Curl::Easy instance ignores the content length header.
- #inspect ⇒ "#<Curl::Easy http://google.com/>"
-
#interface ⇒ String
Obtain the interface name that is used as the outgoing network interface.
-
#interface=(value) ⇒ Object
call-seq: easy.interface = string => string.
-
#last_effective_url ⇒ nil
Retrieve the last effective URL used by this instance.
- #last_result ⇒ 0
-
#local_port ⇒ Fixnum?
Obtain the local port that will be used for the following
perform
calls. -
#local_port=(fixnum) ⇒ Fixnum?
Set the local port that will be used for the following
perform
calls. -
#local_port_range ⇒ Fixnum?
Obtain the local port range that will be used for the following
perform
calls. -
#local_port_range=(fixnum) ⇒ Fixnum?
Set the local port range that will be used for the following
perform
calls. -
#low_speed_limit ⇒ Fixnum?
Obtain the minimum transfer speed over low_speedtime+ below which the transfer will be aborted.
-
#low_speed_limit=(fixnum) ⇒ Fixnum?
Set the transfer speed (in bytes per second) that the transfer should be below during
low_speed_time
seconds for the library to consider it too slow and abort. -
#low_speed_time ⇒ Fixnum?
Obtain the time that the transfer should be below
low_speed_limit
for the library to abort it. -
#low_speed_time=(fixnum) ⇒ Fixnum?
Set the time (in seconds) that the transfer should be below the
low_speed_limit
for the library to consider it too slow and abort. -
#max_redirects ⇒ Fixnum?
Obtain the maximum number of redirections to follow in the following
perform
calls. -
#max_redirects=(fixnum) ⇒ Fixnum?
Set the maximum number of redirections to follow in the following
perform
calls. - #multi ⇒ "#<Curl::Multi>"
- #multi= ⇒ "#<Curl::Multi>"
-
#multipart_form_post=(boolean) ⇒ Boolean
Configure whether this Curl instance uses multipart/formdata content type for HTTP POST requests.
-
#multipart_form_post? ⇒ Boolean
Determine whether this Curl instance uses multipart/formdata content type for HTTP POST requests.
-
#name_lookup_time ⇒ Float
Retrieve the time, in seconds, it took from the start until the name resolving was completed.
- #native_cert= ⇒ Object
-
#nosignal=(onoff) ⇒ Object
call-seq:.
-
#num_connects ⇒ Integer
Retrieve the number of new connections libcurl had to create to achieve the previous transfer (only the successful connects are counted).
-
#on_body {|body_data| ... } ⇒ Object
Assign or remove the
on_body
handler for this Curl::Easy instance. -
#on_complete {|easy| ... } ⇒ Object
Assign or remove the
on_complete
handler for this Curl::Easy instance. -
#on_debug {|type, data| ... } ⇒ Object
Assign or remove the
on_debug
handler for this Curl::Easy instance. -
#on_failure {|easy, code| ... } ⇒ Object
Assign or remove the
on_failure
handler for this Curl::Easy instance. -
#on_header {|header_data| ... } ⇒ Object
Assign or remove the
on_header
handler for this Curl::Easy instance. -
#on_missing {|easy, code| ... } ⇒ Object
Assign or remove the on_missing handler for this Curl::Easy instance.
-
#on_progress {|dl_total, dl_now, ul_total, ul_now| ... } ⇒ Object
Assign or remove the
on_progress
handler for this Curl::Easy instance. -
#on_redirect {|easy, code| ... } ⇒ Object
Assign or remove the on_redirect handler for this Curl::Easy instance.
-
#on_success {|easy| ... } ⇒ Object
Assign or remove the
on_success
handler for this Curl::Easy instance. -
#os_errno ⇒ Integer
Retrieve the errno variable from a connect failure (requires libcurl 7.12.2 or higher, otherwise 0 is always returned).
-
#password ⇒ String
Get the current password.
-
#password=(string) ⇒ String
Set the HTTP Authentication password.
-
#perform ⇒ Object
call-seq: easy.perform => true.
- #post ⇒ Object
-
#post_body ⇒ String?
Obtain the POST body used in this Curl::Easy instance.
-
#post_body=(post_body) ⇒ Object
Sets the POST body of this Curl::Easy instance.
-
#pre_transfer_time ⇒ Float
Retrieve the time, in seconds, it took from the start until the file transfer is just about to begin.
-
#primary_ip ⇒ nil
Retrieve the resolved IP of the most recent connection done with this curl handle.
-
#proxy_auth_types ⇒ Fixnum?
Obtain the proxy authentication types that may be used for the following
perform
calls. -
#proxy_auth_types=(fixnum) ⇒ Fixnum?
Set the proxy authentication types that may be used for the following
perform
calls. -
#proxy_port ⇒ Fixnum?
Obtain the proxy port that will be used for the following
perform
calls. -
#proxy_port=(fixnum) ⇒ Fixnum?
Set the proxy port that will be used for the following
perform
calls. -
#proxy_tunnel=(boolean) ⇒ Boolean
Configure whether this Curl instance will use proxy tunneling.
-
#proxy_tunnel? ⇒ Boolean
Determine whether this Curl instance will use proxy tunneling.
-
#proxy_type ⇒ Fixnum?
Obtain the proxy type that will be used for the following
perform
calls. -
#proxy_type=(fixnum) ⇒ Fixnum?
Set the proxy type that will be used for the following
perform
calls. -
#proxy_url ⇒ String
Obtain the HTTP Proxy URL that will be used by subsequent calls to
perform
. -
#proxy_url=(url) ⇒ Object
call-seq: easy.proxy_url = string => string.
-
#proxypwd ⇒ String
Obtain the username/password string that will be used for proxy connection during subsequent calls to
perform
. -
#proxypwd=(value) ⇒ Object
call-seq: easy.proxypwd = string => string.
- #put ⇒ Object
-
#put_data=(data) ⇒ Object
Points this Curl::Easy instance to data to be uploaded via PUT.
-
#redirect_count ⇒ Integer
Retrieve the total number of redirections that were actually followed.
-
#redirect_time ⇒ Float
Retrieve the total time, in seconds, it took for all redirection steps include name lookup, connect, pretransfer and transfer before final transaction was started.
-
#redirect_url ⇒ nil
Retrieve the URL a redirect would take you to if you would enable CURLOPT_FOLLOWLOCATION.
-
#request_size ⇒ Fixnum
Retrieve the total size of the issued requests.
-
#reset ⇒ Hash
Reset the Curl::Easy instance, clears out all settings.
-
#resolve_mode ⇒ Object
Determines what type of IP address this Curl::Easy instance resolves DNS names to.
-
#resolve_mode=(symbol) ⇒ Object
Configures what type of IP address this Curl::Easy instance resolves DNS names to.
-
#response_code ⇒ Fixnum
Retrieve the last received HTTP or FTP code.
-
#set(opt, val) ⇒ Object
call-seq: easy.set :sym|Fixnum, value.
-
#Fixnum ⇒ Object
Iniital access to libcurl curl_easy_setopt.
-
#ssl_verify_host ⇒ Numeric
Determine whether this Curl instance will verify that the server cert is for the server it is known as.
- #ssl_verify_host=(value) ⇒ Object
-
#ssl_verify_host? ⇒ Boolean
call-seq: easy.ssl_verify_host? => boolean.
-
#ssl_verify_host_integer=(ssl_verify_host) ⇒ Object
Configure whether this Curl instance will verify that the server cert is for the server it is known as.
-
#ssl_verify_peer=(boolean) ⇒ Boolean
Configure whether this Curl instance will verify the SSL peer certificate.
-
#ssl_verify_peer? ⇒ Boolean
Determine whether this Curl instance will verify the SSL peer certificate.
-
#ssl_verify_result ⇒ Integer
Retrieve the result of the certification verification that was requested (by setting
ssl_verify_peer?
totrue
). -
#ssl_version ⇒ Fixnum
Get the version of SSL/TLS that libcurl will attempt to use.
-
#ssl_version=(value) ⇒ Fixnum?
Sets the version of SSL/TLS that libcurl will attempt to use.
-
#start_transfer_time ⇒ Float
Retrieve the time, in seconds, it took from the start until the first byte is just about to be transferred.
-
#status ⇒ Object
call-seq: easy.status => String.
-
#sym2curl(opt) ⇒ Object
call-seq: easy.sym2curl :symbol => Fixnum.
-
#timeout ⇒ Fixnum?
Obtain the maximum time in seconds that you allow the libcurl transfer operation to take.
-
#timeout=(fixnum) ⇒ Fixnum?
Set the maximum time in seconds that you allow the libcurl transfer operation to take.
-
#total_time ⇒ Float
Retrieve the total time in seconds for the previous transfer, including name resolving, TCP connect etc.
-
#unescape("some%20text") ⇒ Object
Convert the given URL encoded input string to a “plain string” and return the result.
-
#unrestricted_auth=(boolean) ⇒ Boolean
Configure whether this Curl instance may use any HTTP authentication method available when necessary.
-
#unrestricted_auth? ⇒ Boolean
Determine whether this Curl instance may use any HTTP authentication method available when necessary.
-
#upload_speed ⇒ Float
Retrieve the average upload speed that curl measured for the preceeding complete upload.
-
#uploaded_bytes ⇒ Float
Retrieve the total amount of bytes that were uploaded in the preceeding transfer.
-
#uploaded_content_length ⇒ Float
Retrieve the content-length of the upload.
-
#url ⇒ String
Obtain the URL that will be used by subsequent calls to
perform
. - #url=(u) ⇒ Object
-
#use_netrc=(boolean) ⇒ Boolean
Configure whether this Curl instance will use data from the user’s .netrc file for FTP connections.
-
#use_netrc? ⇒ Boolean
Determine whether this Curl instance will use data from the user’s .netrc file for FTP connections.
-
#use_ssl ⇒ Fixnum
Get the desired level for using SSL on FTP connections.
-
#use_ssl=(value) ⇒ Fixnum?
Ensure libcurl uses SSL for FTP connections.
-
#useragent ⇒ "Ruby/Curb"
Obtain the user agent string used for this Curl::Easy instance.
-
#useragent=(useragent) ⇒ Object
Set the user agent string for this Curl::Easy instance.
-
#username ⇒ String
Get the current username.
-
#username=(string) ⇒ String
Set the HTTP Authentication username.
-
#userpwd ⇒ String
Obtain the username/password string that will be used for subsequent calls to
perform
. -
#userpwd=(value) ⇒ Object
call-seq: easy.userpwd = string => string.
-
#verbose=(boolean) ⇒ Boolean
Configure whether this Curl instance gives verbose output to STDERR during transfers.
-
#verbose? ⇒ Boolean
Determine whether this Curl instance gives verbose output to STDERR during transfers.
-
#version=(http_version) ⇒ Object
call-seq:.
Class Method Details
.download(url, filename = url.split(/\?/).first.split(/\//).last, &blk) ⇒ Object
call-seq:
Curl::Easy.download(url, filename = url.split(/\?/).first.split(/\//).last) { |curl| ... }
Stream the specified url (via perform) and save the data directly to the supplied filename (defaults to the last component of the URL path, which will usually be the filename most simple urls).
If a block is supplied, it will be passed the curl instance prior to the perform call.
Note that the semantics of the on_body handler are subtly changed when using download, to account for the automatic routing of data to the specified file: The data string is passed to the handler before it is written to the file, allowing the handler to perform mutative operations where necessary. As usual, the transfer will be aborted if the on_body handler 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.
425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 |
# File 'lib/curl/easy.rb', line 425 def download(url, filename = url.split(/\?/).first.split(/\//).last, &blk) curl = Curl::Easy.new(url, &blk) output = if filename.is_a? IO filename.binmode if filename.respond_to?(:binmode) filename else File.open(filename, 'wb') end begin old_on_body = curl.on_body do |data| result = old_on_body ? old_on_body.call(data) : data.length output << data if result == data.length result end curl.perform ensure output.close rescue IOError end return curl end |
.Curl::Easy.error(code) ⇒ String
translate an internal libcurl error to ruby error class
3226 3227 3228 |
# File 'ext/curb_easy.c', line 3226
static VALUE ruby_curl_easy_error_message(VALUE klass, VALUE code) {
return rb_curl_easy_error(FIX2INT(code));
}
|
.http_delete(*args) {|c| ... } ⇒ Object
call-seq:
Curl::Easy.http_delete(url) { |easy| ... } => #<Curl::Easy...>
Convenience method that creates a new Curl::Easy instance with the specified URL and calls http_delete
, before returning the new instance.
If a block is supplied, the new instance will be yielded just prior to the http_delete
call.
400 401 402 403 404 405 |
# File 'lib/curl/easy.rb', line 400 def http_delete(*args) c = Curl::Easy.new *args yield c if block_given? c.http_delete c end |
.http_get(*args) {|c| ... } ⇒ Object
call-seq:
Curl::Easy.http_get(url) { |easy| ... } => #<Curl::Easy...>
Convenience method that creates a new Curl::Easy instance with the specified URL and calls http_get
, before returning the new instance.
If a block is supplied, the new instance will be yielded just prior to the http_get
call.
329 330 331 332 333 334 |
# File 'lib/curl/easy.rb', line 329 def http_get(*args) c = Curl::Easy.new *args yield c if block_given? c.http_get c end |
.http_head(*args) {|c| ... } ⇒ Object
call-seq:
Curl::Easy.http_head(url) { |easy| ... } => #<Curl::Easy...>
Convenience method that creates a new Curl::Easy instance with the specified URL and calls http_head
, before returning the new instance.
If a block is supplied, the new instance will be yielded just prior to the http_head
call.
346 347 348 349 350 351 |
# File 'lib/curl/easy.rb', line 346 def http_head(*args) c = Curl::Easy.new *args yield c if block_given? c.http_head c end |
.http_post(*args) {|c| ... } ⇒ Object
call-seq:
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 always returns true, or raises an exception (defined under Curl::Err) on error.
If you wish to use multipart form encoding, you’ll need to supply a block in order to set multipart_form_post true. See #http_post for more information.
382 383 384 385 386 387 388 |
# File 'lib/curl/easy.rb', line 382 def http_post(*args) url = args.shift c = Curl::Easy.new url yield c if block_given? c.http_post *args c end |
.http_put(url, data) {|c| ... } ⇒ Object
call-seq:
Curl::Easy.http_put(url, data) {|c| ... }
see easy.http_put
359 360 361 362 363 364 |
# File 'lib/curl/easy.rb', line 359 def http_put(url, data) c = Curl::Easy.new url yield c if block_given? c.http_put data c end |
.Curl::Easy.new ⇒ #<Curl::Easy...> .Curl::Easy.new(url = nil) ⇒ #<Curl::Easy...> .Curl::Easy.new(url = nil) {|self| ... } ⇒ #<Curl::Easy...>
Create a new Curl::Easy instance, optionally supplying the URL. The block form allows further configuration to be supplied before the instance is returned.
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 |
# File 'ext/curb_easy.c', line 275
static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
CURLcode ecode;
VALUE url, blk;
VALUE new_curl;
ruby_curl_easy *rbce;
rb_scan_args(argc, argv, "01&", &url, &blk);
rbce = ALLOC(ruby_curl_easy);
/* handler */
rbce->curl = curl_easy_init();
if (!rbce->curl) {
rb_raise(eCurlErrFailedInit, "Failed to initialize easy handle");
}
new_curl = Data_Wrap_Struct(klass, curl_easy_mark, curl_easy_free, rbce);
rbce->multi = Qnil;
rbce->opts = Qnil;
ruby_curl_easy_zero(rbce);
rb_easy_set("url", url);
/* set the new_curl pointer to the curl handle */
ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)new_curl);
if (ecode != CURLE_OK) {
raise_curl_easy_error_exception(ecode);
}
if (blk != Qnil) {
rb_funcall(blk, idCall, 1, new_curl);
}
return new_curl;
}
|
.perform(*args) {|c| ... } ⇒ Object
call-seq:
Curl::Easy.perform(url) { |easy| ... } => #<Curl::Easy...>
Convenience method that creates a new Curl::Easy instance with the specified URL and calls the general perform
method, before returning the new instance. For HTTP URLs, this is equivalent to calling http_get
.
If a block is supplied, the new instance will be yielded just prior to the http_get
call.
312 313 314 315 316 317 |
# File 'lib/curl/easy.rb', line 312 def perform(*args) c = Curl::Easy.new *args yield c if block_given? c.perform c end |
Instance Method Details
#autoreferer=(autoreferer) ⇒ Object
easy = Curl::Easy.new easy.autoreferer=true
1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 |
# File 'ext/curb_easy.c', line 1487
static VALUE ruby_curl_easy_autoreferer_set(VALUE self, VALUE autoreferer) {
ruby_curl_easy *rbce;
Data_Get_Struct(self, ruby_curl_easy, rbce);
if (Qtrue == autoreferer) {
curl_easy_setopt(rbce->curl, CURLOPT_AUTOREFERER, 1);
}
else {
curl_easy_setopt(rbce->curl, CURLOPT_AUTOREFERER, 0);
}
return autoreferer;
}
|
#body_str ⇒ Object
Return the response body from the previous call to perform
. This is populated by the default on_body
handler - if you supply your own body handler, this string will be empty.
2393 2394 2395 |
# File 'ext/curb_easy.c', line 2393 static VALUE ruby_curl_easy_body_str_get(VALUE self) { CURB_OBJECT_HGETTER(ruby_curl_easy, body_data); } |
#cacert ⇒ String
Obtain the cacert file to use for this Curl::Easy instance.
606 607 608 |
# File 'ext/curb_easy.c', line 606 static VALUE ruby_curl_easy_cacert_get(VALUE self) { CURB_OBJECT_HGETTER(ruby_curl_easy, cacert); } |
#cacert=(string) ⇒ Object
Set a cacert bundle to use for this Curl::Easy instance. This file will be used to validate SSL certificates.
596 597 598 |
# File 'ext/curb_easy.c', line 596
static VALUE ruby_curl_easy_cacert_set(VALUE self, VALUE cacert) {
CURB_OBJECT_HSETTER(ruby_curl_easy, cacert);
}
|
#cert ⇒ String
Obtain the cert file to use for this Curl::Easy instance.
562 563 564 |
# File 'ext/curb_easy.c', line 562 static VALUE ruby_curl_easy_cert_get(VALUE self) { CURB_OBJECT_HGETTER(ruby_curl_easy, cert); } |
#cert=(string) ⇒ Object
Set a cert file to use for this Curl::Easy instance. This file will be used to validate SSL connections.
552 553 554 555 556 557 558 559 560 561 |
# File 'ext/curb_easy.c', line 552 def cert=(cert_file) pos = cert_file.rindex(':') if pos && pos > 1 self.native_cert= cert_file[0..pos-1] self.certpassword= cert_file[pos+1..-1] else self.native_cert= cert_file end self.cert end |
#cert_key ⇒ Object
Obtain the cert key file to use for this Curl::Easy instance.
584 585 586 |
# File 'ext/curb_easy.c', line 584 static VALUE ruby_curl_easy_cert_key_get(VALUE self) { CURB_OBJECT_HGETTER(ruby_curl_easy, cert_key); } |
#cert_key=(cert_key) ⇒ Object
Set a cert key to use for this Curl::Easy instance. This file will be used to validate SSL certificates.
574 575 576 |
# File 'ext/curb_easy.c', line 574
static VALUE ruby_curl_easy_cert_key_set(VALUE self, VALUE cert_key) {
CURB_OBJECT_HSETTER(ruby_curl_easy, cert_key);
}
|
#certpassword=(string) ⇒ Object
Set a password used to open the specified cert
616 617 618 |
# File 'ext/curb_easy.c', line 616
static VALUE ruby_curl_easy_certpassword_set(VALUE self, VALUE certpassword) {
CURB_OBJECT_HSETTER(ruby_curl_easy, certpassword);
}
|
#certtype ⇒ String
Obtain the cert type used for this Curl::Easy instance
638 639 640 |
# File 'ext/curb_easy.c', line 638 static VALUE ruby_curl_easy_certtype_get(VALUE self) { CURB_OBJECT_HGETTER(ruby_curl_easy, certtype); } |
#certtype=(certtype) ⇒ Object
Set a cert type to use for this Curl::Easy instance. Default is PEM
628 629 630 |
# File 'ext/curb_easy.c', line 628
static VALUE ruby_curl_easy_certtype_set(VALUE self, VALUE certtype) {
CURB_OBJECT_HSETTER(ruby_curl_easy, certtype);
}
|
#clone ⇒ Object #dup ⇒ Object Also known as: dup
Clone this Curl::Easy instance, creating a new instance. This method duplicates the underlying CURL* handle.
321 322 323 324 325 326 327 328 329 330 331 332 333 |
# File 'ext/curb_easy.c', line 321
static VALUE ruby_curl_easy_clone(VALUE self) {
ruby_curl_easy *rbce, *newrbce;
Data_Get_Struct(self, ruby_curl_easy, rbce);
newrbce = ALLOC(ruby_curl_easy);
memcpy(newrbce, rbce, sizeof(ruby_curl_easy));
newrbce->curl = curl_easy_duphandle(rbce->curl);
newrbce->curl_headers = NULL;
newrbce->curl_ftp_commands = NULL;
return Data_Wrap_Struct(cCurlEasy, curl_easy_mark, curl_easy_free, newrbce);
}
|
#close ⇒ nil
Close the Curl::Easy instance. Any open connections are closed The easy handle is reinitialized. If a previous multi handle was open it is set to nil and will be cleared after a GC.
343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 |
# File 'ext/curb_easy.c', line 343
static VALUE ruby_curl_easy_close(VALUE self) {
CURLcode ecode;
ruby_curl_easy *rbce;
Data_Get_Struct(self, ruby_curl_easy, rbce);
if (rbce->callback_active) {
rb_raise(rb_eRuntimeError, "Cannot close an active curl handle within a callback");
}
ruby_curl_easy_free(rbce);
/* reinit the handle */
rbce->curl = curl_easy_init();
if (!rbce->curl) {
rb_raise(eCurlErrFailedInit, "Failed to initialize easy handle");
}
rbce->multi = Qnil;
ruby_curl_easy_zero(rbce);
/* give the new curl handle a reference back to the ruby object */
ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)self);
if (ecode != CURLE_OK) {
raise_curl_easy_error_exception(ecode);
}
return Qnil;
}
|
#connect_time ⇒ Float
Retrieve the time, in seconds, it took from the start until the connect to the remote host (or proxy) was completed.
2571 2572 2573 2574 2575 2576 2577 2578 2579 |
# File 'ext/curb_easy.c', line 2571
static VALUE ruby_curl_easy_connect_time_get(VALUE self) {
ruby_curl_easy *rbce;
double time;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_CONNECT_TIME, &time);
return rb_float_new(time);
}
|
#connect_timeout ⇒ Fixnum?
Obtain the maximum time in seconds that you allow the connection to the server to take.
1116 1117 1118 |
# File 'ext/curb_easy.c', line 1116
static VALUE ruby_curl_easy_connect_timeout_get(VALUE self, VALUE connect_timeout) {
CURB_IMMED_GETTER(ruby_curl_easy, connect_timeout, 0);
}
|
#connect_timeout=(fixnum) ⇒ Fixnum?
Set the maximum time in seconds that you allow the connection to the server to take. This only limits the connection phase, once it has connected, this option is of no more use.
Set to nil (or zero) to disable connection timeout (it will then only timeout on the system’s internal timeouts).
1105 1106 1107 |
# File 'ext/curb_easy.c', line 1105
static VALUE ruby_curl_easy_connect_timeout_set(VALUE self, VALUE connect_timeout) {
CURB_IMMED_SETTER(ruby_curl_easy, connect_timeout, 0);
}
|
#content_type ⇒ nil
Retrieve the content-type of the downloaded object. This is the value read from the Content-Type: field. If you get nil
, it means that the server didn’t send a valid Content-Type header or that the protocol used doesn’t support this.
2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 |
# File 'ext/curb_easy.c', line 2868
static VALUE ruby_curl_easy_content_type_get(VALUE self) {
ruby_curl_easy *rbce;
char* type;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_CONTENT_TYPE, &type);
if (type && type[0]) { // curl returns empty string if none
return rb_str_new2(type);
} else {
return Qnil;
}
}
|
#cookiefile ⇒ String
Obtain the cookiefile file for this Curl::Easy instance.
530 531 532 |
# File 'ext/curb_easy.c', line 530 static VALUE (VALUE self) { CURB_OBJECT_HGETTER(ruby_curl_easy, ); } |
#cookiefile=(value) ⇒ Object
call-seq:
easy. = string => string
Set a file that contains cookies to be sent in subsequent requests by this Curl::Easy instance.
Note that you must set enable_cookies true to enable the cookie engine, or this option will be ignored.
215 216 217 |
# File 'lib/curl/easy.rb', line 215 def (value) set :cookiefile, value end |
#cookiejar ⇒ String
Obtain the cookiejar file to use for this Curl::Easy instance.
540 541 542 |
# File 'ext/curb_easy.c', line 540 static VALUE (VALUE self) { CURB_OBJECT_HGETTER(ruby_curl_easy, ); } |
#cookiejar=(value) ⇒ Object
call-seq:
easy. = string => string
Set a cookiejar file to use for this Curl::Easy instance. Cookies from the response will be written into this file.
Note that you must set enable_cookies true to enable the cookie engine, or this option will be ignored.
229 230 231 |
# File 'lib/curl/easy.rb', line 229 def (value) set :cookiejar, value end |
#cookies ⇒ Object
Obtain the cookies for this Curl::Easy instance.
520 521 522 |
# File 'ext/curb_easy.c', line 520 static VALUE (VALUE self) { CURB_OBJECT_HGETTER(ruby_curl_easy, ); } |
#cookies=(value) ⇒ Object
call-seq:
easy. = "name1=content1; name2=content2;" => string
Set cookies to be sent by this Curl::Easy instance. The format of the string should be NAME=CONTENTS, where NAME is the cookie name and CONTENTS is what the cookie should contain. Set multiple cookies in one string like this: “name1=content1; name2=content2;” etc.
202 203 204 |
# File 'lib/curl/easy.rb', line 202 def (value) set :cookie, value end |
#delete ⇒ Object
call-seq:
easy.http_delete
DELETE the currently configured URL using the current options set for this Curl::Easy instance. This method always returns true, or raises an exception (defined under Curl::Err) on error.
297 298 299 |
# File 'lib/curl/easy.rb', line 297 def http_delete self.http :DELETE end |
#delete=(onoff) ⇒ Object
83 84 85 86 |
# File 'lib/curl/easy.rb', line 83 def delete=(onoff) set :customrequest, onoff ? 'delete' : nil onoff end |
#dns_cache_timeout ⇒ Fixnum?
Obtain the dns cache timeout in seconds.
1139 1140 1141 |
# File 'ext/curb_easy.c', line 1139
static VALUE ruby_curl_easy_dns_cache_timeout_get(VALUE self, VALUE dns_cache_timeout) {
CURB_IMMED_GETTER(ruby_curl_easy, dns_cache_timeout, -1);
}
|
#dns_cache_timeout=(fixnum) ⇒ Fixnum?
Set the dns cache timeout in seconds. Name resolves will be kept in memory for this number of seconds. Set to zero (0) to completely disable caching, or set to nil (or -1) to make the cached entries remain forever. By default, libcurl caches this info for 60 seconds.
1129 1130 1131 |
# File 'ext/curb_easy.c', line 1129
static VALUE ruby_curl_easy_dns_cache_timeout_set(VALUE self, VALUE dns_cache_timeout) {
CURB_IMMED_SETTER(ruby_curl_easy, dns_cache_timeout, -1);
}
|
#download_speed ⇒ Float
Retrieve the average download speed that curl measured for the preceeding complete download.
2756 2757 2758 2759 2760 2761 2762 2763 2764 |
# File 'ext/curb_easy.c', line 2756
static VALUE ruby_curl_easy_download_speed_get(VALUE self) {
ruby_curl_easy *rbce;
double bytes;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_SPEED_DOWNLOAD, &bytes);
return rb_float_new(bytes);
}
|
#downloaded_bytes ⇒ Float
Retrieve the total amount of bytes that were downloaded in the preceeding transfer.
2722 2723 2724 2725 2726 2727 2728 2729 2730 |
# File 'ext/curb_easy.c', line 2722
static VALUE ruby_curl_easy_downloaded_bytes_get(VALUE self) {
ruby_curl_easy *rbce;
double bytes;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_SIZE_DOWNLOAD, &bytes);
return rb_float_new(bytes);
}
|
#downloaded_content_length ⇒ Float
Retrieve the content-length of the download. This is the value read from the Content-Length: field.
2833 2834 2835 2836 2837 2838 2839 2840 2841 |
# File 'ext/curb_easy.c', line 2833
static VALUE ruby_curl_easy_downloaded_content_length_get(VALUE self) {
ruby_curl_easy *rbce;
double bytes;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &bytes);
return rb_float_new(bytes);
}
|
#enable_cookies=(boolean) ⇒ Boolean
Configure whether the libcurl cookie engine is enabled for this Curl::Easy instance.
1592 1593 1594 1595 |
# File 'ext/curb_easy.c', line 1592
static VALUE ruby_curl_easy_enable_cookies_set(VALUE self, VALUE enable_cookies)
{
CURB_BOOLEAN_SETTER(ruby_curl_easy, enable_cookies);
}
|
#enable_cookies? ⇒ Boolean
Determine whether the libcurl cookie engine is enabled for this Curl::Easy instance.
1604 1605 1606 |
# File 'ext/curb_easy.c', line 1604 static VALUE (VALUE self) { CURB_BOOLEAN_GETTER(ruby_curl_easy, ); } |
#encoding ⇒ String
Get the set encoding types
659 660 661 |
# File 'ext/curb_easy.c', line 659 static VALUE ruby_curl_easy_encoding_get(VALUE self) { CURB_OBJECT_HGETTER(ruby_curl_easy, encoding); } |
#encoding=(string) ⇒ String
Set the accepted encoding types, curl will handle all of the decompression
649 650 651 |
# File 'ext/curb_easy.c', line 649
static VALUE ruby_curl_easy_encoding_set(VALUE self, VALUE encoding) {
CURB_OBJECT_HSETTER(ruby_curl_easy, encoding);
}
|
#escape("some text") ⇒ Object
Convert the given input string to a URL encoded string and return the result. All input characters that are not a-z, A-Z or 0-9 are converted to their “URL escaped” version (%NN where NN is a two-digit hexadecimal number).
3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 |
# File 'ext/curb_easy.c', line 3165
static VALUE ruby_curl_easy_escape(VALUE self, VALUE svalue) {
ruby_curl_easy *rbce;
char *result;
VALUE rresult;
VALUE str = svalue;
Data_Get_Struct(self, ruby_curl_easy, rbce);
/* NOTE: make sure the value is a string, if not call to_s */
if( rb_type(str) != T_STRING ) { str = rb_funcall(str,rb_intern("to_s"),0); }
#if (LIBCURL_VERSION_NUM >= 0x070f04)
result = (char*)curl_easy_escape(rbce->curl, StringValuePtr(str), (int)RSTRING_LEN(str));
#else
result = (char*)curl_escape(StringValuePtr(str), (int)RSTRING_LEN(str));
#endif
rresult = rb_str_new2(result);
curl_free(result);
return rresult;
}
|
#fetch_file_time=(boolean) ⇒ Boolean
Configure whether this Curl instance will fetch remote file times, if available.
1364 1365 1366 |
# File 'ext/curb_easy.c', line 1364
static VALUE ruby_curl_easy_fetch_file_time_set(VALUE self, VALUE fetch_file_time) {
CURB_BOOLEAN_SETTER(ruby_curl_easy, fetch_file_time);
}
|
#fetch_file_time? ⇒ Boolean
Determine whether this Curl instance will fetch remote file times, if available.
1375 1376 1377 |
# File 'ext/curb_easy.c', line 1375 static VALUE ruby_curl_easy_fetch_file_time_q(VALUE self) { CURB_BOOLEAN_GETTER(ruby_curl_easy, fetch_file_time); } |
#file_time ⇒ Fixnum
Retrieve the remote time of the retrieved document (in number of seconds since 1 jan 1970 in the GMT/UTC time zone). If you get -1, it can be because of many reasons (unknown, the server hides it or the server doesn’t support the command that tells document time etc) and the time of the document is unknown.
Note that you must tell the server to collect this information before the transfer is made, by setting fetch_file_time?
to true, or you will unconditionally get a -1 back.
This requires libcurl 7.5 or higher - otherwise -1 is unconditionally returned.
2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 |
# File 'ext/curb_easy.c', line 2515
static VALUE ruby_curl_easy_file_time_get(VALUE self) {
#ifdef HAVE_CURLINFO_FILETIME
ruby_curl_easy *rbce;
long time;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_FILETIME, &time);
return LONG2NUM(time);
#else
rb_warn("Installed libcurl is too old to support file_time");
return INT2FIX(0);
#endif
}
|
#follow_location=(onoff) ⇒ Object
call-seq:
easy.follow_location = boolean => boolean
Configure whether this Curl instance will follow Location: headers in HTTP responses. Redirects will only be followed to the extent specified by max_redirects
.
252 253 254 |
# File 'lib/curl/easy.rb', line 252 def follow_location=(onoff) set :followlocation, onoff end |
#follow_location? ⇒ Boolean
Determine whether this Curl instance will follow Location: headers in HTTP responses.
1508 1509 1510 |
# File 'ext/curb_easy.c', line 1508 static VALUE ruby_curl_easy_follow_location_q(VALUE self) { CURB_BOOLEAN_GETTER(ruby_curl_easy, follow_location); } |
#ftp_commands ⇒ Object
call-seq
easy.ftp_commands => array or nil
842 843 844 |
# File 'ext/curb_easy.c', line 842 static VALUE ruby_curl_easy_ftp_commands_get(VALUE self) { CURB_OBJECT_HGETTER(ruby_curl_easy, ftp_commands); } |
#ftp_commands=(ftp_commands) ⇒ Object
Explicitly sets the list of commands to execute on the FTP server when calling perform
834 835 836 |
# File 'ext/curb_easy.c', line 834
static VALUE ruby_curl_easy_ftp_commands_set(VALUE self, VALUE ftp_commands) {
CURB_OBJECT_HSETTER(ruby_curl_easy, ftp_commands);
}
|
#ftp_entry_path ⇒ nil
Retrieve the path of the entry path. That is the initial path libcurl ended up in when logging on to the remote FTP server. This returns nil
if something is wrong.
(requires libcurl 7.15.4 or higher, otherwise nil
is always returned).
2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 |
# File 'ext/curb_easy.c', line 2980
static VALUE ruby_curl_easy_ftp_entry_path_get(VALUE self) {
#ifdef HAVE_CURLINFO_FTP_ENTRY_PATH
ruby_curl_easy *rbce;
char* path = NULL;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_FTP_ENTRY_PATH, &path);
if (path && path[0]) { // curl returns NULL or empty string if none
return rb_str_new2(path);
} else {
return Qnil;
}
#else
rb_warn("Installed libcurl is too old to support num_connects");
return Qnil;
#endif
}
|
#ftp_filemethod(ftp_filemethod) ⇒ Object
call-seq
easy.ftp_filemethod => fixnum
Get the configuration for how libcurl will reach files on the server.
1331 1332 1333 |
# File 'ext/curb_easy.c', line 1331
static VALUE ruby_curl_easy_ftp_filemethod_get(VALUE self, VALUE ftp_filemethod) {
CURB_IMMED_GETTER(ruby_curl_easy, ftp_filemethod, -1);
}
|
#ftp_filemethod=(value) ⇒ Fixnum?
Controls how libcurl reaches files on the server. Valid options are Curl::CURL_MULTICWD, Curl::CURL_NOCWD, and Curl::CURL_SINGLECWD (see libcurl docs for CURLOPT_FTP_METHOD).
1321 1322 1323 |
# File 'ext/curb_easy.c', line 1321
static VALUE ruby_curl_easy_ftp_filemethod_set(VALUE self, VALUE ftp_filemethod) {
CURB_IMMED_SETTER(ruby_curl_easy, ftp_filemethod, -1);
}
|
#ftp_response_timeout ⇒ Fixnum?
Obtain the maximum time that libcurl will wait for FTP command responses.
1166 1167 1168 |
# File 'ext/curb_easy.c', line 1166
static VALUE ruby_curl_easy_ftp_response_timeout_get(VALUE self, VALUE ftp_response_timeout) {
CURB_IMMED_GETTER(ruby_curl_easy, ftp_response_timeout, 0);
}
|
#ftp_response_timeout=(fixnum) ⇒ Fixnum?
Set a timeout period (in seconds) on the amount of time that the server is allowed to take in order to generate a response message for a command before the session is considered hung. While curl is waiting for a response, this value overrides timeout
. It is recommended that if used in conjunction with timeout
, you set ftp_response_timeout
to a value smaller than timeout
.
Ignored if libcurl version is < 7.10.8.
1156 1157 1158 |
# File 'ext/curb_easy.c', line 1156
static VALUE ruby_curl_easy_ftp_response_timeout_set(VALUE self, VALUE ftp_response_timeout) {
CURB_IMMED_SETTER(ruby_curl_easy, ftp_response_timeout, 0);
}
|
#get ⇒ Object
call-seq:
easy.http_get => true
GET the currently configured URL using the current options set for this Curl::Easy instance. This method always returns true, or raises an exception (defined under Curl::Err) on error.
284 285 286 287 |
# File 'lib/curl/easy.rb', line 284 def http_get set :httpget, true http :GET end |
#Fixnum ⇒ Object
Iniital access to libcurl curl_easy_getinfo, remember getinfo doesn’t return the same values as setopt
3128 3129 3130 |
# File 'ext/curb_easy.c', line 3128
static VALUE ruby_curl_easy_get_opt(VALUE self, VALUE opt) {
return Qnil;
}
|
#head=(onoff) ⇒ Object
240 241 242 |
# File 'lib/curl/easy.rb', line 240 def head=(onoff) set :nobody, onoff end |
#header_in_body=(boolean) ⇒ Boolean
Configure whether this Curl instance will return HTTP headers combined with body data. If this option is set true, both header and body data will go to body_str
(or the configured on_body
handler).
1444 1445 1446 |
# File 'ext/curb_easy.c', line 1444
static VALUE ruby_curl_easy_header_in_body_set(VALUE self, VALUE header_in_body) {
CURB_BOOLEAN_SETTER(ruby_curl_easy, header_in_body);
}
|
#header_in_body? ⇒ Boolean
Determine whether this Curl instance will return HTTP headers combined with body data.
1455 1456 1457 |
# File 'ext/curb_easy.c', line 1455 static VALUE ruby_curl_easy_header_in_body_q(VALUE self) { CURB_BOOLEAN_GETTER(ruby_curl_easy, header_in_body); } |
#header_size ⇒ Fixnum
Retrieve the total size of all the headers received in the preceeding transfer.
2773 2774 2775 2776 2777 2778 2779 2780 2781 |
# File 'ext/curb_easy.c', line 2773
static VALUE ruby_curl_easy_header_size_get(VALUE self) {
ruby_curl_easy *rbce;
long size;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_HEADER_SIZE, &size);
return LONG2NUM(size);
}
|
#header_str ⇒ Object
Return the response header from the previous call to perform
. This is populated by the default on_header
handler - if you supply your own header handler, this string will be empty.
2405 2406 2407 |
# File 'ext/curb_easy.c', line 2405 static VALUE ruby_curl_easy_header_str_get(VALUE self) { CURB_OBJECT_HGETTER(ruby_curl_easy, header_data); } |
#headers ⇒ Hash, ...
Obtain the custom HTTP headers for following requests.
471 472 473 474 475 476 477 478 |
# File 'ext/curb_easy.c', line 471
static VALUE ruby_curl_easy_headers_get(VALUE self) {
ruby_curl_easy *rbce;
VALUE headers;
Data_Get_Struct(self, ruby_curl_easy, rbce);
headers = rb_easy_get("headers");//rb_hash_aref(rbce->opts, rb_intern("headers"));
if (headers == Qnil) { headers = rb_easy_set("headers", rb_hash_new()); }
return headers;
}
|
#headers=(headers) ⇒ Object
easy.headers = => “val” …, “Header” => “val” => val”, …
easy.headers = ["Header: val" ..., "Header: val"] => ["Header: val", ...]
Set custom HTTP headers for following requests. This can be used to add custom headers, or override standard headers used by libcurl. It defaults to a Hash.
For example to set a standard or custom header:
easy.headers["MyHeader"] = "myval"
To remove a standard header (this is useful when removing libcurls default ‘Expect: 100-Continue’ header when using HTTP form posts):
easy.headers["Expect"] = ''
Anything passed to libcurl as a header will be converted to a string during the perform step.
461 462 463 |
# File 'ext/curb_easy.c', line 461
static VALUE ruby_curl_easy_headers_set(VALUE self, VALUE headers) {
CURB_OBJECT_HSETTER(ruby_curl_easy, headers);
}
|
#http(verb) ⇒ Object
Send an HTTP request with method set to verb, using the current options set for this Curl::Easy instance. This method always returns true or raises an exception (defined under Curl::Err) on error.
2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 |
# File 'ext/curb_easy.c', line 2256
static VALUE ruby_curl_easy_perform_verb(VALUE self, VALUE verb) {
VALUE str_verb;
if (rb_type(verb) == T_STRING) {
return ruby_curl_easy_perform_verb_str(self, StringValueCStr(verb));
}
else if (rb_respond_to(verb,rb_intern("to_s"))) {
str_verb = rb_funcall(verb, rb_intern("to_s"), 0);
return ruby_curl_easy_perform_verb_str(self, StringValueCStr(str_verb));
}
else {
rb_raise(rb_eRuntimeError, "Invalid HTTP VERB, must response to 'to_s'");
}
}
|
#http_auth_types ⇒ Fixnum?
Obtain the HTTP authentication types that may be used for the following perform
calls.
1014 1015 1016 |
# File 'ext/curb_easy.c', line 1014 static VALUE ruby_curl_easy_http_auth_types_get(VALUE self) { CURB_IMMED_GETTER(ruby_curl_easy, http_auth_types, 0); } |
#http_auth_types=(*args) ⇒ Object
VALUE self, VALUE http_auth_types) {
974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 |
# File 'ext/curb_easy.c', line 974
static VALUE ruby_curl_easy_http_auth_types_set(int argc, VALUE *argv, VALUE self) {//VALUE self, VALUE http_auth_types) {
ruby_curl_easy *rbce;
VALUE args_ary;
int i, len;
char* node = NULL;
long mask = 0x000000;
rb_scan_args(argc, argv, "*", &args_ary);
Data_Get_Struct(self, ruby_curl_easy, rbce);
len = (int)RARRAY_LEN(args_ary);
if (len == 1 && (TYPE(rb_ary_entry(args_ary,0)) == T_FIXNUM || rb_ary_entry(args_ary,0) == Qnil)) {
if (rb_ary_entry(args_ary,0) == Qnil) {
rbce->http_auth_types = 0;
}
else {
rbce->http_auth_types = NUM2INT(rb_ary_entry(args_ary,0));
}
}
else {
// we could have multiple values, but they should be symbols
node = RSTRING_PTR(rb_funcall(rb_ary_entry(args_ary,0),rb_intern("to_s"),0));
mask = CURL_HTTPAUTH_STR_TO_NUM(node);
for( i = 1; i < len; ++i ) {
node = RSTRING_PTR(rb_funcall(rb_ary_entry(args_ary,i),rb_intern("to_s"),0));
mask |= CURL_HTTPAUTH_STR_TO_NUM(node);
}
rbce->http_auth_types = mask;
}
return INT2NUM(rbce->http_auth_types);
}
|
#http_connect_code ⇒ Fixnum
Retrieve the last received proxy response code to a CONNECT request.
2488 2489 2490 2491 2492 2493 2494 2495 2496 |
# File 'ext/curb_easy.c', line 2488
static VALUE ruby_curl_easy_http_connect_code_get(VALUE self) {
ruby_curl_easy *rbce;
long code;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_HTTP_CONNECTCODE, &code);
return LONG2NUM(code);
}
|
#http_delete ⇒ Object
call-seq:
easy.http_delete
DELETE the currently configured URL using the current options set for this Curl::Easy instance. This method always returns true, or raises an exception (defined under Curl::Err) on error.
294 295 296 |
# File 'lib/curl/easy.rb', line 294 def http_delete self.http :DELETE end |
#http_get ⇒ Object
call-seq:
easy.http_get => true
GET the currently configured URL using the current options set for this Curl::Easy instance. This method always returns true, or raises an exception (defined under Curl::Err) on error.
280 281 282 283 |
# File 'lib/curl/easy.rb', line 280 def http_get set :httpget, true http :GET end |
#http_head ⇒ Object
call-seq:
easy.http_head => true
Request headers from the currently configured URL using the HEAD method and current options set for this Curl::Easy instance. This method always returns true, or raises an exception (defined under Curl::Err) on error.
265 266 267 268 269 270 |
# File 'lib/curl/easy.rb', line 265 def http_head set :nobody, true ret = self.perform set :nobody, false ret end |
#http_post("url = encoded%20form%20data;and=so%20on") ⇒ true #http_post("url = encoded%20form%20data", "and = so%20on", ...) ⇒ true #http_post("url = encoded%20form%20data", Curl: :PostField, "and = so%20on", ...) ⇒ true #http_post(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 always returns true, or raises an exception (defined under Curl::Err) on error.
The Content-type of the POST is determined by the current setting of multipart_form_post? , according to the following rules:
-
When false (the default): the form will be POSTed with a content-type of ‘application/x-www-form-urlencoded’, and any of the four calling forms may be used.
-
When true: the form will be POSTed with a content-type of ‘multipart/formdata’. Only the last calling form may be used, i.e. only PostField instances may be POSTed. In this mode, individual fields’ content-types are recognised, and file upload fields are supported.
2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 |
# File 'ext/curb_easy.c', line 2294
static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
ruby_curl_easy *rbce;
CURL *curl;
int i;
VALUE args_ary;
rb_scan_args(argc, argv, "*", &args_ary);
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl = rbce->curl;
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, NULL);
if (rbce->multipart_form_post) {
VALUE ret;
struct curl_httppost *first = NULL, *last = NULL;
// Make the multipart form
for (i = 0; i < argc; i++) {
if (rb_obj_is_instance_of(argv[i], cCurlPostField)) {
append_to_form(argv[i], &first, &last);
} else if (rb_type(argv[i]) == T_ARRAY) {
// see: https://github.com/rvanlieshout/curb/commit/8bcdefddc0162484681ebd1a92d52a642666a445
int c = 0, argv_len = (int)RARRAY_LEN(argv[i]);
for (; c < argv_len; ++c) {
if (rb_obj_is_instance_of(rb_ary_entry(argv[i],c), cCurlPostField)) {
append_to_form(rb_ary_entry(argv[i],c), &first, &last);
} else {
rb_raise(eCurlErrInvalidPostField, "You must use PostFields only with multipart form posts");
return Qnil;
}
}
} else {
rb_raise(eCurlErrInvalidPostField, "You must use PostFields only with multipart form posts");
return Qnil;
}
}
curl_easy_setopt(curl, CURLOPT_POST, 0);
curl_easy_setopt(curl, CURLOPT_HTTPPOST, first);
ret = rb_funcall(self, rb_intern("perform"), 0);
curl_formfree(first);
return ret;
} else {
VALUE post_body = Qnil;
/* TODO: check for PostField.file and raise error before to_s fails */
if ((post_body = rb_funcall(args_ary, idJoin, 1, rbstrAmp)) == Qnil) {
rb_raise(eCurlErrError, "Failed to join arguments");
return Qnil;
} else {
/* if the function call above returns an empty string because no additional arguments were passed this makes sure
a previously set easy.post_body = "arg=foo&bar=bin" will be honored */
if( post_body != Qnil && rb_type(post_body) == T_STRING && RSTRING_LEN(post_body) > 0 ) {
ruby_curl_easy_post_body_set(self, post_body);
}
/* if post body is not defined, set it so we enable POST header, even though the request body is empty */
if( rb_easy_nil("postdata_buffer") ) {
ruby_curl_easy_post_body_set(self, post_body);
}
return rb_funcall(self, rb_intern("perform"), 0);
}
}
}
|
#http_put(data) ⇒ true
PUT the supplied data to the currently configured URL using the current options set for this Curl::Easy instance. This method always returns true, or raises an exception (defined under Curl::Err) on error.
2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 |
# File 'ext/curb_easy.c', line 2369
static VALUE ruby_curl_easy_perform_put(VALUE self, VALUE data) {
ruby_curl_easy *rbce;
CURL *curl;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl = rbce->curl;
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, NULL);
ruby_curl_easy_put_data_set(self, data);
return rb_funcall(self, rb_intern("perform"), 0);
}
|
#ignore_content_length=(boolean) ⇒ Object
Configure whether this Curl::Easy instance should ignore the content length header.
1615 1616 1617 1618 |
# File 'ext/curb_easy.c', line 1615
static VALUE ruby_curl_easy_ignore_content_length_set(VALUE self, VALUE ignore_content_length)
{
CURB_BOOLEAN_SETTER(ruby_curl_easy, ignore_content_length);
}
|
#ignore_content_length? ⇒ Boolean
Determine whether this Curl::Easy instance ignores the content length header.
1627 1628 1629 |
# File 'ext/curb_easy.c', line 1627 static VALUE ruby_curl_easy_ignore_content_length_q(VALUE self) { CURB_BOOLEAN_GETTER(ruby_curl_easy, ignore_content_length); } |
#inspect ⇒ "#<Curl::Easy http://google.com/>"
3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 |
# File 'ext/curb_easy.c', line 3136
static VALUE ruby_curl_easy_inspect(VALUE self) {
char buf[64];
ruby_curl_easy *rbce;
Data_Get_Struct(self, ruby_curl_easy, rbce);
/* if we don't have a url set... we'll crash... */
if( !rb_easy_nil("url") && rb_easy_type_check("url", T_STRING)) {
VALUE url = rb_easy_get("url");
size_t len = 13+((RSTRING_LEN(url) > 50) ? 50 : RSTRING_LEN(url));
/* "#<Net::HTTP http://www.google.com/:80 open=false>" */
memcpy(buf,"#<Curl::Easy ", 13);
memcpy(buf+13,StringValueCStr(url), (len - 13));
buf[len++] = '>';
return rb_str_new(buf,len);
}
return rb_str_new2("#<Curl::Easy>");
}
|
#interface ⇒ String
Obtain the interface name that is used as the outgoing network interface. The name can be an interface name, an IP address or a host name.
487 488 489 |
# File 'ext/curb_easy.c', line 487 static VALUE ruby_curl_easy_interface_get(VALUE self) { CURB_OBJECT_HGETTER(ruby_curl_easy, interface_hm); } |
#interface=(value) ⇒ Object
call-seq:
easy.interface = string => string
Set the interface name to use as the outgoing network interface. The name can be an interface name, an IP address or a host name.
167 168 169 |
# File 'lib/curl/easy.rb', line 167 def interface=(value) set :interface, value end |
#last_effective_url ⇒ nil
Retrieve the last effective URL used by this instance. This is the URL used in the last perform
call, and may differ from the value of easy.url.
2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 |
# File 'ext/curb_easy.c', line 2420
static VALUE ruby_curl_easy_last_effective_url_get(VALUE self) {
ruby_curl_easy *rbce;
char* url;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_EFFECTIVE_URL, &url);
if (url && url[0]) { // curl returns empty string if none
return rb_str_new2(url);
} else {
return Qnil;
}
}
|
#last_result ⇒ 0
3024 3025 3026 3027 3028 |
# File 'ext/curb_easy.c', line 3024
static VALUE ruby_curl_easy_last_result(VALUE self) {
ruby_curl_easy *rbce;
Data_Get_Struct(self, ruby_curl_easy, rbce);
return INT2FIX(rbce->last_result);
}
|
#local_port ⇒ Fixnum?
Obtain the local port that will be used for the following perform
calls.
This option is ignored if compiled against libcurl < 7.15.2.
871 872 873 |
# File 'ext/curb_easy.c', line 871 static VALUE ruby_curl_easy_local_port_get(VALUE self) { CURB_IMMED_PORT_GETTER(ruby_curl_easy, local_port); } |
#local_port=(fixnum) ⇒ Fixnum?
Set the local port that will be used for the following perform
calls.
Passing nil
will return to the default behaviour (no local port preference).
This option is ignored if compiled against libcurl < 7.15.2.
859 860 861 |
# File 'ext/curb_easy.c', line 859
static VALUE ruby_curl_easy_local_port_set(VALUE self, VALUE local_port) {
CURB_IMMED_PORT_SETTER(ruby_curl_easy, local_port, "port");
}
|
#local_port_range ⇒ Fixnum?
Obtain the local port range that will be used for the following perform
calls.
This option is ignored if compiled against libcurl < 7.15.2.
902 903 904 |
# File 'ext/curb_easy.c', line 902 static VALUE ruby_curl_easy_local_port_range_get(VALUE self) { CURB_IMMED_PORT_GETTER(ruby_curl_easy, local_port_range); } |
#local_port_range=(fixnum) ⇒ Fixnum?
Set the local port range that will be used for the following perform
calls. This is a number (between 0 and 65535) that determines how far libcurl may deviate from the supplied local_port
in order to find an available port.
If you set local_port
it’s also recommended that you set this, since it is fairly likely that your specified port will be unavailable.
This option is ignored if compiled against libcurl < 7.15.2.
889 890 891 |
# File 'ext/curb_easy.c', line 889
static VALUE ruby_curl_easy_local_port_range_set(VALUE self, VALUE local_port_range) {
CURB_IMMED_PORT_SETTER(ruby_curl_easy, local_port_range, "port range");
}
|
#low_speed_limit ⇒ Fixnum?
Obtain the minimum transfer speed over low_speedtime+ below which the transfer will be aborted.
1189 1190 1191 |
# File 'ext/curb_easy.c', line 1189
static VALUE ruby_curl_easy_low_speed_limit_get(VALUE self, VALUE low_speed_limit) {
CURB_IMMED_GETTER(ruby_curl_easy, low_speed_limit, 0);
}
|
#low_speed_limit=(fixnum) ⇒ Fixnum?
Set the transfer speed (in bytes per second) that the transfer should be below during low_speed_time
seconds for the library to consider it too slow and abort.
1178 1179 1180 |
# File 'ext/curb_easy.c', line 1178
static VALUE ruby_curl_easy_low_speed_limit_set(VALUE self, VALUE low_speed_limit) {
CURB_IMMED_SETTER(ruby_curl_easy, low_speed_limit, 0);
}
|
#low_speed_time ⇒ Fixnum?
Obtain the time that the transfer should be below low_speed_limit
for the library to abort it.
1211 1212 1213 |
# File 'ext/curb_easy.c', line 1211
static VALUE ruby_curl_easy_low_speed_time_get(VALUE self, VALUE low_speed_time) {
CURB_IMMED_GETTER(ruby_curl_easy, low_speed_time, 0);
}
|
#low_speed_time=(fixnum) ⇒ Fixnum?
Set the time (in seconds) that the transfer should be below the low_speed_limit
for the library to consider it too slow and abort.
1200 1201 1202 |
# File 'ext/curb_easy.c', line 1200
static VALUE ruby_curl_easy_low_speed_time_set(VALUE self, VALUE low_speed_time) {
CURB_IMMED_SETTER(ruby_curl_easy, low_speed_time, 0);
}
|
#max_redirects ⇒ Fixnum?
Obtain the maximum number of redirections to follow in the following perform
calls.
1063 1064 1065 |
# File 'ext/curb_easy.c', line 1063 static VALUE ruby_curl_easy_max_redirects_get(VALUE self) { CURB_IMMED_GETTER(ruby_curl_easy, max_redirs, -1); } |
#max_redirects=(fixnum) ⇒ Fixnum?
Set the maximum number of redirections to follow in the following perform
calls. Set to nil or -1 allow an infinite number (the default). Setting this option only makes sense if follow_location
is also set true.
With libcurl >= 7.15.1, setting this to 0 will cause libcurl to refuse any redirect.
1052 1053 1054 |
# File 'ext/curb_easy.c', line 1052
static VALUE ruby_curl_easy_max_redirects_set(VALUE self, VALUE max_redirs) {
CURB_IMMED_SETTER(ruby_curl_easy, max_redirs, -1);
}
|
#multi ⇒ "#<Curl::Multi>"
3003 3004 3005 3006 3007 |
# File 'ext/curb_easy.c', line 3003
static VALUE ruby_curl_easy_multi_get(VALUE self) {
ruby_curl_easy *rbce;
Data_Get_Struct(self, ruby_curl_easy, rbce);
return rbce->multi;
}
|
#multi= ⇒ "#<Curl::Multi>"
3013 3014 3015 3016 3017 3018 |
# File 'ext/curb_easy.c', line 3013
static VALUE ruby_curl_easy_multi_set(VALUE self, VALUE multi) {
ruby_curl_easy *rbce;
Data_Get_Struct(self, ruby_curl_easy, rbce);
rbce->multi = multi;
return rbce->multi;
}
|
#multipart_form_post=(boolean) ⇒ Boolean
Configure whether this Curl instance uses multipart/formdata content type for HTTP POST requests. If this is false (the default), then the application/x-www-form-urlencoded content type is used for the form data.
If this is set true, you must pass one or more PostField instances to the http_post method - no support for posting multipart forms from a string is provided.
1569 1570 1571 1572 |
# File 'ext/curb_easy.c', line 1569
static VALUE ruby_curl_easy_multipart_form_post_set(VALUE self, VALUE multipart_form_post)
{
CURB_BOOLEAN_SETTER(ruby_curl_easy, multipart_form_post);
}
|
#multipart_form_post? ⇒ Boolean
Determine whether this Curl instance uses multipart/formdata content type for HTTP POST requests.
1581 1582 1583 |
# File 'ext/curb_easy.c', line 1581 static VALUE ruby_curl_easy_multipart_form_post_q(VALUE self) { CURB_BOOLEAN_GETTER(ruby_curl_easy, multipart_form_post); } |
#name_lookup_time ⇒ Float
Retrieve the time, in seconds, it took from the start until the name resolving was completed.
2554 2555 2556 2557 2558 2559 2560 2561 2562 |
# File 'ext/curb_easy.c', line 2554
static VALUE ruby_curl_easy_name_lookup_time_get(VALUE self) {
ruby_curl_easy *rbce;
double time;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_NAMELOOKUP_TIME, &time);
return rb_float_new(time);
}
|
#native_cert= ⇒ Object
454 |
# File 'lib/curl/easy.rb', line 454 alias_method :native_cert=, :cert= |
#nosignal=(onoff) ⇒ Object
call-seq:
easy = Curl::Easy.new easy.nosignal = true
72 73 74 |
# File 'lib/curl/easy.rb', line 72 def nosignal=(onoff) set :nosignal, !!onoff end |
#num_connects ⇒ Integer
Retrieve the number of new connections libcurl had to create to achieve the previous transfer (only the successful connects are counted). Combined with redirect_count
you are able to know how many times libcurl successfully reused existing connection(s) or not.
See the Connection Options of curl_easy_setopt(3) to see how libcurl tries to make persistent connections to save time.
(requires libcurl 7.12.3 or higher, otherwise -1 is always returned).
2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 |
# File 'ext/curb_easy.c', line 2939
static VALUE ruby_curl_easy_num_connects_get(VALUE self) {
#ifdef HAVE_CURLINFO_NUM_CONNECTS
ruby_curl_easy *rbce;
long result;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_NUM_CONNECTS, &result);
return LONG2NUM(result);
#else
rb_warn("Installed libcurl is too old to support num_connects");
return INT2FIX(-1);
#endif
}
|
#on_body {|body_data| ... } ⇒ Object
Assign or remove the on_body
handler for this Curl::Easy instance. To remove a previously-supplied handler, call this method with no attached block.
The on_body
handler is called for each chunk of response body passed back by libcurl during perform
. It should perform any processing necessary, and return the actual number of bytes handled. Normally, this will equal the length of the data string, and CURL will continue processing. If the returned length does not equal the input length, CURL will abort the processing with a Curl::Err::AbortedByCallbackError.
1709 1710 1711 |
# File 'ext/curb_easy.c', line 1709
static VALUE ruby_curl_easy_on_body_set(int argc, VALUE *argv, VALUE self) {
CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, body_proc);
}
|
#on_complete {|easy| ... } ⇒ Object
Assign or remove the on_complete
handler for this Curl::Easy instance. To remove a previously-supplied handler, call this method with no attached block.
The on_complete
handler is called when the request is finished.
1783 1784 1785 |
# File 'ext/curb_easy.c', line 1783
static VALUE ruby_curl_easy_on_complete_set(int argc, VALUE *argv, VALUE self) {
CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, complete_proc);
}
|
#on_debug {|type, data| ... } ⇒ Object
Assign or remove the on_debug
handler for this Curl::Easy instance. To remove a previously-supplied handler, call this method with no attached block.
The on_debug
handler, if configured, will receive detailed information from libcurl during the perform call. This can be useful for debugging. Setting a debug handler overrides libcurl’s internal handler, disabling any output from verbose
, if set.
The type argument will match one of the Curl::Easy::CURLINFO_XXXX constants, and specifies the kind of information contained in the data. The data is passed as a String.
1841 1842 1843 |
# File 'ext/curb_easy.c', line 1841
static VALUE ruby_curl_easy_on_debug_set(int argc, VALUE *argv, VALUE self) {
CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, debug_proc);
}
|
#on_failure {|easy, code| ... } ⇒ Object
Assign or remove the on_failure
handler for this Curl::Easy instance. To remove a previously-supplied handler, call this method with no attached block.
The on_failure
handler is called when the request is finished with a status of 50x
1739 1740 1741 |
# File 'ext/curb_easy.c', line 1739
static VALUE ruby_curl_easy_on_failure_set(int argc, VALUE *argv, VALUE self) {
CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, failure_proc);
}
|
#on_header {|header_data| ... } ⇒ Object
Assign or remove the on_header
handler for this Curl::Easy instance. To remove a previously-supplied handler, call this method with no attached block.
The on_header
handler is called for each chunk of response header passed back by libcurl during perform
. The semantics are the same as for the block supplied to on_body
.
1799 1800 1801 |
# File 'ext/curb_easy.c', line 1799
static VALUE ruby_curl_easy_on_header_set(int argc, VALUE *argv, VALUE self) {
CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, header_proc);
}
|
#on_missing {|easy, code| ... } ⇒ Object
Assign or remove the on_missing handler for this Curl::Easy instance.
To remove a previously-supplied handler, call this method with no attached
block.
The +on_missing+ handler is called when request is finished with a
status of 40x
1754 1755 1756 |
# File 'ext/curb_easy.c', line 1754
static VALUE ruby_curl_easy_on_missing_set(int argc, VALUE *argv, VALUE self) {
CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, missing_proc);
}
|
#on_progress {|dl_total, dl_now, ul_total, ul_now| ... } ⇒ Object
Assign or remove the on_progress
handler for this Curl::Easy instance. To remove a previously-supplied handler, call this method with no attached block.
The on_progress
handler is called regularly by libcurl (approximately once per second) during transfers to allow the application to receive progress information. There is no guarantee that the reported progress will change between calls.
The result of the block call determines whether libcurl continues the transfer. Returning a non-true value (i.e. nil or false) will cause the transfer to abort, throwing a Curl::Err::AbortedByCallbackError.
1820 1821 1822 |
# File 'ext/curb_easy.c', line 1820
static VALUE ruby_curl_easy_on_progress_set(int argc, VALUE *argv, VALUE self) {
CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, progress_proc);
}
|
#on_redirect {|easy, code| ... } ⇒ Object
Assign or remove the on_redirect handler for this Curl::Easy instance.
To remove a previously-supplied handler, call this method with no attached
block.
The +on_redirect+ handler is called when request is finished with a
status of 30x
1769 1770 1771 |
# File 'ext/curb_easy.c', line 1769
static VALUE ruby_curl_easy_on_redirect_set(int argc, VALUE *argv, VALUE self) {
CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, redirect_proc);
}
|
#on_success {|easy| ... } ⇒ Object
Assign or remove the on_success
handler for this Curl::Easy instance. To remove a previously-supplied handler, call this method with no attached block.
The on_success
handler is called when the request is finished with a status of 20x
1724 1725 1726 |
# File 'ext/curb_easy.c', line 1724
static VALUE ruby_curl_easy_on_success_set(int argc, VALUE *argv, VALUE self) {
CURB_HANDLER_PROC_HSETTER(ruby_curl_easy, success_proc);
}
|
#os_errno ⇒ Integer
Retrieve the errno variable from a connect failure (requires libcurl 7.12.2 or higher, otherwise 0 is always returned).
2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 |
# File 'ext/curb_easy.c', line 2910
static VALUE ruby_curl_easy_os_errno_get(VALUE self) {
#ifdef HAVE_CURLINFO_OS_ERRNO
ruby_curl_easy *rbce;
long result;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_OS_ERRNO, &result);
return LONG2NUM(result);
#else
rb_warn("Installed libcurl is too old to support os_errno");
return INT2FIX(0);
#endif
}
|
#password ⇒ String
Get the current password
1263 1264 1265 1266 1267 1268 1269 |
# File 'ext/curb_easy.c', line 1263
static VALUE ruby_curl_easy_password_get(VALUE self, VALUE password) {
#if HAVE_CURLOPT_PASSWORD
CURB_OBJECT_HGETTER(ruby_curl_easy, password);
#else
return Qnil;
#endif
}
|
#password=(string) ⇒ String
Set the HTTP Authentication password.
1249 1250 1251 1252 1253 1254 1255 |
# File 'ext/curb_easy.c', line 1249
static VALUE ruby_curl_easy_password_set(VALUE self, VALUE password) {
#if HAVE_CURLOPT_PASSWORD
CURB_OBJECT_HSETTER(ruby_curl_easy, password);
#else
return Qnil;
#endif
}
|
#perform ⇒ Object
call-seq:
easy.perform => true
Transfer the currently configured URL using the options set for this Curl::Easy instance. If this is an HTTP URL, it will be transferred via the configured HTTP Verb.
53 54 55 56 57 58 59 60 61 62 63 64 |
# File 'lib/curl/easy.rb', line 53 def perform self.multi = Curl::Multi.new if self.multi.nil? self.multi.add self ret = self.multi.perform if self.last_result != 0 && self.on_failure.nil? error = Curl::Easy.error(self.last_result) raise error.first end ret end |
#post ⇒ Object
4 |
# File 'lib/curl/easy.rb', line 4 alias post http_post |
#post_body ⇒ String?
Obtain the POST body used in this Curl::Easy instance.
744 745 746 |
# File 'ext/curb_easy.c', line 744 static VALUE ruby_curl_easy_post_body_get(VALUE self) { CURB_OBJECT_HGETTER(ruby_curl_easy, postdata_buffer); } |
#post_body=(post_body) ⇒ Object
Sets the POST body of this Curl::Easy instance. This is expected to be URL encoded; no additional processing or encoding is done on the string. The content-type header will be set to application/x-www-form-urlencoded.
This is handy if you want to perform a POST against a Curl::Multi instance.
694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 |
# File 'ext/curb_easy.c', line 694
static VALUE ruby_curl_easy_post_body_set(VALUE self, VALUE post_body) {
ruby_curl_easy *rbce;
CURL *curl;
char *data;
long len;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl = rbce->curl;
if ( post_body == Qnil ) {
//rbce->postdata_buffer = Qnil;
rb_easy_del("postdata_buffer");
} else {
if (rb_type(post_body) == T_STRING) {
data = StringValuePtr(post_body);
len = RSTRING_LEN(post_body);
}
else if (rb_respond_to(post_body, rb_intern("to_s"))) {
VALUE str_body = rb_funcall(post_body, rb_intern("to_s"), 0);
data = StringValuePtr(str_body);
len = RSTRING_LEN(post_body);
}
else {
rb_raise(rb_eRuntimeError, "post data must respond_to .to_s");
}
// Store the string, since it has to hang around for the duration of the
// request. See CURLOPT_POSTFIELDS in the libcurl docs.
//rbce->postdata_buffer = post_body;
rb_easy_set("postdata_buffer", post_body);
curl_easy_setopt(curl, CURLOPT_POST, 1);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, len);
return post_body;
}
return Qnil;
}
|
#pre_transfer_time ⇒ Float
Retrieve the time, in seconds, it took from the start until the file transfer is just about to begin. This includes all pre-transfer commands and negotiations that are specific to the particular protocol(s) involved.
2590 2591 2592 2593 2594 2595 2596 2597 2598 |
# File 'ext/curb_easy.c', line 2590
static VALUE ruby_curl_easy_pre_transfer_time_get(VALUE self) {
ruby_curl_easy *rbce;
double time;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_PRETRANSFER_TIME, &time);
return rb_float_new(time);
}
|
#primary_ip ⇒ nil
Retrieve the resolved IP of the most recent connection
done with this curl handle. This string may be IPv6 if
that's enabled. This feature requires curl 7.19.x and above
2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 |
# File 'ext/curb_easy.c', line 2467
static VALUE ruby_curl_easy_primary_ip_get(VALUE self) {
ruby_curl_easy *rbce;
char* ip;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_PRIMARY_IP, &ip);
if (ip && ip[0]) { // curl returns empty string if none
return rb_str_new2(ip);
} else {
return Qnil;
}
}
|
#proxy_auth_types ⇒ Fixnum?
Obtain the proxy authentication types that may be used for the following perform
calls.
1037 1038 1039 |
# File 'ext/curb_easy.c', line 1037 static VALUE ruby_curl_easy_proxy_auth_types_get(VALUE self) { CURB_IMMED_GETTER(ruby_curl_easy, proxy_auth_types, 0); } |
#proxy_auth_types=(fixnum) ⇒ Fixnum?
Set the proxy authentication types that may be used for the following perform
calls. This is a bitmap made by ORing together the Curl::CURLAUTH constants.
1026 1027 1028 |
# File 'ext/curb_easy.c', line 1026
static VALUE ruby_curl_easy_proxy_auth_types_set(VALUE self, VALUE proxy_auth_types) {
CURB_IMMED_SETTER(ruby_curl_easy, proxy_auth_types, 0);
}
|
#proxy_port ⇒ Fixnum?
Obtain the proxy port that will be used for the following perform
calls.
922 923 924 |
# File 'ext/curb_easy.c', line 922 static VALUE ruby_curl_easy_proxy_port_get(VALUE self) { CURB_IMMED_PORT_GETTER(ruby_curl_easy, proxy_port); } |
#proxy_port=(fixnum) ⇒ Fixnum?
Set the proxy port that will be used for the following perform
calls.
912 913 914 |
# File 'ext/curb_easy.c', line 912
static VALUE ruby_curl_easy_proxy_port_set(VALUE self, VALUE proxy_port) {
CURB_IMMED_PORT_SETTER(ruby_curl_easy, proxy_port, "port");
}
|
#proxy_tunnel=(boolean) ⇒ Boolean
Configure whether this Curl instance will use proxy tunneling.
1343 1344 1345 |
# File 'ext/curb_easy.c', line 1343
static VALUE ruby_curl_easy_proxy_tunnel_set(VALUE self, VALUE proxy_tunnel) {
CURB_BOOLEAN_SETTER(ruby_curl_easy, proxy_tunnel);
}
|
#proxy_tunnel? ⇒ Boolean
Determine whether this Curl instance will use proxy tunneling.
1353 1354 1355 |
# File 'ext/curb_easy.c', line 1353 static VALUE ruby_curl_easy_proxy_tunnel_q(VALUE self) { CURB_BOOLEAN_GETTER(ruby_curl_easy, proxy_tunnel); } |
#proxy_type ⇒ Fixnum?
Obtain the proxy type that will be used for the following perform
calls.
943 944 945 |
# File 'ext/curb_easy.c', line 943 static VALUE ruby_curl_easy_proxy_type_get(VALUE self) { CURB_IMMED_GETTER(ruby_curl_easy, proxy_type, -1); } |
#proxy_type=(fixnum) ⇒ Fixnum?
Set the proxy type that will be used for the following perform
calls. This should be one of the Curl::CURLPROXY constants.
933 934 935 |
# File 'ext/curb_easy.c', line 933
static VALUE ruby_curl_easy_proxy_type_set(VALUE self, VALUE proxy_type) {
CURB_IMMED_SETTER(ruby_curl_easy, proxy_type, -1);
}
|
#proxy_url ⇒ String
Obtain the HTTP Proxy URL that will be used by subsequent calls to perform
.
435 436 437 |
# File 'ext/curb_easy.c', line 435 static VALUE ruby_curl_easy_proxy_url_get(VALUE self) { CURB_OBJECT_HGETTER(ruby_curl_easy, proxy_url); } |
#proxy_url=(url) ⇒ Object
call-seq:
easy.proxy_url = string => string
Set the URL of the HTTP proxy to use for subsequent calls to perform
. The URL should specify the the host name or dotted IP address. To specify port number in this string, append :[port] to the end of the host name. The proxy string may be prefixed with [protocol]:// since any such prefix will be ignored. The proxy’s port number may optionally be specified with the separate option proxy_port .
When you tell the library to use an HTTP proxy, libcurl will transparently convert operations to HTTP even if you specify an FTP URL etc. This may have an impact on what other features of the library you can use, such as FTP specifics that don’t work unless you tunnel through the HTTP proxy. Such tunneling is activated with proxy_tunnel = true.
libcurl respects the environment variables http_proxy, ftp_proxy, all_proxy etc, if any of those is set. The proxy_url option does however override any possibly set environment variables.
Starting with libcurl 7.14.1, the proxy host string given in environment variables can be specified the exact same way as the proxy can be set with proxy_url, including protocol prefix (http://) and embedded user + password.
136 137 138 |
# File 'lib/curl/easy.rb', line 136 def proxy_url=(url) set :proxy, url end |
#proxypwd ⇒ String
Obtain the username/password string that will be used for proxy connection during subsequent calls to perform
. The supplied string should have the form “username:password”
510 511 512 |
# File 'ext/curb_easy.c', line 510 static VALUE ruby_curl_easy_proxypwd_get(VALUE self) { CURB_OBJECT_HGETTER(ruby_curl_easy, proxypwd); } |
#proxypwd=(value) ⇒ Object
call-seq:
easy.proxypwd = string => string
Set the username/password string to use for proxy connection during subsequent calls to perform
. The supplied string should have the form “username:password”
190 191 192 |
# File 'lib/curl/easy.rb', line 190 def proxypwd=(value) set :proxyuserpwd, value end |
#put ⇒ Object
5 |
# File 'lib/curl/easy.rb', line 5 alias put http_put |
#put_data=(data) ⇒ Object
Points this Curl::Easy instance to data to be uploaded via PUT. This sets the request to a PUT type request - useful if you want to PUT via a multi handle.
756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 |
# File 'ext/curb_easy.c', line 756
static VALUE ruby_curl_easy_put_data_set(VALUE self, VALUE data) {
ruby_curl_easy *rbce;
CURL *curl;
VALUE upload;
VALUE headers;
Data_Get_Struct(self, ruby_curl_easy, rbce);
upload = ruby_curl_upload_new(cCurlUpload);
ruby_curl_upload_stream_set(upload,data);
curl = rbce->curl;
rb_easy_set("upload", upload); /* keep the upload object alive as long as
the easy handle is active or until the upload
is complete or terminated... */
curl_easy_setopt(curl, CURLOPT_NOBODY, 0);
curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
curl_easy_setopt(curl, CURLOPT_READFUNCTION, (curl_read_callback)read_data_handler);
curl_easy_setopt(curl, CURLOPT_READDATA, rbce);
/*
* we need to set specific headers for the PUT to work... so
* convert the internal headers structure to a HASH if one is set
*/
if (!rb_easy_nil("headers")) {
if (rb_easy_type_check("headers", T_ARRAY) || rb_easy_type_check("headers", T_STRING)) {
rb_raise(rb_eRuntimeError, "Must set headers as a HASH to modify the headers in an PUT request");
}
}
// exit fast if the payload is empty
if (NIL_P(data)) { return data; }
headers = rb_easy_get("headers");
if( headers == Qnil ) {
headers = rb_hash_new();
}
if (rb_respond_to(data, rb_intern("read"))) {
VALUE stat = rb_funcall(data, rb_intern("stat"), 0);
if( stat && rb_hash_aref(headers, rb_str_new2("Content-Length")) == Qnil) {
VALUE size;
if( rb_hash_aref(headers, rb_str_new2("Expect")) == Qnil ) {
rb_hash_aset(headers, rb_str_new2("Expect"), rb_str_new2(""));
}
size = rb_funcall(stat, rb_intern("size"), 0);
curl_easy_setopt(curl, CURLOPT_INFILESIZE, FIX2LONG(size));
}
else if( rb_hash_aref(headers, rb_str_new2("Content-Length")) == Qnil && rb_hash_aref(headers, rb_str_new2("Transfer-Encoding")) == Qnil ) {
rb_hash_aset(headers, rb_str_new2("Transfer-Encoding"), rb_str_new2("chunked"));
}
else if( rb_hash_aref(headers, rb_str_new2("Content-Length")) ) {
VALUE size = rb_funcall(rb_hash_aref(headers, rb_str_new2("Content-Length")), rb_intern("to_i"), 0);
curl_easy_setopt(curl, CURLOPT_INFILESIZE, FIX2LONG(size));
}
}
else if (rb_respond_to(data, rb_intern("to_s"))) {
curl_easy_setopt(curl, CURLOPT_INFILESIZE, RSTRING_LEN(data));
if( rb_hash_aref(headers, rb_str_new2("Expect")) == Qnil ) {
rb_hash_aset(headers, rb_str_new2("Expect"), rb_str_new2(""));
}
}
else {
rb_raise(rb_eRuntimeError, "PUT data must respond to read or to_s");
}
rb_easy_set("headers",headers);
// if we made it this far, all should be well.
return data;
}
|
#redirect_count ⇒ Integer
Retrieve the total number of redirections that were actually followed.
Requires libcurl 7.9.7 or higher, otherwise -1 is always returned.
2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 |
# File 'ext/curb_easy.c', line 2652
static VALUE ruby_curl_easy_redirect_count_get(VALUE self) {
#ifdef HAVE_CURLINFO_REDIRECT_COUNT
ruby_curl_easy *rbce;
long count;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_REDIRECT_COUNT, &count);
return LONG2NUM(count);
#else
rb_warn("Installed libcurl is too old to support redirect_count");
return INT2FIX(-1);
#endif
}
|
#redirect_time ⇒ Float
Retrieve the total time, in seconds, it took for all redirection steps include name lookup, connect, pretransfer and transfer before final transaction was started. redirect_time
contains the complete execution time for multiple redirections.
Requires libcurl 7.9.7 or higher, otherwise -1 is always returned.
2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 |
# File 'ext/curb_easy.c', line 2629
static VALUE ruby_curl_easy_redirect_time_get(VALUE self) {
#ifdef HAVE_CURLINFO_REDIRECT_TIME
ruby_curl_easy *rbce;
double time;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_REDIRECT_TIME, &time);
return rb_float_new(time);
#else
rb_warn("Installed libcurl is too old to support redirect_time");
return rb_float_new(-1);
#endif
}
|
#redirect_url ⇒ nil
Retrieve the URL a redirect would take you to if you would enable CURLOPT_FOLLOWLOCATION.
Requires libcurl 7.18.2 or higher, otherwise -1 is always returned.
2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 |
# File 'ext/curb_easy.c', line 2677
static VALUE ruby_curl_easy_redirect_url_get(VALUE self) {
#ifdef HAVE_CURLINFO_REDIRECT_URL
ruby_curl_easy *rbce;
char* url;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_REDIRECT_URL, &url);
if (url && url[0]) { // curl returns empty string if none
return rb_str_new2(url);
} else {
return Qnil;
}
#else
rb_warn("Installed libcurl is too old to support redirect_url");
return INT2FIX(-1);
#endif
}
|
#request_size ⇒ Fixnum
Retrieve the total size of the issued requests. This is so far only for HTTP requests. Note that this may be more than one request if follow_location?
is true.
2791 2792 2793 2794 2795 2796 2797 2798 2799 |
# File 'ext/curb_easy.c', line 2791
static VALUE ruby_curl_easy_request_size_get(VALUE self) {
ruby_curl_easy *rbce;
long size;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_REQUEST_SIZE, &size);
return LONG2NUM(size);
}
|
#reset ⇒ Hash
Reset the Curl::Easy instance, clears out all settings.
from curl.haxx.se/libcurl/c/curl_easy_reset.html Re-initializes all options previously set on a specified CURL handle to the default values. This puts back the handle to the same state as it was in when it was just created with curl_easy_init(3). It does not change the following information kept in the handle: live connections, the Session ID cache, the DNS cache, the cookies and shares.
The return value contains all settings stored.
386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 |
# File 'ext/curb_easy.c', line 386
static VALUE ruby_curl_easy_reset(VALUE self) {
CURLcode ecode;
ruby_curl_easy *rbce;
VALUE opts_dup;
Data_Get_Struct(self, ruby_curl_easy, rbce);
if (rbce->callback_active) {
rb_raise(rb_eRuntimeError, "Cannot close an active curl handle within a callback");
}
opts_dup = rb_funcall(rbce->opts, rb_intern("dup"), 0);
curl_easy_reset(rbce->curl);
ruby_curl_easy_zero(rbce);
/* rest clobbers the private setting, so reset it to self */
ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)self);
if (ecode != CURLE_OK) {
raise_curl_easy_error_exception(ecode);
}
/* Free everything up */
if (rbce->curl_headers) {
curl_slist_free_all(rbce->curl_headers);
rbce->curl_headers = NULL;
}
return opts_dup;
}
|
#resolve_mode ⇒ Object
Determines what type of IP address this Curl::Easy instance resolves DNS names to.
1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 |
# File 'ext/curb_easy.c', line 1638
static VALUE ruby_curl_easy_resolve_mode(VALUE self) {
ruby_curl_easy *rbce;
Data_Get_Struct(self, ruby_curl_easy, rbce);
unsigned short rm = rbce->resolve_mode;
switch(rm) {
case CURL_IPRESOLVE_V4:
return rb_easy_sym("ipv4");
case CURL_IPRESOLVE_V6:
return rb_easy_sym("ipv6");
default:
return rb_easy_sym("auto");
}
}
|
#resolve_mode=(symbol) ⇒ Object
Configures what type of IP address this Curl::Easy instance resolves DNS names to. Valid options are:
- :auto
-
resolves DNS names to all IP versions your system allows
- :ipv4
-
resolves DNS names to IPv4 only
- :ipv6
-
resolves DNS names to IPv6 only
1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 |
# File 'ext/curb_easy.c', line 1665
static VALUE ruby_curl_easy_resolve_mode_set(VALUE self, VALUE resolve_mode) {
if (TYPE(resolve_mode) != T_SYMBOL) {
rb_raise(rb_eTypeError, "Must pass a symbol");
return Qnil;
} else {
ruby_curl_easy *rbce;
Data_Get_Struct(self, ruby_curl_easy, rbce);
ID resolve_mode_id = rb_to_id(resolve_mode);
if (resolve_mode_id == rb_intern("auto")) {
rbce->resolve_mode = CURL_IPRESOLVE_WHATEVER;
return resolve_mode;
} else if (resolve_mode_id == rb_intern("ipv4")) {
rbce->resolve_mode = CURL_IPRESOLVE_V4;
return resolve_mode;
} else if (resolve_mode_id == rb_intern("ipv6")) {
rbce->resolve_mode = CURL_IPRESOLVE_V6;
return resolve_mode;
} else {
rb_raise(rb_eArgError, "Must set to one of :auto, :ipv4, :ipv6");
return Qnil;
}
}
}
|
#response_code ⇒ Fixnum
Retrieve the last received HTTP or FTP code. This will be zero if no server response code has been received. Note that a proxy’s CONNECT response should be read with http_connect_code
and not this method.
2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 |
# File 'ext/curb_easy.c', line 2443
static VALUE ruby_curl_easy_response_code_get(VALUE self) {
ruby_curl_easy *rbce;
long code;
Data_Get_Struct(self, ruby_curl_easy, rbce);
#ifdef HAVE_CURLINFO_RESPONSE_CODE
curl_easy_getinfo(rbce->curl, CURLINFO_RESPONSE_CODE, &code);
#else
// old libcurl
curl_easy_getinfo(rbce->curl, CURLINFO_HTTP_CODE, &code);
#endif
return LONG2NUM(code);
}
|
#set(opt, val) ⇒ Object
call-seq:
easy.set :sym|Fixnum, value
set options on the curl easy handle see curl.haxx.se/libcurl/c/curl_easy_setopt.html
27 28 29 30 31 32 33 |
# File 'lib/curl/easy.rb', line 27 def set(opt,val) if opt.is_a?(Symbol) setopt(sym2curl(opt), val) else setopt(opt.to_i, val) end end |
#Fixnum ⇒ Object
Iniital access to libcurl curl_easy_setopt
3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 |
# File 'ext/curb_easy.c', line 3036
static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
ruby_curl_easy *rbce;
long option = FIX2LONG(opt);
Data_Get_Struct(self, ruby_curl_easy, rbce);
switch (option) {
/* BEHAVIOR OPTIONS */
case CURLOPT_VERBOSE: {
VALUE verbose = val;
CURB_BOOLEAN_SETTER(ruby_curl_easy, verbose);
} break;
case CURLOPT_FOLLOWLOCATION: {
VALUE follow_location = val;
CURB_BOOLEAN_SETTER(ruby_curl_easy, follow_location);
} break;
/* TODO: CALLBACK OPTIONS */
/* TODO: ERROR OPTIONS */
/* NETWORK OPTIONS */
case CURLOPT_URL: {
VALUE url = val;
CURB_OBJECT_HSETTER(ruby_curl_easy, url);
} break;
case CURLOPT_CUSTOMREQUEST:
curl_easy_setopt(rbce->curl, CURLOPT_CUSTOMREQUEST, NIL_P(val) ? NULL : StringValueCStr(val));
break;
case CURLOPT_HTTP_VERSION:
curl_easy_setopt(rbce->curl, CURLOPT_HTTP_VERSION, FIX2INT(val));
break;
case CURLOPT_PROXY: {
VALUE proxy_url = val;
CURB_OBJECT_HSETTER(ruby_curl_easy, proxy_url);
} break;
case CURLOPT_INTERFACE: {
VALUE interface_hm = val;
CURB_OBJECT_HSETTER(ruby_curl_easy, interface_hm);
} break;
case CURLOPT_HEADER:
case CURLOPT_NOPROGRESS:
case CURLOPT_NOSIGNAL:
case CURLOPT_HTTPGET:
case CURLOPT_NOBODY: {
int type = rb_type(val);
VALUE value;
if (type == T_TRUE) {
value = rb_int_new(1);
} else if (type == T_FALSE) {
value = rb_int_new(0);
} else {
value = rb_funcall(val, rb_intern("to_i"), 0);
}
curl_easy_setopt(rbce->curl, option, FIX2INT(value));
} break;
case CURLOPT_USERPWD: {
VALUE userpwd = val;
CURB_OBJECT_HSETTER(ruby_curl_easy, userpwd);
} break;
case CURLOPT_PROXYUSERPWD: {
VALUE proxypwd = val;
CURB_OBJECT_HSETTER(ruby_curl_easy, proxypwd);
} break;
case CURLOPT_COOKIE: {
VALUE cookies = val;
CURB_OBJECT_HSETTER(ruby_curl_easy, cookies);
} break;
case CURLOPT_COOKIEFILE: {
VALUE cookiefile = val;
CURB_OBJECT_HSETTER(ruby_curl_easy, cookiefile);
} break;
case CURLOPT_COOKIEJAR: {
VALUE cookiejar = val;
CURB_OBJECT_HSETTER(ruby_curl_easy, cookiejar);
} break;
case CURLOPT_RESUME_FROM: {
curl_easy_setopt(rbce->curl, CURLOPT_RESUME_FROM, FIX2LONG(val));
} break;
case CURLOPT_FAILONERROR: {
curl_easy_setopt(rbce->curl, CURLOPT_FAILONERROR, FIX2LONG(val));
} break;
default:
break;
}
return val;
}
|
#ssl_verify_host ⇒ Numeric
Determine whether this Curl instance will verify that the server cert is for the server it is known as.
1432 1433 1434 |
# File 'ext/curb_easy.c', line 1432 static VALUE ruby_curl_easy_ssl_verify_host_get(VALUE self) { CURB_IMMED_GETTER(ruby_curl_easy, ssl_verify_host, 0); } |
#ssl_verify_host=(value) ⇒ Object
140 141 142 143 144 |
# File 'lib/curl/easy.rb', line 140 def ssl_verify_host=(value) value = 1 if value.class == TrueClass value = 0 if value.class == FalseClass self.ssl_verify_host_integer=value end |
#ssl_verify_host? ⇒ Boolean
call-seq:
easy.ssl_verify_host? => boolean
Deprecated: call easy.ssl_verify_host instead can be one of [0,1,2]
Determine whether this Curl instance will verify that the server cert is for the server it is known as.
156 157 158 |
# File 'lib/curl/easy.rb', line 156 def ssl_verify_host? ssl_verify_host.nil? ? false : (ssl_verify_host > 0) end |
#ssl_verify_host_integer=(ssl_verify_host) ⇒ Object
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? .
1421 1422 1423 |
# File 'ext/curb_easy.c', line 1421
static VALUE ruby_curl_easy_ssl_verify_host_set(VALUE self, VALUE ssl_verify_host) {
CURB_IMMED_SETTER(ruby_curl_easy, ssl_verify_host, 0);
}
|
#ssl_verify_peer=(boolean) ⇒ Boolean
Configure whether this Curl instance will verify the SSL peer 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.
1393 1394 1395 |
# File 'ext/curb_easy.c', line 1393
static VALUE ruby_curl_easy_ssl_verify_peer_set(VALUE self, VALUE ssl_verify_peer) {
CURB_BOOLEAN_SETTER(ruby_curl_easy, ssl_verify_peer);
}
|
#ssl_verify_peer? ⇒ Boolean
Determine whether this Curl instance will verify the SSL peer certificate.
1404 1405 1406 |
# File 'ext/curb_easy.c', line 1404 static VALUE ruby_curl_easy_ssl_verify_peer_q(VALUE self) { CURB_BOOLEAN_GETTER(ruby_curl_easy, ssl_verify_peer); } |
#ssl_verify_result ⇒ Integer
Retrieve the result of the certification verification that was requested (by setting ssl_verify_peer?
to true
).
2808 2809 2810 2811 2812 2813 2814 2815 2816 |
# File 'ext/curb_easy.c', line 2808
static VALUE ruby_curl_easy_ssl_verify_result_get(VALUE self) {
ruby_curl_easy *rbce;
long result;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_SSL_VERIFYRESULT, &result);
return LONG2NUM(result);
}
|
#ssl_version ⇒ Fixnum
Get the version of SSL/TLS that libcurl will attempt to use.
1289 1290 1291 |
# File 'ext/curb_easy.c', line 1289
static VALUE ruby_curl_easy_ssl_version_get(VALUE self, VALUE ssl_version) {
CURB_IMMED_GETTER(ruby_curl_easy, ssl_version, -1);
}
|
#ssl_version=(value) ⇒ Fixnum?
Sets the version of SSL/TLS that libcurl will attempt to use. Valid options are Curl::CURL_SSLVERSION_TLSv1, Curl::CURL_SSLVERSION::SSLv2, Curl::CURL_SSLVERSION_SSLv3 and Curl::CURL_SSLVERSION_DEFAULT
1279 1280 1281 |
# File 'ext/curb_easy.c', line 1279
static VALUE ruby_curl_easy_ssl_version_set(VALUE self, VALUE ssl_version) {
CURB_IMMED_SETTER(ruby_curl_easy, ssl_version, -1);
}
|
#start_transfer_time ⇒ Float
Retrieve the time, in seconds, it took from the start until the first byte is just about to be transferred. This includes the pre_transfer_time
and also the time the server needs to calculate the result.
2608 2609 2610 2611 2612 2613 2614 2615 2616 |
# File 'ext/curb_easy.c', line 2608
static VALUE ruby_curl_easy_start_transfer_time_get(VALUE self) {
ruby_curl_easy *rbce;
double time;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_STARTTRANSFER_TIME, &time);
return rb_float_new(time);
}
|
#status ⇒ Object
call-seq:
easy.status => String
11 12 13 14 15 16 17 18 19 |
# File 'lib/curl/easy.rb', line 11 def status parts = self.header_str.split(/\s/) status = [] parts.shift while parts.size > 0 && parts.first != '' status << parts.shift end status.join(' ') end |
#sym2curl(opt) ⇒ Object
call-seq:
easy.sym2curl :symbol => Fixnum
translates ruby symbols to libcurl
41 42 43 |
# File 'lib/curl/easy.rb', line 41 def sym2curl(opt) Curl.const_get("CURLOPT_#{opt.to_s.upcase}") end |
#timeout ⇒ Fixnum?
Obtain the maximum time in seconds that you allow the libcurl transfer operation to take.
1090 1091 1092 |
# File 'ext/curb_easy.c', line 1090
static VALUE ruby_curl_easy_timeout_get(VALUE self, VALUE timeout) {
CURB_IMMED_GETTER(ruby_curl_easy, timeout, 0);
}
|
#timeout=(fixnum) ⇒ Fixnum?
Set the maximum time in seconds that you allow the libcurl transfer operation to take. Normally, name lookups can take a considerable time and limiting operations to less than a few minutes risk aborting perfectly normal operations.
Set to nil (or zero) to disable timeout (it will then only timeout on the system’s internal timeouts).
1079 1080 1081 |
# File 'ext/curb_easy.c', line 1079
static VALUE ruby_curl_easy_timeout_set(VALUE self, VALUE timeout) {
CURB_IMMED_SETTER(ruby_curl_easy, timeout, 0);
}
|
#total_time ⇒ Float
Retrieve the total time in seconds for the previous transfer, including name resolving, TCP connect etc.
2537 2538 2539 2540 2541 2542 2543 2544 2545 |
# File 'ext/curb_easy.c', line 2537
static VALUE ruby_curl_easy_total_time_get(VALUE self) {
ruby_curl_easy *rbce;
double time;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_TOTAL_TIME, &time);
return rb_float_new(time);
}
|
#unescape("some%20text") ⇒ Object
Convert the given URL encoded input string to a “plain string” and return the result. All input characters that are URL encoded (%XX where XX is a two-digit hexadecimal number) are converted to their binary versions.
3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 |
# File 'ext/curb_easy.c', line 3196
static VALUE ruby_curl_easy_unescape(VALUE self, VALUE str) {
ruby_curl_easy *rbce;
int rlen;
char *result;
VALUE rresult;
Data_Get_Struct(self, ruby_curl_easy, rbce);
#if (LIBCURL_VERSION_NUM >= 0x070f04)
result = (char*)curl_easy_unescape(rbce->curl, StringValuePtr(str), (int)RSTRING_LEN(str), &rlen);
#else
result = (char*)curl_unescape(StringValuePtr(str), RSTRING_LEN(str));
rlen = strlen(result);
#endif
rresult = rb_str_new(result, rlen);
curl_free(result);
return rresult;
}
|
#unrestricted_auth=(boolean) ⇒ Boolean
Configure whether this Curl instance may use any HTTP authentication method available when necessary.
1519 1520 1521 |
# File 'ext/curb_easy.c', line 1519
static VALUE ruby_curl_easy_unrestricted_auth_set(VALUE self, VALUE unrestricted_auth) {
CURB_BOOLEAN_SETTER(ruby_curl_easy, unrestricted_auth);
}
|
#unrestricted_auth? ⇒ Boolean
Determine whether this Curl instance may use any HTTP authentication method available when necessary.
1530 1531 1532 |
# File 'ext/curb_easy.c', line 1530 static VALUE ruby_curl_easy_unrestricted_auth_q(VALUE self) { CURB_BOOLEAN_GETTER(ruby_curl_easy, unrestricted_auth); } |
#upload_speed ⇒ Float
Retrieve the average upload speed that curl measured for the preceeding complete upload.
2739 2740 2741 2742 2743 2744 2745 2746 2747 |
# File 'ext/curb_easy.c', line 2739
static VALUE ruby_curl_easy_upload_speed_get(VALUE self) {
ruby_curl_easy *rbce;
double bytes;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_SPEED_UPLOAD, &bytes);
return rb_float_new(bytes);
}
|
#uploaded_bytes ⇒ Float
Retrieve the total amount of bytes that were uploaded in the preceeding transfer.
2705 2706 2707 2708 2709 2710 2711 2712 2713 |
# File 'ext/curb_easy.c', line 2705
static VALUE ruby_curl_easy_uploaded_bytes_get(VALUE self) {
ruby_curl_easy *rbce;
double bytes;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_SIZE_UPLOAD, &bytes);
return rb_float_new(bytes);
}
|
#uploaded_content_length ⇒ Float
Retrieve the content-length of the upload.
2849 2850 2851 2852 2853 2854 2855 2856 2857 |
# File 'ext/curb_easy.c', line 2849
static VALUE ruby_curl_easy_uploaded_content_length_get(VALUE self) {
ruby_curl_easy *rbce;
double bytes;
Data_Get_Struct(self, ruby_curl_easy, rbce);
curl_easy_getinfo(rbce->curl, CURLINFO_CONTENT_LENGTH_UPLOAD, &bytes);
return rb_float_new(bytes);
}
|
#url ⇒ String
Obtain the URL that will be used by subsequent calls to perform
.
425 426 427 |
# File 'ext/curb_easy.c', line 425 static VALUE ruby_curl_easy_url_get(VALUE self) { CURB_OBJECT_HGETTER(ruby_curl_easy, url); } |
#url=(u) ⇒ Object
call-seq:
easy.url = "http://some.url/" => "http://some.url/"
Set the URL for subsequent calls to perform
. It is acceptable (and even recommended) to reuse Curl::Easy instances by reassigning the URL between calls to perform
.
107 108 109 |
# File 'lib/curl/easy.rb', line 107 def url=(u) set :url, u end |
#use_netrc=(boolean) ⇒ Boolean
Configure whether this Curl instance will use data from the user’s .netrc file for FTP connections.
1466 1467 1468 |
# File 'ext/curb_easy.c', line 1466
static VALUE ruby_curl_easy_use_netrc_set(VALUE self, VALUE use_netrc) {
CURB_BOOLEAN_SETTER(ruby_curl_easy, use_netrc);
}
|
#use_netrc? ⇒ Boolean
Determine whether this Curl instance will use data from the user’s .netrc file for FTP connections.
1477 1478 1479 |
# File 'ext/curb_easy.c', line 1477 static VALUE ruby_curl_easy_use_netrc_q(VALUE self) { CURB_BOOLEAN_GETTER(ruby_curl_easy, use_netrc); } |
#use_ssl ⇒ Fixnum
Get the desired level for using SSL on FTP connections.
1310 1311 1312 |
# File 'ext/curb_easy.c', line 1310
static VALUE ruby_curl_easy_use_ssl_get(VALUE self, VALUE use_ssl) {
CURB_IMMED_GETTER(ruby_curl_easy, use_ssl, -1);
}
|
#use_ssl=(value) ⇒ Fixnum?
Ensure libcurl uses SSL for FTP connections. Valid options are Curl::CURL_USESSL_NONE, Curl::CURL_USESSL_TRY, Curl::CURL_USESSL_CONTROL, and Curl::CURL_USESSL_ALL.
1300 1301 1302 |
# File 'ext/curb_easy.c', line 1300
static VALUE ruby_curl_easy_use_ssl_set(VALUE self, VALUE use_ssl) {
CURB_IMMED_SETTER(ruby_curl_easy, use_ssl, -1);
}
|
#useragent ⇒ "Ruby/Curb"
Obtain the user agent string used for this Curl::Easy instance
680 681 682 |
# File 'ext/curb_easy.c', line 680 static VALUE ruby_curl_easy_useragent_get(VALUE self) { CURB_OBJECT_HGETTER(ruby_curl_easy, useragent); } |
#useragent=(useragent) ⇒ Object
Set the user agent string for this Curl::Easy instance
670 671 672 |
# File 'ext/curb_easy.c', line 670
static VALUE ruby_curl_easy_useragent_set(VALUE self, VALUE useragent) {
CURB_OBJECT_HSETTER(ruby_curl_easy, useragent);
}
|
#username ⇒ String
Get the current username
1235 1236 1237 1238 1239 1240 1241 |
# File 'ext/curb_easy.c', line 1235
static VALUE ruby_curl_easy_username_get(VALUE self, VALUE username) {
#if HAVE_CURLOPT_USERNAME
CURB_OBJECT_HGETTER(ruby_curl_easy, username);
#else
return Qnil;
#endif
}
|
#username=(string) ⇒ String
Set the HTTP Authentication username.
1221 1222 1223 1224 1225 1226 1227 |
# File 'ext/curb_easy.c', line 1221
static VALUE ruby_curl_easy_username_set(VALUE self, VALUE username) {
#if HAVE_CURLOPT_USERNAME
CURB_OBJECT_HSETTER(ruby_curl_easy, username);
#else
return Qnil;
#endif
}
|
#userpwd ⇒ String
Obtain the username/password string that will be used for subsequent calls to perform
.
498 499 500 |
# File 'ext/curb_easy.c', line 498 static VALUE ruby_curl_easy_userpwd_get(VALUE self) { CURB_OBJECT_HGETTER(ruby_curl_easy, userpwd); } |
#userpwd=(value) ⇒ Object
call-seq:
easy.userpwd = string => string
Set the username/password string to use for subsequent calls to perform
. The supplied string should have the form “username:password”
178 179 180 |
# File 'lib/curl/easy.rb', line 178 def userpwd=(value) set :userpwd, value end |
#verbose=(boolean) ⇒ Boolean
Configure whether this Curl instance gives verbose output to STDERR during transfers. Ignored if this instance has an on_debug handler.
1541 1542 1543 |
# File 'ext/curb_easy.c', line 1541
static VALUE ruby_curl_easy_verbose_set(VALUE self, VALUE verbose) {
CURB_BOOLEAN_SETTER(ruby_curl_easy, verbose);
}
|
#verbose? ⇒ Boolean
Determine whether this Curl instance gives verbose output to STDERR during transfers.
1552 1553 1554 |
# File 'ext/curb_easy.c', line 1552 static VALUE ruby_curl_easy_verbose_q(VALUE self) { CURB_BOOLEAN_GETTER(ruby_curl_easy, verbose); } |