Class: Curl::Easy

Inherits:
Object
  • Object
show all
Defined in:
lib/curl/easy.rb,
ext/curb_easy.c

Defined Under Namespace

Classes: Error

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#Curl::Easy.new ⇒ #<Curl::Easy... #Curl::Easy.new(url = nil) ⇒ #<Curl::Easy... #Curl::Easy.new(url = nil) {|self| ... } ⇒ #<Curl::Easy...

Initialize a new Curl::Easy instance, optionally supplying the URL. The block form allows further configuration to be supplied before the instance is returned.

Overloads:

  • #Curl::Easy.new ⇒ #<Curl::Easy...

    Returns ].

  • #Curl::Easy.new(url = nil) ⇒ #<Curl::Easy...

    Returns ].

  • #Curl::Easy.new(url = nil) {|self| ... } ⇒ #<Curl::Easy...

    Returns ].

    Yields:

    • (self) 


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
373
374
375
376
377
378
379
380
 
# File 'ext/curb_easy.c', line 345

static VALUE ruby_curl_easy_initialize(int argc, VALUE *argv, VALUE self) {
  CURLcode ecode;
  VALUE url, blk;
  ruby_curl_easy *rbce;

  rb_scan_args(argc, argv, "01&", &url, &blk);

  Data_Get_Struct(self, ruby_curl_easy, rbce);

  /* handler */
  rbce->curl = curl_easy_init();
  if (!rbce->curl) {
    rb_raise(eCurlErrFailedInit, "Failed to initialize easy handle");
  }

  rbce->multi = Qnil;
  rbce->opts  = Qnil;

  ruby_curl_easy_zero(rbce);

  curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, &rbce->err_buf);

  rb_easy_set("url", url);

  /* set the pointer to the curl handle */
  ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)self);
  if (ecode != CURLE_OK) {
    raise_curl_easy_error_exception(ecode);
  }

  if (blk != Qnil) {
    rb_funcall(blk, idCall, 1, self);
  }

  return self;
}

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.



520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
 
# File 'lib/curl/easy.rb', line 520

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) ⇒ Array, String

translate an internal libcurl error to ruby error class

Returns ].

Returns:

  • (Array, String) —

    ]



4161
4162
4163
 
# File 'ext/curb_easy.c', line 4161

static VALUE ruby_curl_easy_error_message(VALUE klass, VALUE code) {
  return rb_curl_easy_error(NUM2INT(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.

Yields:

  • (c) 


495
496
497
498
499
500
 
# File 'lib/curl/easy.rb', line 495

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.

Yields:

  • (c) 


401
402
403
404
405
406
 
# File 'lib/curl/easy.rb', line 401

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.

Yields:

  • (c) 


418
419
420
421
422
423
 
# File 'lib/curl/easy.rb', line 418

def http_head(*args)
  c = Curl::Easy.new(*args)
  yield c if block_given?
  c.http_head
  c
end

.http_patch(*args) {|c| ... } ⇒ Object

call-seq:

Curl::Easy.http_patch(url, data) {|c| ... }
Curl::Easy.http_patch(url, "some=urlencoded%20form%20data&and=so%20on") => true
Curl::Easy.http_patch(url, "some=urlencoded%20form%20data", "and=so%20on", ...) => true
Curl::Easy.http_patch(url, "some=urlencoded%20form%20data", Curl::PostField, "and=so%20on", ...) => true
Curl::Easy.http_patch(url, Curl::PostField, Curl::PostField ..., Curl::PostField) => true

see easy.http_patch

Yields:

  • (c) 


453
454
455
456
457
458
459
 
# File 'lib/curl/easy.rb', line 453

def http_patch(*args)
  url = args.shift
  c = Curl::Easy.new(url)
  yield c if block_given?
  c.http_patch(*args)
  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.

Yields:

  • (c) 


477
478
479
480
481
482
483
 
# File 'lib/curl/easy.rb', line 477

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(*args) {|c| ... } ⇒ Object

call-seq:

Curl::Easy.http_put(url, data) {|c| ... }
Curl::Easy.http_put(url, "some=urlencoded%20form%20data&and=so%20on") => true
Curl::Easy.http_put(url, "some=urlencoded%20form%20data", "and=so%20on", ...) => true
Curl::Easy.http_put(url, "some=urlencoded%20form%20data", Curl::PostField, "and=so%20on", ...) => true
Curl::Easy.http_put(url, Curl::PostField, Curl::PostField ..., Curl::PostField) => true

see easy.http_put

Yields:

  • (c) 


435
436
437
438
439
440
441
 
# File 'lib/curl/easy.rb', line 435

def http_put(*args)
  url = args.shift
  c = Curl::Easy.new(url)
  yield c if block_given?
  c.http_put(*args)
  c
end

.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.

Yields:

  • (c) 


384
385
386
387
388
389
 
# File 'lib/curl/easy.rb', line 384

def perform(*args)
  c = Curl::Easy.new(*args)
  yield c if block_given?
  c.perform
  c
end

Instance Method Details

#app_connect_time ⇒ Object 



3231
3232
3233
3234
3235
3236
3237
3238
3239
 
# File 'ext/curb_easy.c', line 3231

static VALUE ruby_curl_easy_app_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_APPCONNECT_TIME, &time);

  return rb_float_new(time);
}

#autoreferer=(autoreferer) ⇒ Object

easy = Curl::Easy.new easy.autoreferer=true



1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
 
# File 'ext/curb_easy.c', line 1813

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 Also known as: body

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.



3028
3029
3030
3031
3032
3033
3034
 
# File 'ext/curb_easy.c', line 3028

static VALUE ruby_curl_easy_body_str_get(VALUE self) {
  /*
     TODO: can we force_encoding on the return here if we see charset=utf-8 in the content-type header?
     Content-Type: application/json; charset=utf-8
  */
  CURB_OBJECT_HGETTER(ruby_curl_easy, body_data);
}

#cacert ⇒ String

Obtain the cacert file to use for this Curl::Easy instance.

Returns:

  • (String) 


767
768
769
 
# File 'ext/curb_easy.c', line 767

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.



757
758
759
 
# File 'ext/curb_easy.c', line 757

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.

Returns:

  • (String) 


723
724
725
 
# File 'ext/curb_easy.c', line 723

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.



713
714
715
716
717
718
719
720
721
722
 
# File 'ext/curb_easy.c', line 713

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.



745
746
747
 
# File 'ext/curb_easy.c', line 745

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.



735
736
737
 
# File 'ext/curb_easy.c', line 735

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



777
778
779
 
# File 'ext/curb_easy.c', line 777

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

Returns:

  • (String) 


799
800
801
 
# File 'ext/curb_easy.c', line 799

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



789
790
791
 
# File 'ext/curb_easy.c', line 789

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.



406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
 
# File 'ext/curb_easy.c', line 406

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);
  if (!newrbce) {
    rb_raise(rb_eNoMemError, "Failed to allocate memory for Curl::Easy clone");
  }
  /* shallow copy */
  memcpy(newrbce, rbce, sizeof(ruby_curl_easy));

  /* now deep copy */
  newrbce->curl = curl_easy_duphandle(rbce->curl);
  newrbce->curl_headers = (rbce->curl_headers) ? duplicate_curl_slist(rbce->curl_headers) : NULL;
  newrbce->curl_proxy_headers = (rbce->curl_proxy_headers) ? duplicate_curl_slist(rbce->curl_proxy_headers) : NULL;
  newrbce->curl_ftp_commands = (rbce->curl_ftp_commands) ? duplicate_curl_slist(rbce->curl_ftp_commands) : NULL;
  newrbce->curl_resolve = (rbce->curl_resolve) ? duplicate_curl_slist(rbce->curl_resolve) : NULL;

  /* A cloned easy should not retain ownership reference to the original multi. */
  newrbce->multi = Qnil;

  if (rbce->opts != Qnil) {
    newrbce->opts = rb_funcall(rbce->opts, rb_intern("dup"), 0);
  }

  /* Set the error buffer on the new curl handle using the new err_buf */
  curl_easy_setopt(newrbce->curl, CURLOPT_ERRORBUFFER, newrbce->err_buf);

  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.

Returns:

  • (nil) 


446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
 
# File 'ext/curb_easy.c', line 446

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;
}

#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.

Returns:

  • (Fixnum) 


3082
3083
3084
3085
3086
3087
3088
3089
3090
3091
3092
3093
3094
3095
 
# File 'ext/curb_easy.c', line 3082

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);
}

#connect_time ⇒ Float

Retrieve the time, in seconds, it took from the start until the connect to the remote host (or proxy) was completed.

Returns:

  • (Float) 


3210
3211
3212
3213
3214
3215
3216
3217
3218
 
# File 'ext/curb_easy.c', line 3210

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.

Returns:

  • (Fixnum, nil) 


1368
1369
1370
 
# File 'ext/curb_easy.c', line 1368

static VALUE ruby_curl_easy_connect_timeout_get(VALUE self) {
  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).

Returns:

  • (Fixnum, nil) 


1357
1358
1359
 
# File 'ext/curb_easy.c', line 1357

static VALUE ruby_curl_easy_connect_timeout_set(VALUE self, VALUE connect_timeout) {
  CURB_IMMED_SETTER(ruby_curl_easy, connect_timeout, 0);
}

#connect_timeout_ms ⇒ Fixnum?

Obtain the maximum time in milliseconds that you allow the connection to the server to take.

Returns:

  • (Fixnum, nil) 


1394
1395
1396
 
# File 'ext/curb_easy.c', line 1394

static VALUE ruby_curl_easy_connect_timeout_ms_get(VALUE self) {
  CURB_IMMED_GETTER(ruby_curl_easy, connect_timeout_ms, 0);
}

#connect_timeout_ms=(fixnum) ⇒ Fixnum?

Set the maximum time in milliseconds 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).

Returns:

  • (Fixnum, nil) 


1383
1384
1385
 
# File 'ext/curb_easy.c', line 1383

static VALUE ruby_curl_easy_connect_timeout_ms_set(VALUE self, VALUE connect_timeout_ms) {
  CURB_IMMED_SETTER(ruby_curl_easy, connect_timeout_ms, 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.

Returns:

  • (nil) 


3530
3531
3532
3533
3534
3535
3536
3537
3538
3539
3540
3541
3542
 
# File 'ext/curb_easy.c', line 3530

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 path for this Curl::Easy instance (used to load cookies when the cookie engine is enabled).

Returns:

  • (String) 


690
691
692
 
# File 'ext/curb_easy.c', line 690

static VALUE ruby_curl_easy_cookiefile_get(VALUE self) {
  CURB_OBJECT_HGETTER(ruby_curl_easy, cookiefile);
}

#cookiefile=(value) ⇒ Object

call-seq:

easy.cookiefile = 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.

Note: assigning nil has no effect; pass a path string to use a cookie file.



263
264
265
 
# File 'lib/curl/easy.rb', line 263

def cookiefile=(value)
  set :cookiefile, value
end

#cookiejar ⇒ String

Obtain the cookiejar path for this Curl::Easy instance (used to persist cookies when the cookie engine is enabled).

Returns:

  • (String) 


701
702
703
 
# File 'ext/curb_easy.c', line 701

static VALUE ruby_curl_easy_cookiejar_get(VALUE self) {
  CURB_OBJECT_HGETTER(ruby_curl_easy, cookiejar);
}

#cookiejar=(value) ⇒ Object

call-seq:

easy.cookiejar = 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.

Note: assigning nil has no effect; pass a path string to persist cookies to a file.



279
280
281
 
# File 'lib/curl/easy.rb', line 279

def cookiejar=(value)
  set :cookiejar, value
end

#cookielist ⇒ Array<String>, ...

Note:

requires libcurl 7.14.1 or higher, otherwise -1 is always returned

Retrieves the cookies curl knows in an array of strings. Returned strings are in Netscape cookiejar format or in Set-Cookie format. Since 7.43.0 cookies in the Set-Cookie format without a domain name are not exported.

To modify the cookie engine (add/replace/remove), use easy.cookielist= string or easy.set(:cookielist, string) with one of the following accepted inputs:

  • A Set-Cookie style header string: “Set-Cookie: name=value; Domain=example.com; Path=/; Expires=…”

  • One or more lines in Netscape cookie file format (tab-separated fields)

  • Special commands: “ALL” (clear all), “SESS” (remove session cookies), “FLUSH” (write to jar), “RELOAD” (reload from file)

Returns:

  • (Array<String>, nil, -1) —

    array of strings, or nil if there are no cookies, or -1 if the libcurl version is too old

See Also:



3636
3637
3638
3639
3640
3641
3642
3643
3644
3645
3646
3647
3648
3649
3650
3651
3652
3653
3654
3655
3656
3657
 
# File 'ext/curb_easy.c', line 3636

static VALUE ruby_curl_easy_cookielist_get(VALUE self) {
#ifdef HAVE_CURLINFO_COOKIELIST
  ruby_curl_easy *rbce;
  struct curl_slist *cookies;
  struct curl_slist *cookie;
  VALUE rb_cookies;

  Data_Get_Struct(self, ruby_curl_easy, rbce);
  curl_easy_getinfo(rbce->curl, CURLINFO_COOKIELIST, &cookies);
  if (!cookies)
    return Qnil;
  rb_cookies = rb_ary_new();
  for (cookie = cookies; cookie; cookie = cookie->next)
    rb_ary_push(rb_cookies, rb_str_new2(cookie->data));
  curl_slist_free_all(cookies);
  return rb_cookies;

#else
    rb_warn("Installed libcurl is too old to support cookielist");
    return INT2FIX(-1);
#endif
}

#cookielist=(value) ⇒ Object

call-seq:

easy.cookielist = string                         => string

Modify cookies in libcurl’s internal cookie engine (CURLOPT_COOKIELIST). Accepts a Set-Cookie style string, one or more lines in Netscape cookie file format, or one of the special commands: “ALL” (clear), “SESS” (remove session cookies), “FLUSH” (write to jar), “RELOAD” (reload from file).

Examples:

easy.cookielist = "Set-Cookie: session=42; Domain=example.com; Path=/;"
easy.cookielist = [
  ['.example.com', 'TRUE', '/', 'FALSE', 0, 'c1', 'v1'].join("\t"),
  ['.example.com', 'TRUE', '/', 'FALSE', 0, 'c2', 'v2'].join("\t"),
  ''
].join("\n")
easy.cookielist = 'ALL'   # clear all cookies in the engine



301
302
303
 
# File 'lib/curl/easy.rb', line 301

def cookielist=(value)
  set :cookielist, value
end

#cookies ⇒ Object

Obtain the manually set Cookie header string for this Curl::Easy instance.

Notes:

  • This corresponds to libcurl’s CURLOPT_COOKIE and only affects the outgoing Cookie request header. It does NOT modify the internal libcurl cookie engine that stores cookies received via Set-Cookie.

  • To inspect or modify cookies stored in the cookie engine, use easy.cookielist (getter) and easy.cookielist= or easy.set(:cookielist, …) (setter).

  • To clear a previously set manual Cookie header, assign an empty string. Assigning nil currently has no effect.



679
680
681
 
# File 'ext/curb_easy.c', line 679

static VALUE ruby_curl_easy_cookies_get(VALUE self) {
  CURB_OBJECT_HGETTER(ruby_curl_easy, cookies);
}

#cookies=(value) ⇒ Object

call-seq:

easy.cookies = "name1=content1; name2=content2;" => string

Set the manual Cookie request header for 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;”.

Notes:

  • This only affects the outgoing Cookie header (libcurl CURLOPT_COOKIE) and does NOT alter the internal libcurl cookie engine (which stores cookies from Set-Cookie).

  • To change cookies stored in the engine, use #cookielist / #cookielist= or #set with :cookielist.

  • To clear a previously set manual Cookie header, assign an empty string (”). Assigning nil has no effect in current curb versions.



248
249
250
 
# File 'lib/curl/easy.rb', line 248

def cookies=(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.



369
370
371
 
# File 'lib/curl/easy.rb', line 369

def http_delete
  self.http :DELETE
end

#delete=(onoff) ⇒ Object

call-seq:

easy = Curl::Easy.new("url") do|c|
 c.delete = true
end
easy.perform



103
104
105
106
 
# File 'lib/curl/easy.rb', line 103

def delete=(onoff)
  set :customrequest, onoff ? 'DELETE' : nil
  onoff
end

#dns_cache_timeout ⇒ Fixnum?

Obtain the dns cache timeout in seconds.

Returns:

  • (Fixnum, nil) 


1417
1418
1419
 
# File 'ext/curb_easy.c', line 1417

static VALUE ruby_curl_easy_dns_cache_timeout_get(VALUE self) {
  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.

Returns:

  • (Fixnum, nil) 


1407
1408
1409
 
# File 'ext/curb_easy.c', line 1407

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.

Returns:

  • (Float) 


3418
3419
3420
3421
3422
3423
3424
3425
3426
 
# File 'ext/curb_easy.c', line 3418

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.

Returns:

  • (Float) 


3384
3385
3386
3387
3388
3389
3390
3391
3392
 
# File 'ext/curb_easy.c', line 3384

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.

Returns:

  • (Float) 


3495
3496
3497
3498
3499
3500
3501
3502
3503
 
# File 'ext/curb_easy.c', line 3495

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. When enabled, cookies received via Set-Cookie are stored by libcurl and automatically sent on subsequent matching requests. Use easy.cookiefile to load cookies and easy.cookiejar to persist them.

This setting is independent from the manual Cookie header set via easy.cookies. The manual header is additive and can be cleared by assigning an empty string.

Returns:

  • (Boolean) 


1923
1924
1925
1926
 
# File 'ext/curb_easy.c', line 1923

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.

Returns:

  • (Boolean) 


1935
1936
1937
 
# File 'ext/curb_easy.c', line 1935

static VALUE ruby_curl_easy_enable_cookies_q(VALUE self) {
  CURB_BOOLEAN_GETTER(ruby_curl_easy, enable_cookies);
}

#encoding ⇒ String

Get the set encoding types

Returns:

  • (String) 


820
821
822
 
# File 'ext/curb_easy.c', line 820

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

Returns:

  • (String) 


810
811
812
 
# File 'ext/curb_easy.c', line 810

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).



4100
4101
4102
4103
4104
4105
4106
4107
4108
4109
4110
4111
4112
4113
4114
4115
4116
4117
4118
4119
4120
4121
 
# File 'ext/curb_easy.c', line 4100

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.

Returns:

  • (Boolean) 


1690
1691
1692
 
# File 'ext/curb_easy.c', line 1690

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.

Returns:

  • (Boolean) 


1701
1702
1703
 
# File 'ext/curb_easy.c', line 1701

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.

Returns:

  • (Fixnum) 


3154
3155
3156
3157
3158
3159
3160
3161
3162
3163
3164
3165
3166
3167
 
# File 'ext/curb_easy.c', line 3154

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 LONG2NUM(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.



324
325
326
 
# File 'lib/curl/easy.rb', line 324

def follow_location=(onoff)
  set :followlocation, onoff
end

#follow_location? ⇒ Boolean

Determine whether this Curl instance will follow Location: headers in HTTP responses.

Returns:

  • (Boolean) 


1834
1835
1836
 
# File 'ext/curb_easy.c', line 1834

static VALUE ruby_curl_easy_follow_location_q(VALUE self) {
  CURB_BOOLEAN_GETTER(ruby_curl_easy, follow_location);
}

#ftp_commands ⇒ Array?

Returns:

  • (Array, nil) 


1017
1018
1019
 
# File 'ext/curb_easy.c', line 1017

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.

NOTE:

  • This maps to libcurl CURLOPT_QUOTE; it sends commands on the control connection.

  • Do not include data-transfer commands like LIST/NLST/RETR/STOR here. libcurl does not parse PASV/EPSV replies from QUOTE commands and will not establish the required data connection. For directory listings, set CURLOPT_DIRLISTONLY (via ‘easy.set(:dirlistonly, true)`) and request an FTP directory URL (e.g. “host/path/”) so libcurl manages PASV/EPSV and the data connection for you.



1009
1010
1011
 
# File 'ext/curb_easy.c', line 1009

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).

Returns:

  • (nil) 


3678
3679
3680
3681
3682
3683
3684
3685
3686
3687
3688
3689
3690
3691
3692
3693
3694
3695
 
# File 'ext/curb_easy.c', line 3678

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 ftp_entry_path");
  return Qnil;
#endif
}

#ftp_filemethod ⇒ Fixnum

Get the configuration for how libcurl will reach files on the server.

Returns:

  • (Fixnum) 


1657
1658
1659
 
# File 'ext/curb_easy.c', line 1657

static VALUE ruby_curl_easy_ftp_filemethod_get(VALUE self) {
  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).

Returns:

  • (Fixnum, nil) 


1647
1648
1649
 
# File 'ext/curb_easy.c', line 1647

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.

Returns:

  • (Fixnum, nil) 


1444
1445
1446
 
# File 'ext/curb_easy.c', line 1444

static VALUE ruby_curl_easy_ftp_response_timeout_get(VALUE self) {
  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.

Returns:

  • (Fixnum, nil) 


1434
1435
1436
 
# File 'ext/curb_easy.c', line 1434

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.



356
357
358
359
 
# File 'lib/curl/easy.rb', line 356

def http_get
  set :httpget, true
  http :GET
end

#getinfo(opt) ⇒ nil

Note:

This method is not implemented yet.

Iniital access to libcurl curl_easy_getinfo, remember getinfo doesn’t return the same values as setopt

Returns:

  • (nil)

Parameters:

  • code (Fixnum) —

    Constant CURLINFO_* from libcurl

Returns:

  • (nil) 


4063
4064
4065
 
# File 'ext/curb_easy.c', line 4063

static VALUE ruby_curl_easy_get_opt(VALUE self, VALUE opt) {
  return Qnil;
}

#head=(onoff) ⇒ Object

call-seq:

easy = Curl::Easy.new("url") do|c|
 c.head = true
end
easy.perform



312
313
314
 
# File 'lib/curl/easy.rb', line 312

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).

Returns:

  • (Boolean) 


1770
1771
1772
 
# File 'ext/curb_easy.c', line 1770

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.

Returns:

  • (Boolean) 


1781
1782
1783
 
# File 'ext/curb_easy.c', line 1781

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.

Returns:

  • (Fixnum) 


3435
3436
3437
3438
3439
3440
3441
3442
3443
 
# File 'ext/curb_easy.c', line 3435

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 Also known as: head

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.



3044
3045
3046
 
# File 'ext/curb_easy.c', line 3044

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.

Returns:

  • (Hash, Array, Str) 


586
587
588
589
590
591
592
593
 
# File 'ext/curb_easy.c', line 586

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.



572
573
574
 
# File 'ext/curb_easy.c', line 572

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.



2753
2754
2755
2756
2757
2758
2759
2760
2761
2762
2763
2764
2765
 
# File 'ext/curb_easy.c', line 2753

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.

Returns:

  • (Fixnum, nil) 


1209
1210
1211
 
# File 'ext/curb_easy.c', line 1209

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) {



1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
 
# File 'ext/curb_easy.c', line 1168

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;
  long i, len;
  char* node = NULL;
  long mask = 0;

  rb_scan_args(argc, argv, "*", &args_ary);
  Data_Get_Struct(self, ruby_curl_easy, rbce);

  len = RARRAY_LEN(args_ary);

  if (len == 1 && (rb_ary_entry(args_ary,0) == Qnil || TYPE(rb_ary_entry(args_ary,0)) == T_FIXNUM ||
        TYPE(rb_ary_entry(args_ary,0)) == T_BIGNUM)) {
    if (rb_ary_entry(args_ary,0) == Qnil) {
      rbce->http_auth_types = 0;
    }
    else {
      rbce->http_auth_types = NUM2LONG(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 LONG2NUM(rbce->http_auth_types);
}

#http_connect_code ⇒ Fixnum

Retrieve the last received proxy response code to a CONNECT request.

Returns:

  • (Fixnum) 


3127
3128
3129
3130
3131
3132
3133
3134
3135
 
# File 'ext/curb_easy.c', line 3127

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.



366
367
368
 
# File 'lib/curl/easy.rb', line 366

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.



352
353
354
355
 
# File 'lib/curl/easy.rb', line 352

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.



337
338
339
340
341
342
 
# File 'lib/curl/easy.rb', line 337

def http_head
  set :nobody, true
  ret = self.perform
  set :nobody, false
  ret
end

#http_patch("url = encoded%20form%20data;and=so%20on") ⇒ true #http_patch("url = encoded%20form%20data", "and = so%20on", ...) ⇒ true #http_patch("url = encoded%20form%20data", Curl: :PostField, "and = so%20on", ...) ⇒ true #http_patch(Curl: :PostField, Curl: :PostField..., Curl: :PostField) ⇒ true

PATCH 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.

When multipart_form_post is true the multipart logic is used; otherwise, the arguments are joined into a raw PATCH body.

Overloads:

  • #http_patch("url = encoded%20form%20data;and=so%20on") ⇒ true

    Returns:

    • (true)
  • #http_patch("url = encoded%20form%20data", "and = so%20on", ...) ⇒ true

    Returns:

    • (true)
  • #http_patch("url = encoded%20form%20data", Curl: :PostField, "and = so%20on", ...) ⇒ true

    Returns:

    • (true)
  • #http_patch(Curl: :PostField, Curl: :PostField..., Curl: :PostField) ⇒ true

    Returns:

    • (true) 


2875
2876
2877
2878
2879
2880
2881
2882
2883
2884
2885
2886
2887
2888
2889
2890
2891
2892
2893
2894
2895
2896
2897
2898
2899
2900
2901
2902
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916
2917
2918
2919
2920
2921
2922
2923
2924
2925
2926
2927
2928
2929
2930
2931
2932
2933
2934
2935
2936
2937
2938
2939
2940
 
# File 'ext/curb_easy.c', line 2875

static VALUE ruby_curl_easy_perform_patch(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;

  /* Clear the error buffer */
  memset(rbce->err_buf, 0, CURL_ERROR_SIZE);

  /* Set the custom HTTP method to PATCH */
  curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PATCH");

  if (rbce->multipart_form_post) {
    VALUE ret;
    struct curl_httppost *first = NULL, *last = NULL;

    /* Build the multipart form (same logic as for POST) */
    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) {
        long j, argv_len = RARRAY_LEN(argv[i]);
        for (j = 0; j < argv_len; ++j) {
          if (rb_obj_is_instance_of(rb_ary_entry(argv[i], j), cCurlPostField)) {
            append_to_form(rb_ary_entry(argv[i], j), &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;
      }
    }
    /* Disable the POST flag */
    curl_easy_setopt(curl, CURLOPT_POST, 0);
    /* Use the built multipart form as the request body */
    curl_easy_setopt(curl, CURLOPT_HTTPPOST, first);
    ret = rb_funcall(self, rb_intern("perform"), 0);
    curl_formfree(first);
    return ret;
  } else {
    /* Join arguments into a raw PATCH body */
    VALUE patch_body = rb_funcall(args_ary, idJoin, 1, rbstrAmp);
    if (patch_body == Qnil) {
      rb_raise(eCurlErrError, "Failed to join arguments");
      return Qnil;
    } else {
      if (rb_type(patch_body) == T_STRING && RSTRING_LEN(patch_body) > 0) {
        ruby_curl_easy_post_body_set(self, patch_body);
      }
      /* If postdata_buffer is still nil, set it so that the PATCH header is enabled */
      if (rb_easy_nil("postdata_buffer")) {
        ruby_curl_easy_post_body_set(self, patch_body);
      }
      return rb_funcall(self, rb_intern("perform"), 0);
    }
  }
}

#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.

Overloads:

  • #http_post("url = encoded%20form%20data;and=so%20on") ⇒ true

    Returns:

    • (true)
  • #http_post("url = encoded%20form%20data", "and = so%20on", ...) ⇒ true

    Returns:

    • (true)
  • #http_post("url = encoded%20form%20data", Curl: :PostField, "and = so%20on", ...) ⇒ true

    Returns:

    • (true)
  • #http_post(Curl: :PostField, Curl: :PostField..., Curl: :PostField) ⇒ true

    Returns:

    • (true) 


2791
2792
2793
2794
2795
2796
2797
2798
2799
2800
2801
2802
2803
2804
2805
2806
2807
2808
2809
2810
2811
2812
2813
2814
2815
2816
2817
2818
2819
2820
2821
2822
2823
2824
2825
2826
2827
2828
2829
2830
2831
2832
2833
2834
2835
2836
2837
2838
2839
2840
2841
2842
2843
2844
2845
2846
2847
2848
2849
2850
2851
2852
2853
2854
2855
2856
2857
2858
 
# File 'ext/curb_easy.c', line 2791

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;

  memset(rbce->err_buf, 0, CURL_ERROR_SIZE);

  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
        long c = 0, argv_len = 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.

Returns:

  • (true) 


2950
2951
2952
2953
2954
2955
2956
2957
2958
2959
2960
2961
2962
2963
2964
2965
2966
2967
2968
2969
2970
2971
2972
2973
2974
2975
2976
2977
2978
2979
2980
2981
2982
2983
2984
2985
2986
2987
2988
2989
2990
2991
2992
2993
2994
2995
2996
2997
2998
2999
3000
3001
3002
3003
3004
3005
3006
3007
3008
3009
3010
3011
3012
3013
3014
3015
 
# File 'ext/curb_easy.c', line 2950

static VALUE ruby_curl_easy_perform_put(int argc, VALUE *argv, VALUE self) {
  ruby_curl_easy *rbce;
  CURL *curl;
  VALUE args_ary;
  int i;

  rb_scan_args(argc, argv, "*", &args_ary);
  Data_Get_Struct(self, ruby_curl_easy, rbce);
  curl = rbce->curl;

  memset(rbce->err_buf, 0, CURL_ERROR_SIZE);
  curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");

  /* New: if no arguments were provided, treat as an empty PUT */
  if (RARRAY_LEN(args_ary) == 0) {
    /* Option 1: explicitly set an empty body */
    ruby_curl_easy_put_data_set(self, rb_str_new2(""));
  }
  /* If a single argument is given and it is a String or responds to read, use legacy behavior */
  else if (RARRAY_LEN(args_ary) == 1 &&
           (rb_type(rb_ary_entry(args_ary, 0)) == T_STRING ||
            rb_respond_to(rb_ary_entry(args_ary, 0), rb_intern("read")))) {
    ruby_curl_easy_put_data_set(self, rb_ary_entry(args_ary, 0));
  }
  /* Otherwise, if multipart_form_post is true, use multipart logic */
  else if (rbce->multipart_form_post) {
    VALUE ret;
    struct curl_httppost *first = NULL, *last = NULL;
    for (i = 0; i < RARRAY_LEN(args_ary); i++) {
      VALUE field = rb_ary_entry(args_ary, i);
      if (rb_obj_is_instance_of(field, cCurlPostField)) {
        append_to_form(field, &first, &last);
      } else if (rb_type(field) == T_ARRAY) {
        long j;
        for (j = 0; j < RARRAY_LEN(field); j++) {
          VALUE subfield = rb_ary_entry(field, j);
          if (rb_obj_is_instance_of(subfield, cCurlPostField)) {
            append_to_form(subfield, &first, &last);
          } else {
            rb_raise(eCurlErrInvalidPostField,
                     "You must use PostFields only with multipart form posts");
          }
        }
      } else {
        rb_raise(eCurlErrInvalidPostField,
                 "You must use PostFields only with multipart form posts");
      }
    }
    curl_easy_setopt(curl, CURLOPT_POST, 0);
    curl_easy_setopt(curl, CURLOPT_HTTPPOST, first);
    /* Set the method explicitly to PUT */
    curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
    ret = rb_funcall(self, rb_intern("perform"), 0);
    curl_formfree(first);
    return ret;
  }
  /* Fallback: join all arguments */
  else {
    VALUE post_body = rb_funcall(args_ary, idJoin, 1, rbstrAmp);
    if (post_body != Qnil && rb_type(post_body) == T_STRING &&
        RSTRING_LEN(post_body) > 0) {
      ruby_curl_easy_put_data_set(self, post_body);
    }
  }
  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.



1946
1947
1948
1949
 
# File 'ext/curb_easy.c', line 1946

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.

Returns:

  • (Boolean) 


1958
1959
1960
 
# File 'ext/curb_easy.c', line 1958

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/>"

Returns:



4071
4072
4073
4074
4075
4076
4077
4078
4079
4080
4081
4082
4083
4084
4085
4086
 
# File 'ext/curb_easy.c', line 4071

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.

Returns:

  • (String) 


637
638
639
 
# File 'ext/curb_easy.c', line 637

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.



204
205
206
 
# File 'lib/curl/easy.rb', line 204

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.

Returns:

  • (nil) 


3059
3060
3061
3062
3063
3064
3065
3066
3067
3068
3069
3070
3071
 
# File 'ext/curb_easy.c', line 3059

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_error ⇒ "Error details"?

Returns:



3732
3733
3734
3735
3736
3737
3738
3739
3740
3741
 
# File 'ext/curb_easy.c', line 3732

static VALUE ruby_curl_easy_last_error(VALUE self) {
  ruby_curl_easy *rbce;
  Data_Get_Struct(self, ruby_curl_easy, rbce);

  if (rbce->err_buf[0]) {    // curl returns NULL or empty string if none
    return rb_str_new2(rbce->err_buf);
  } else {
    return Qnil;
  }
}

#last_result ⇒ 0

Returns:

  • (0) 


3722
3723
3724
3725
3726
 
# File 'ext/curb_easy.c', line 3722

static VALUE ruby_curl_easy_last_result(VALUE self) {
  ruby_curl_easy *rbce;
  Data_Get_Struct(self, ruby_curl_easy, rbce);
  return LONG2NUM(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.

Returns:

  • (Fixnum, nil) 


1065
1066
1067
 
# File 'ext/curb_easy.c', line 1065

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.

Returns:

  • (Fixnum, nil) 


1053
1054
1055
 
# File 'ext/curb_easy.c', line 1053

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.

Returns:

  • (Fixnum, nil) 


1096
1097
1098
 
# File 'ext/curb_easy.c', line 1096

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.

Returns:

  • (Fixnum, nil) 


1083
1084
1085
 
# File 'ext/curb_easy.c', line 1083

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.

Returns:

  • (Fixnum, nil) 


1467
1468
1469
 
# File 'ext/curb_easy.c', line 1467

static VALUE ruby_curl_easy_low_speed_limit_get(VALUE self) {
  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.

Returns:

  • (Fixnum, nil) 


1456
1457
1458
 
# File 'ext/curb_easy.c', line 1456

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.

Returns:

  • (Fixnum, nil) 


1489
1490
1491
 
# File 'ext/curb_easy.c', line 1489

static VALUE ruby_curl_easy_low_speed_time_get(VALUE self) {
  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.

Returns:

  • (Fixnum, nil) 


1478
1479
1480
 
# File 'ext/curb_easy.c', line 1478

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_recv_speed_large=(fixnum) ⇒ Fixnum?

Get the maximal receiving transfer speed (in bytes per second)

Returns:

  • (Fixnum, nil) 


1529
1530
1531
 
# File 'ext/curb_easy.c', line 1529

static VALUE ruby_curl_easy_max_recv_speed_large_get(VALUE self) {
  CURB_IMMED_GETTER(ruby_curl_easy, max_recv_speed_large, 0);
}

#max_recv_speed_large=(fixnum) ⇒ Fixnum?

Set the maximal receiving transfer speed (in bytes per second)

Returns:

  • (Fixnum, nil) 


1519
1520
1521
 
# File 'ext/curb_easy.c', line 1519

static VALUE ruby_curl_easy_max_recv_speed_large_set(VALUE self, VALUE max_recv_speed_large) {
  CURB_IMMED_SETTER(ruby_curl_easy, max_recv_speed_large, 0);
}

#max_redirects ⇒ Fixnum?

Obtain the maximum number of redirections to follow in the following perform calls.

Returns:

  • (Fixnum, nil) 


1258
1259
1260
 
# File 'ext/curb_easy.c', line 1258

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.

Returns:

  • (Fixnum, nil) 


1247
1248
1249
 
# File 'ext/curb_easy.c', line 1247

static VALUE ruby_curl_easy_max_redirects_set(VALUE self, VALUE max_redirs) {
  CURB_IMMED_SETTER(ruby_curl_easy, max_redirs, -1);
}

#max_send_speed_large=(fixnum) ⇒ Fixnum?

Get the maximal sending transfer speed (in bytes per second)

Returns:

  • (Fixnum, nil) 


1509
1510
1511
 
# File 'ext/curb_easy.c', line 1509

static VALUE ruby_curl_easy_max_send_speed_large_get(VALUE self) {
  CURB_IMMED_GETTER(ruby_curl_easy, max_send_speed_large, 0);
}

#max_send_speed_large=(fixnum) ⇒ Fixnum?

Set the maximal sending transfer speed (in bytes per second)

Returns:

  • (Fixnum, nil) 


1499
1500
1501
 
# File 'ext/curb_easy.c', line 1499

static VALUE ruby_curl_easy_max_send_speed_large_set(VALUE self, VALUE max_send_speed_large) {
  CURB_IMMED_SETTER(ruby_curl_easy, max_send_speed_large, 0);
}

#multi ⇒ "#<Curl::Multi>"

Returns:



3701
3702
3703
3704
3705
 
# File 'ext/curb_easy.c', line 3701

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>"

Returns:



3711
3712
3713
3714
3715
3716
 
# File 'ext/curb_easy.c', line 3711

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.

Returns:

  • (Boolean) 


1895
1896
1897
1898
 
# File 'ext/curb_easy.c', line 1895

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.

Returns:

  • (Boolean) 


1907
1908
1909
 
# File 'ext/curb_easy.c', line 1907

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.

Returns:

  • (Float) 


3193
3194
3195
3196
3197
3198
3199
3200
3201
 
# File 'ext/curb_easy.c', line 3193

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 



549
 
# File 'lib/curl/easy.rb', line 549

alias_method :native_cert=, :cert=

#nosignal=(onoff) ⇒ Object

call-seq:

easy = Curl::Easy.new easy.nosignal = true



92
93
94
 
# File 'lib/curl/easy.rb', line 92

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).

Returns:

  • (Integer) 


3601
3602
3603
3604
3605
3606
3607
3608
3609
3610
3611
3612
3613
3614
 
# File 'ext/curb_easy.c', line 3601

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 LONG2NUM(-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.

Yields:

  • (body_data) 


2042
2043
2044
 
# File 'ext/curb_easy.c', line 2042

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.

Yields:

  • (easy) 


2116
2117
2118
 
# File 'ext/curb_easy.c', line 2116

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.

Yields:

  • (type, data) 


2174
2175
2176
 
# File 'ext/curb_easy.c', line 2174

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

Yields:



2072
2073
2074
 
# File 'ext/curb_easy.c', line 2072

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.

Yields:

  • (header_data) 


2132
2133
2134
 
# File 'ext/curb_easy.c', line 2132

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

Yields:



2087
2088
2089
 
# File 'ext/curb_easy.c', line 2087

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.

Yields:

  • (dl_total, dl_now, ul_total, ul_now) 


2153
2154
2155
 
# File 'ext/curb_easy.c', line 2153

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

Yields:



2102
2103
2104
 
# File 'ext/curb_easy.c', line 2102

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

Yields:

  • (easy) 


2057
2058
2059
 
# File 'ext/curb_easy.c', line 2057

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).

Returns:

  • (Integer) 


3572
3573
3574
3575
3576
3577
3578
3579
3580
3581
3582
3583
3584
3585
 
# File 'ext/curb_easy.c', line 3572

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 LONG2NUM(0);
#endif
}

#password ⇒ String

Get the current password

Returns:

  • (String) 


1581
1582
1583
1584
1585
1586
1587
 
# File 'ext/curb_easy.c', line 1581

static VALUE ruby_curl_easy_password_get(VALUE self) {
#if HAVE_CURLOPT_PASSWORD
  CURB_OBJECT_HGETTER(ruby_curl_easy, password);
#else
  return Qnil;
#endif
}

#password=(string) ⇒ String

Set the HTTP Authentication password.

Returns:

  • (String) 


1567
1568
1569
1570
1571
1572
1573
 
# File 'ext/curb_easy.c', line 1567

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.



66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/curl/easy.rb', line 66

def perform
  self.multi = Curl::Multi.new if self.multi.nil?
  self.multi.add self
  ret = self.multi.perform
  self.multi.remove self

  if Curl::Multi.autoclose
    self.multi.close
    self.multi = nil
  end

  if self.last_result != 0 && self.on_failure.nil?
    (err_class, err_summary) = Curl::Easy.error(self.last_result)
    err_detail = self.last_error
    raise err_class.new([err_summary, err_detail].compact.join(": "))
  end

  ret
end

#post ⇒ Object 



5
 
# File 'lib/curl/easy.rb', line 5

alias post http_post

#post_body ⇒ String?

Obtain the POST body used in this Curl::Easy instance.

Returns:

  • (String, nil) 


905
906
907
 
# File 'ext/curb_easy.c', line 905

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.



855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
 
# File 'ext/curb_easy.c', line 855

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 ) {
    rb_easy_del("postdata_buffer");
    curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);

  } 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.

Returns:

  • (Float) 


3252
3253
3254
3255
3256
3257
3258
3259
3260
 
# File 'ext/curb_easy.c', line 3252

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

Returns:

  • (nil) 


3106
3107
3108
3109
3110
3111
3112
3113
3114
3115
3116
3117
3118
 
# File 'ext/curb_easy.c', line 3106

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.

Returns:

  • (Fixnum, nil) 


1232
1233
1234
 
# File 'ext/curb_easy.c', line 1232

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.

Returns:

  • (Fixnum, nil) 


1221
1222
1223
 
# File 'ext/curb_easy.c', line 1221

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_headers ⇒ Hash, ...

Obtain the custom HTTP proxy_headers for following requests.

Returns:

  • (Hash, Array, Str) 


621
622
623
624
625
626
627
628
 
# File 'ext/curb_easy.c', line 621

static VALUE ruby_curl_easy_proxy_headers_get(VALUE self) {
  ruby_curl_easy *rbce;
  VALUE proxy_headers;
  Data_Get_Struct(self, ruby_curl_easy, rbce);
  proxy_headers = rb_easy_get("proxy_headers");//rb_hash_aref(rbce->opts, rb_intern("proxy_headers"));
  if (proxy_headers == Qnil) { proxy_headers = rb_easy_set("proxy_headers", rb_hash_new()); }
  return proxy_headers;
}

#proxy_headers=(proxy_headers) ⇒ Object 



576
577
578
 
# File 'ext/curb_easy.c', line 576

static VALUE ruby_curl_easy_proxy_headers_set(VALUE self, VALUE proxy_headers) {
  CURB_OBJECT_HSETTER(ruby_curl_easy, proxy_headers);
}

#proxy_port ⇒ Fixnum?

Obtain the proxy port that will be used for the following perform calls.

Returns:

  • (Fixnum, nil) 


1116
1117
1118
 
# File 'ext/curb_easy.c', line 1116

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.

Returns:

  • (Fixnum, nil) 


1106
1107
1108
 
# File 'ext/curb_easy.c', line 1106

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.

Returns:

  • (Boolean) 


1669
1670
1671
 
# File 'ext/curb_easy.c', line 1669

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.

Returns:

  • (Boolean) 


1679
1680
1681
 
# File 'ext/curb_easy.c', line 1679

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.

Returns:

  • (Fixnum, nil) 


1137
1138
1139
 
# File 'ext/curb_easy.c', line 1137

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.

Returns:

  • (Fixnum, nil) 


1127
1128
1129
 
# File 'ext/curb_easy.c', line 1127

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.

Returns:

  • (String) 


546
547
548
 
# File 'ext/curb_easy.c', line 546

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.



157
158
159
 
# File 'lib/curl/easy.rb', line 157

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”

Returns:

  • (String) 


660
661
662
 
# File 'ext/curb_easy.c', line 660

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”



227
228
229
 
# File 'lib/curl/easy.rb', line 227

def proxypwd=(value)
  set :proxyuserpwd, value
end

#put ⇒ Object 



6
 
# File 'lib/curl/easy.rb', line 6

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.



917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
 
# File 'ext/curb_easy.c', line 917

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);
#if HAVE_CURLOPT_SEEKFUNCTION
  curl_easy_setopt(curl, CURLOPT_SEEKFUNCTION, (curl_seek_callback)seek_data_handler);
#endif
  curl_easy_setopt(curl, CURLOPT_READDATA, rbce);
#if HAVE_CURLOPT_SEEKDATA
  curl_easy_setopt(curl, CURLOPT_SEEKDATA, rbce);
#endif

  /*
   * 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, NUM2LONG(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, NUM2LONG(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.

Returns:

  • (Integer) 


3314
3315
3316
3317
3318
3319
3320
3321
3322
3323
3324
3325
3326
3327
3328
 
# File 'ext/curb_easy.c', line 3314

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 LONG2NUM(-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.

Returns:

  • (Float) 


3291
3292
3293
3294
3295
3296
3297
3298
3299
3300
3301
3302
3303
3304
 
# File 'ext/curb_easy.c', line 3291

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.

Returns:

  • (nil) 


3339
3340
3341
3342
3343
3344
3345
3346
3347
3348
3349
3350
3351
3352
3353
3354
3355
3356
 
# File 'ext/curb_easy.c', line 3339

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 LONG2NUM(-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.

Returns:

  • (Fixnum) 


3453
3454
3455
3456
3457
3458
3459
3460
3461
 
# File 'ext/curb_easy.c', line 3453

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);
}

#request_target=(value) ⇒ Object

call-seq:

easy.request_target = string                    => string

Set the request-target used in the HTTP request line (libcurl CURLOPT_REQUEST_TARGET). Useful for absolute-form request targets (e.g., when speaking to proxies) or special targets like “*” (OPTIONS *). Requires libcurl with CURLOPT_REQUEST_TARGET support.



169
170
171
172
173
174
175
 
# File 'lib/curl/easy.rb', line 169

def request_target=(value)
  if Curl.const_defined?(:CURLOPT_REQUEST_TARGET)
    set :request_target, value
  else
    raise NotImplementedError, "CURLOPT_REQUEST_TARGET is not supported by this libcurl"
  end
end

#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.

Returns:

  • (Hash) 


489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
 
# File 'ext/curb_easy.c', line 489

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);

  curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, &rbce->err_buf);

  /* reset 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;
  }

  /* Free everything up */
  if (rbce->curl_proxy_headers) {
    curl_slist_free_all(rbce->curl_proxy_headers);
    rbce->curl_proxy_headers = NULL;
  }

  return opts_dup;
}

#resolve ⇒ Array?

Returns:

  • (Array, nil) 


1036
1037
1038
 
# File 'ext/curb_easy.c', line 1036

static VALUE ruby_curl_easy_resolve_get(VALUE self) {
  CURB_OBJECT_HGETTER(ruby_curl_easy, resolve);
}

#resolve=(resolve) ⇒ Object

Set the resolve list to statically resolve hostnames to IP addresses, bypassing DNS for matching hostname/port combinations.



1028
1029
1030
 
# File 'ext/curb_easy.c', line 1028

static VALUE ruby_curl_easy_resolve_set(VALUE self, VALUE resolve) {
  CURB_OBJECT_HSETTER(ruby_curl_easy, resolve);
}

#resolve_mode ⇒ Object

Determines what type of IP address this Curl::Easy instance resolves DNS names to.



1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
 
# File 'ext/curb_easy.c', line 1969

static VALUE ruby_curl_easy_resolve_mode(VALUE self) {
  ruby_curl_easy *rbce;
  unsigned short rm;
  Data_Get_Struct(self, ruby_curl_easy, rbce);

  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



1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
 
# File 'ext/curb_easy.c', line 1997

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;
    ID resolve_mode_id;
    Data_Get_Struct(self, ruby_curl_easy, rbce);

    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.

Returns:

  • (Fixnum) 


3082
3083
3084
3085
3086
3087
3088
3089
3090
3091
3092
3093
3094
3095
 
# File 'ext/curb_easy.c', line 3082

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



34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/curl/easy.rb', line 34

def set(opt,val)
  if opt.is_a?(Symbol)
    option = sym2curl(opt)
  else
    option = opt.to_i
  end

  begin
    setopt(option, val)
  rescue TypeError
    raise TypeError, "Curb doesn't support setting #{opt} [##{option}] option"
  end
end

#setopt(opt, val) ⇒ Object

Note:

Some options - like url or cookie - aren’t set directly throught curl_easy_setopt, but stored in the Ruby object state.

Note:

When curl_easy_setopt is called, return value is not checked here.

Initial access to libcurl curl_easy_setopt

Parameters:

  • opt (Fixnum) —

    The option to set, see Curl::CURLOPT_* constants

  • val (Object)

Returns:

  • (Object) —

    val

Raises:

  • (TypeError) —

    if the option is not supported



3756
3757
3758
3759
3760
3761
3762
3763
3764
3765
3766
3767
3768
3769
3770
3771
3772
3773
3774
3775
3776
3777
3778
3779
3780
3781
3782
3783
3784
3785
3786
3787
3788
3789
3790
3791
3792
3793
3794
3795
3796
3797
3798
3799
3800
3801
3802
3803
3804
3805
3806
3807
3808
3809
3810
3811
3812
3813
3814
3815
3816
3817
3818
3819
3820
3821
3822
3823
3824
3825
3826
3827
3828
3829
3830
3831
3832
3833
3834
3835
3836
3837
3838
3839
3840
3841
3842
3843
3844
3845
3846
3847
3848
3849
3850
3851
3852
3853
3854
3855
3856
3857
3858
3859
3860
3861
3862
3863
3864
3865
3866
3867
3868
3869
3870
3871
3872
3873
3874
3875
3876
3877
3878
3879
3880
3881
3882
3883
3884
3885
3886
3887
3888
3889
3890
3891
3892
3893
3894
3895
3896
3897
3898
3899
3900
3901
3902
3903
3904
3905
3906
3907
3908
3909
3910
3911
3912
3913
3914
3915
3916
3917
3918
3919
3920
3921
3922
3923
3924
3925
3926
3927
3928
3929
3930
3931
3932
3933
3934
3935
3936
3937
3938
3939
3940
3941
3942
3943
3944
3945
3946
3947
3948
3949
3950
3951
3952
3953
3954
3955
3956
3957
3958
3959
3960
3961
3962
3963
3964
3965
3966
3967
3968
3969
3970
3971
3972
3973
3974
3975
3976
3977
3978
3979
3980
3981
3982
3983
3984
3985
3986
3987
3988
3989
3990
3991
3992
3993
3994
3995
3996
3997
3998
3999
4000
4001
4002
4003
4004
4005
4006
4007
4008
4009
4010
4011
4012
4013
4014
4015
4016
4017
4018
4019
4020
4021
4022
4023
4024
4025
4026
4027
4028
4029
4030
4031
4032
4033
4034
4035
4036
4037
4038
4039
4040
4041
4042
4043
4044
4045
4046
4047
4048
4049
4050
4051
 
# File 'ext/curb_easy.c', line 3756

static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
  ruby_curl_easy *rbce;
  long option = NUM2LONG(opt);
  rb_io_t *open_f_ptr;

  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, NUM2LONG(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:
#if HAVE_CURLOPT_PATH_AS_IS
  case CURLOPT_PATH_AS_IS:
#endif
#if HAVE_CURLOPT_PIPEWAIT
  case CURLOPT_PIPEWAIT:
#endif
  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, NUM2LONG(value));
    } break;
  case CURLOPT_POST: {
    curl_easy_setopt(rbce->curl, CURLOPT_POST, rb_type(val) == T_TRUE);
  } break;
  case CURLOPT_MAXCONNECTS: {
    curl_easy_setopt(rbce->curl, CURLOPT_MAXCONNECTS, NUM2LONG(val));
  } break;
  case CURLOPT_POSTFIELDS: {
    curl_easy_setopt(rbce->curl, CURLOPT_POSTFIELDS, NIL_P(val) ? NULL : StringValueCStr(val));
  } 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;
#if HAVE_CURLOPT_NOPROXY
  case CURLOPT_NOPROXY: {
    VALUE noproxy = val;
    CURB_OBJECT_HSETTER(ruby_curl_easy, noproxy);
    } break;
#endif
  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;
#if HAVE_CURLOPT_REQUEST_TARGET
  case CURLOPT_REQUEST_TARGET: {
    /* Forward request-target directly to libcurl as a string. */
    curl_easy_setopt(rbce->curl, CURLOPT_REQUEST_TARGET, NIL_P(val) ? NULL : StringValueCStr(val));
    } break;
#endif
  case CURLOPT_TCP_NODELAY: {
    curl_easy_setopt(rbce->curl, CURLOPT_TCP_NODELAY, NUM2LONG(val));
    } break;
  /* FTP-specific toggles */
#if HAVE_CURLOPT_DIRLISTONLY
  case CURLOPT_DIRLISTONLY: {
    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, CURLOPT_DIRLISTONLY, NUM2LONG(value));
    } break;
#endif
#if HAVE_CURLOPT_FTP_USE_EPSV
  case CURLOPT_FTP_USE_EPSV: {
    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, CURLOPT_FTP_USE_EPSV, NUM2LONG(value));
    } break;
#endif
#if HAVE_CURLOPT_FTP_USE_EPRT
  case CURLOPT_FTP_USE_EPRT: {
    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, CURLOPT_FTP_USE_EPRT, NUM2LONG(value));
    } break;
#endif
#if HAVE_CURLOPT_FTP_SKIP_PASV_IP
  case CURLOPT_FTP_SKIP_PASV_IP: {
    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, CURLOPT_FTP_SKIP_PASV_IP, NUM2LONG(value));
    } break;
#endif
  case CURLOPT_RANGE: {
    curl_easy_setopt(rbce->curl, CURLOPT_RANGE, StringValueCStr(val));
    } break;
  case CURLOPT_RESUME_FROM: {
    curl_easy_setopt(rbce->curl, CURLOPT_RESUME_FROM, NUM2LONG(val));
    } break;
  case CURLOPT_FAILONERROR: {
    curl_easy_setopt(rbce->curl, CURLOPT_FAILONERROR, NUM2LONG(val));
    } break;
  case CURLOPT_SSL_CIPHER_LIST: {
    curl_easy_setopt(rbce->curl, CURLOPT_SSL_CIPHER_LIST, StringValueCStr(val));
    } break;
  case CURLOPT_FORBID_REUSE: {
    curl_easy_setopt(rbce->curl, CURLOPT_FORBID_REUSE, NUM2LONG(val));
    } break;
#if HAVE_CURLOPT_GSSAPI_DELEGATION
  case CURLOPT_GSSAPI_DELEGATION: {
    curl_easy_setopt(rbce->curl, CURLOPT_GSSAPI_DELEGATION, NUM2LONG(val));
    } break;
#endif
#if HAVE_CURLOPT_UNIX_SOCKET_PATH
  case CURLOPT_UNIX_SOCKET_PATH: {
	curl_easy_setopt(rbce->curl, CURLOPT_UNIX_SOCKET_PATH, StringValueCStr(val));
    } break;
#endif
#if HAVE_CURLOPT_MAX_SEND_SPEED_LARGE
  case CURLOPT_MAX_SEND_SPEED_LARGE: {
    curl_easy_setopt(rbce->curl, CURLOPT_MAX_SEND_SPEED_LARGE, (curl_off_t) NUM2LL(val));
    } break;
#endif
#if HAVE_CURLOPT_MAX_RECV_SPEED_LARGE
  case CURLOPT_MAX_RECV_SPEED_LARGE: {
    curl_easy_setopt(rbce->curl, CURLOPT_MAX_RECV_SPEED_LARGE, (curl_off_t) NUM2LL(val));
    } break;
#endif
#if HAVE_CURLOPT_MAXFILESIZE
  case CURLOPT_MAXFILESIZE:
    curl_easy_setopt(rbce->curl, CURLOPT_MAXFILESIZE, NUM2LONG(val));
    break;
#endif
#if HAVE_CURLOPT_TCP_KEEPALIVE
  case CURLOPT_TCP_KEEPALIVE:
    curl_easy_setopt(rbce->curl, CURLOPT_TCP_KEEPALIVE, NUM2LONG(val));
    break;
  case CURLOPT_TCP_KEEPIDLE:
    curl_easy_setopt(rbce->curl, CURLOPT_TCP_KEEPIDLE, NUM2LONG(val));
    break;
  case CURLOPT_TCP_KEEPINTVL:
    curl_easy_setopt(rbce->curl, CURLOPT_TCP_KEEPINTVL, NUM2LONG(val));
    break;
#endif
#if HAVE_CURLOPT_HAPROXYPROTOCOL
  case CURLOPT_HAPROXYPROTOCOL:
    curl_easy_setopt(rbce->curl, CURLOPT_HAPROXYPROTOCOL, NUM2LONG(val));
    break;
#endif
  case CURLOPT_STDERR:
    // libcurl requires raw FILE pointer and this should be IO object in Ruby.
    // Tempfile or StringIO won't work.
    Check_Type(val, T_FILE);
    GetOpenFile(val, open_f_ptr);
    curl_easy_setopt(rbce->curl, CURLOPT_STDERR, rb_io_stdio_file(open_f_ptr));
    /* Retain a Ruby reference to the IO to prevent GC/finalization
     * while libcurl still holds and writes to the underlying FILE*. */
    rb_easy_set("stderr_io", val);
    break;
  case CURLOPT_PROTOCOLS:
  case CURLOPT_REDIR_PROTOCOLS:
    curl_easy_setopt(rbce->curl, option, NUM2LONG(val));
    break;
#if HAVE_CURLOPT_SSL_SESSIONID_CACHE
  case CURLOPT_SSL_SESSIONID_CACHE:
    curl_easy_setopt(rbce->curl, CURLOPT_SSL_SESSIONID_CACHE, NUM2LONG(val));
    break;
#endif
#if HAVE_CURLOPT_COOKIELIST
  case CURLOPT_COOKIELIST: {
	/* Forward to libcurl */
	curl_easy_setopt(rbce->curl, CURLOPT_COOKIELIST, StringValueCStr(val));
	/* Track whether the cookie engine should be enabled for requests.
	 * According to libcurl docs, CURLOPT_COOKIELIST also enables the cookie engine
	 * when provided with a non-command string. Some environments may still require
	 * an explicit "enable" via CURLOPT_COOKIEFILE="" to send cookies on requests.
	 * We do that in the perform setup when this flag is set.
	 */
	if (RB_TYPE_P(val, T_STRING)) {
	  const char *s = StringValueCStr(val);
	  if (!(strcmp(s, "ALL") == 0 || strcmp(s, "SESS") == 0 || strcmp(s, "FLUSH") == 0 || strcmp(s, "RELOAD") == 0)) {
	    rbce->cookielist_engine_enabled = 1;
	  }
	} else {
	  /* Non-string values are unexpected; be conservative and do not enable. */
	}
  } break;
#endif
#if HAVE_CURLOPT_PROXY_SSL_VERIFYHOST
  case CURLOPT_PROXY_SSL_VERIFYHOST:
    curl_easy_setopt(rbce->curl, CURLOPT_PROXY_SSL_VERIFYHOST, NUM2LONG(val));
    break;
#endif
#if HAVE_CURLOPT_RESOLVE
  case CURLOPT_RESOLVE: {
    struct curl_slist *list = NULL;
    if (NIL_P(val)) {
      /* When nil is passed, we clear any previous resolve list */
      list = NULL;
    } else if (TYPE(val) == T_ARRAY) {
      long i, len = RARRAY_LEN(val);
      for (i = 0; i < len; i++) {
        VALUE item = rb_ary_entry(val, i);
        struct curl_slist *new_list = curl_slist_append(list, StringValueCStr(item));
        if (!new_list) {
          curl_slist_free_all(list);
          rb_raise(rb_eNoMemError, "Failed to append to resolve list");
        }
        list = new_list;
      }
    } else {
      /* If a single string is passed, use it directly */
      list = curl_slist_append(NULL, StringValueCStr(val));
      if (!list) {
        rb_raise(rb_eNoMemError, "Failed to create resolve list");
      }
    }
    /* Save the list pointer in the ruby_curl_easy structure for cleanup later */
    rbce->curl_resolve = list;
    curl_easy_setopt(rbce->curl, CURLOPT_RESOLVE, list);
  } break;
#endif
  default:
    rb_raise(rb_eTypeError, "Curb unsupported option");
  }

  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.

Returns:

  • (Numeric) 


1758
1759
1760
 
# File 'ext/curb_easy.c', line 1758

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 



177
178
179
180
181
 
# File 'lib/curl/easy.rb', line 177

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.

Returns:

  • (Boolean) 


193
194
195
 
# File 'lib/curl/easy.rb', line 193

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? .



1747
1748
1749
 
# File 'ext/curb_easy.c', line 1747

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.

Returns:

  • (Boolean) 


1719
1720
1721
 
# File 'ext/curb_easy.c', line 1719

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.

Returns:

  • (Boolean) 


1730
1731
1732
 
# File 'ext/curb_easy.c', line 1730

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).

Returns:

  • (Integer) 


3470
3471
3472
3473
3474
3475
3476
3477
3478
 
# File 'ext/curb_easy.c', line 3470

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.

Returns:

  • (Fixnum) 


1615
1616
1617
 
# File 'ext/curb_easy.c', line 1615

static VALUE ruby_curl_easy_ssl_version_get(VALUE self) {
  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_DEFAULT
Curl::CURL_SSLVERSION_TLSv1 (TLS 1.x)
Curl::CURL_SSLVERSION_SSLv2
Curl::CURL_SSLVERSION_SSLv3
Curl::CURL_SSLVERSION_TLSv1_0
Curl::CURL_SSLVERSION_TLSv1_1
Curl::CURL_SSLVERSION_TLSv1_2
Curl::CURL_SSLVERSION_TLSv1_3

Returns:

  • (Fixnum, nil) 


1605
1606
1607
 
# File 'ext/curb_easy.c', line 1605

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.

Returns:

  • (Float) 


3270
3271
3272
3273
3274
3275
3276
3277
3278
 
# File 'ext/curb_easy.c', line 3270

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



22
23
24
25
26
 
# File 'lib/curl/easy.rb', line 22

def status
  # Matches the last HTTP Status - following the HTTP protocol specification 'Status-Line = HTTP-Version SP Status-Code SP (Opt:)Reason-Phrase CRLF'
  statuses = self.header_str.to_s.scan(/HTTP\/\d(\.\d)?\s(\d+\s.*)\r\n/).map {|match| match[1] }
  statuses.last.strip if statuses.length > 0
end

#sym2curl(opt) ⇒ Object

call-seq:

 easy.sym2curl :symbol => Fixnum

translates ruby symbols to libcurl options



54
55
56
 
# File 'lib/curl/easy.rb', line 54

def sym2curl(opt)
  Curl.const_get("CURLOPT_#{opt.to_s.upcase}")
end

#timeout ⇒ Numeric

Obtain the maximum time in seconds that you allow the libcurl transfer operation to take.

Uses timeout_ms internally instead of timeout.

Returns:

  • (Numeric) 


1302
1303
1304
1305
1306
 
# File 'ext/curb_easy.c', line 1302

static VALUE ruby_curl_easy_timeout_get(VALUE self) {
  ruby_curl_easy *rbce;
  Data_Get_Struct(self, ruby_curl_easy, rbce);
  return DBL2NUM(rbce->timeout_ms / 1000.0);
}

#timeout=(float) ⇒ Numeric

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).

Uses timeout_ms internally instead of timeout because it allows for better precision and libcurl will use the last set value when both timeout and timeout_ms are set.

Returns:

  • (Numeric) 


1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
 
# File 'ext/curb_easy.c', line 1279

static VALUE ruby_curl_easy_timeout_set(VALUE self, VALUE timeout_s) {
  ruby_curl_easy *rbce;
  Data_Get_Struct(self, ruby_curl_easy, rbce);

  if (Qnil == timeout_s || NUM2DBL(timeout_s) <= 0.0) {
    rbce->timeout_ms = 0;
  } else {
    rbce->timeout_ms = (unsigned long)(NUM2DBL(timeout_s) * 1000);
  }

  return DBL2NUM(rbce->timeout_ms / 1000.0);
}

#timeout_ms ⇒ Fixnum?

Obtain the maximum time in milliseconds that you allow the libcurl transfer operation to take.

Returns:

  • (Fixnum, nil) 


1340
1341
1342
1343
1344
 
# File 'ext/curb_easy.c', line 1340

static VALUE ruby_curl_easy_timeout_ms_get(VALUE self) {
  ruby_curl_easy *rbce;
  Data_Get_Struct(self, ruby_curl_easy, rbce);
  return LONG2NUM(rbce->timeout_ms);
}

#timeout_ms=(fixnum) ⇒ Fixnum?

Set the maximum time in milliseconds 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).

Returns:

  • (Fixnum, nil) 


1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
 
# File 'ext/curb_easy.c', line 1320

static VALUE ruby_curl_easy_timeout_ms_set(VALUE self, VALUE timeout_ms) {
  ruby_curl_easy *rbce;
  Data_Get_Struct(self, ruby_curl_easy, rbce);

  if (Qnil == timeout_ms || NUM2DBL(timeout_ms) <= 0.0) {
    rbce->timeout_ms = 0;
  } else {
    rbce->timeout_ms = NUM2ULONG(timeout_ms);
  }

  return ULONG2NUM(rbce->timeout_ms);
}

#total_time ⇒ Float

Retrieve the total time in seconds for the previous transfer, including name resolving, TCP connect etc.

Returns:

  • (Float) 


3176
3177
3178
3179
3180
3181
3182
3183
3184
 
# File 'ext/curb_easy.c', line 3176

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.



4131
4132
4133
4134
4135
4136
4137
4138
4139
4140
4141
4142
4143
4144
4145
4146
4147
4148
4149
4150
 
# File 'ext/curb_easy.c', line 4131

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), (int)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.

Returns:

  • (Boolean) 


1845
1846
1847
 
# File 'ext/curb_easy.c', line 1845

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.

Returns:

  • (Boolean) 


1856
1857
1858
 
# File 'ext/curb_easy.c', line 1856

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.

Returns:

  • (Float) 


3401
3402
3403
3404
3405
3406
3407
3408
3409
 
# File 'ext/curb_easy.c', line 3401

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.

Returns:

  • (Float) 


3367
3368
3369
3370
3371
3372
3373
3374
3375
 
# File 'ext/curb_easy.c', line 3367

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.

Returns:

  • (Float) 


3511
3512
3513
3514
3515
3516
3517
3518
3519
 
# File 'ext/curb_easy.c', line 3511

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.

Returns:

  • (String) 


536
537
538
 
# File 'ext/curb_easy.c', line 536

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.



128
129
130
 
# File 'lib/curl/easy.rb', line 128

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.

Returns:

  • (Boolean) 


1792
1793
1794
 
# File 'ext/curb_easy.c', line 1792

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.

Returns:

  • (Boolean) 


1803
1804
1805
 
# File 'ext/curb_easy.c', line 1803

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.

Returns:

  • (Fixnum) 


1636
1637
1638
 
# File 'ext/curb_easy.c', line 1636

static VALUE ruby_curl_easy_use_ssl_get(VALUE self) {
  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.

Returns:

  • (Fixnum, nil) 


1626
1627
1628
 
# File 'ext/curb_easy.c', line 1626

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

Returns:

  • ("Ruby/Curb") 


841
842
843
 
# File 'ext/curb_easy.c', line 841

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



831
832
833
 
# File 'ext/curb_easy.c', line 831

static VALUE ruby_curl_easy_useragent_set(VALUE self, VALUE useragent) {
  CURB_OBJECT_HSETTER(ruby_curl_easy, useragent);
}

#username ⇒ String

Get the current username

Returns:

  • (String) 


1553
1554
1555
1556
1557
1558
1559
 
# File 'ext/curb_easy.c', line 1553

static VALUE ruby_curl_easy_username_get(VALUE self) {
#if HAVE_CURLOPT_USERNAME
  CURB_OBJECT_HGETTER(ruby_curl_easy, username);
#else
  return Qnil;
#endif
}

#username=(string) ⇒ String

Set the HTTP Authentication username.

Returns:

  • (String) 


1539
1540
1541
1542
1543
1544
1545
 
# File 'ext/curb_easy.c', line 1539

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.

Returns:

  • (String) 


648
649
650
 
# File 'ext/curb_easy.c', line 648

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”



215
216
217
 
# File 'lib/curl/easy.rb', line 215

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.

Returns:

  • (Boolean) 


1867
1868
1869
 
# File 'ext/curb_easy.c', line 1867

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.

Returns:

  • (Boolean) 


1878
1879
1880
 
# File 'ext/curb_easy.c', line 1878

static VALUE ruby_curl_easy_verbose_q(VALUE self) {
  CURB_BOOLEAN_GETTER(ruby_curl_easy, verbose);
}

#version=(http_version) ⇒ Object

call-seq:

easy = Curl::Easy.new("url")
easy.version = Curl::HTTP_2_0
easy.version = Curl::HTTP_1_1
easy.version = Curl::HTTP_1_0
easy.version = Curl::HTTP_NONE



116
117
118
 
# File 'lib/curl/easy.rb', line 116

def version=(http_version)
  set :http_version, http_version
end