Struct curl::easy::Easy2

source · [−]

pub struct Easy2<H> { /* private fields */ }

Expand description

Raw bindings to a libcurl “easy session”.

This type corresponds to the CURL type in libcurl, and is probably what you want for just sending off a simple HTTP request and fetching a response. Each easy handle can be thought of as a large builder before calling the final perform function.

There are many many configuration options for each Easy2 handle, and they should all have their own documentation indicating what it affects and how it interacts with other options. Some implementations of libcurl can use this handle to interact with many different protocols, although by default this crate only guarantees the HTTP/HTTPS protocols working.

Note that almost all methods on this structure which configure various properties return a Result. This is largely used to detect whether the underlying implementation of libcurl actually implements the option being requested. If you’re linked to a version of libcurl which doesn’t support the option, then an error will be returned. Some options also perform some validation when they’re set, and the error is returned through this vector.

Note that historically this library contained an Easy handle so this one’s called Easy2. The major difference between the Easy type is that an Easy2 structure uses a trait instead of closures for all of the callbacks that curl can invoke. The Easy type is actually built on top of this Easy type, and this Easy2 type can be more flexible in some situations due to the generic parameter.

There’s not necessarily a right answer for which type is correct to use, but as a general rule of thumb Easy is typically a reasonable choice for synchronous I/O and Easy2 is a good choice for asynchronous I/O.

Examples

use curl::easy::{Easy2, Handler, WriteError};

struct Collector(Vec<u8>);

impl Handler for Collector {
    fn write(&mut self, data: &[u8]) -> Result<usize, WriteError> {
        self.0.extend_from_slice(data);
        Ok(data.len())
    }
}

let mut easy = Easy2::new(Collector(Vec::new()));
easy.get(true).unwrap();
easy.url("https://www.rust-lang.org/").unwrap();
easy.perform().unwrap();

assert_eq!(easy.response_code().unwrap(), 200);
let contents = easy.get_ref();
println!("{}", String::from_utf8_lossy(&contents.0));

Struct curl::easy::Easy2

Implementations

impl<H: Handler> Easy2<H>

pub fn new(handler: H) -> Easy2<H>

pub fn reset(&mut self)

impl<H> Easy2<H>

pub fn verbose(&mut self, verbose: bool) -> Result<(), Error>

pub fn show_header(&mut self, show: bool) -> Result<(), Error>

pub fn progress(&mut self, progress: bool) -> Result<(), Error>

pub fn signal(&mut self, signal: bool) -> Result<(), Error>

pub fn wildcard_match(&mut self, m: bool) -> Result<(), Error>

pub fn unix_socket(&mut self, unix_domain_socket: &str) -> Result<(), Error>

pub fn unix_socket_path<P: AsRef<Path>>( &mut self, path: Option<P>) -> Result<(), Error>

pub fn get_ref(&self) -> &H

pub fn get_mut(&mut self) -> &mut H

pub fn fail_on_error(&mut self, fail: bool) -> Result<(), Error>

pub fn url(&mut self, url: &str) -> Result<(), Error>

pub fn port(&mut self, port: u16) -> Result<(), Error>

pub fn connect_to(&mut self, list: List) -> Result<(), Error>

pub fn path_as_is(&mut self, as_is: bool) -> Result<(), Error>

pub fn proxy(&mut self, url: &str) -> Result<(), Error>

pub fn proxy_port(&mut self, port: u16) -> Result<(), Error>

pub fn proxy_cainfo(&mut self, cainfo: &str) -> Result<(), Error>

pub fn proxy_capath<P: AsRef<Path>>(&mut self, path: P) -> Result<(), Error>

pub fn proxy_sslcert(&mut self, sslcert: &str) -> Result<(), Error>

pub fn proxy_sslcert_blob(&mut self, blob: &[u8]) -> Result<(), Error>

pub fn proxy_sslkey(&mut self, sslkey: &str) -> Result<(), Error>

pub fn proxy_sslkey_blob(&mut self, blob: &[u8]) -> Result<(), Error>

pub fn proxy_type(&mut self, kind: ProxyType) -> Result<(), Error>

pub fn noproxy(&mut self, skip: &str) -> Result<(), Error>

pub fn http_proxy_tunnel(&mut self, tunnel: bool) -> Result<(), Error>

pub fn interface(&mut self, interface: &str) -> Result<(), Error>

pub fn set_local_port(&mut self, port: u16) -> Result<(), Error>

pub fn local_port_range(&mut self, range: u16) -> Result<(), Error>

pub fn dns_servers(&mut self, servers: &str) -> Result<(), Error>

pub fn dns_cache_timeout(&mut self, dur: Duration) -> Result<(), Error>

pub fn doh_url(&mut self, url: Option<&str>) -> Result<(), Error>

pub fn doh_ssl_verify_peer(&mut self, verify: bool) -> Result<(), Error>

pub fn doh_ssl_verify_host(&mut self, verify: bool) -> Result<(), Error>

pub fn doh_ssl_verify_status(&mut self, verify: bool) -> Result<(), Error>

pub fn buffer_size(&mut self, size: usize) -> Result<(), Error>

pub fn upload_buffer_size(&mut self, size: usize) -> Result<(), Error>

pub fn tcp_nodelay(&mut self, enable: bool) -> Result<(), Error>

pub fn tcp_keepalive(&mut self, enable: bool) -> Result<(), Error>

pub fn tcp_keepidle(&mut self, amt: Duration) -> Result<(), Error>

pub fn tcp_keepintvl(&mut self, amt: Duration) -> Result<(), Error>

pub fn address_scope(&mut self, scope: u32) -> Result<(), Error>

pub fn username(&mut self, user: &str) -> Result<(), Error>

pub fn password(&mut self, pass: &str) -> Result<(), Error>

pub fn http_auth(&mut self, auth: &Auth) -> Result<(), Error>

pub fn aws_sigv4(&mut self, param: &str) -> Result<(), Error>

pub fn proxy_username(&mut self, user: &str) -> Result<(), Error>

pub fn proxy_password(&mut self, pass: &str) -> Result<(), Error>

pub fn proxy_auth(&mut self, auth: &Auth) -> Result<(), Error>

pub fn netrc(&mut self, netrc: NetRc) -> Result<(), Error>

pub fn autoreferer(&mut self, enable: bool) -> Result<(), Error>

pub fn accept_encoding(&mut self, encoding: &str) -> Result<(), Error>

pub fn transfer_encoding(&mut self, enable: bool) -> Result<(), Error>

pub fn follow_location(&mut self, enable: bool) -> Result<(), Error>

pub fn unrestricted_auth(&mut self, enable: bool) -> Result<(), Error>

pub fn max_redirections(&mut self, max: u32) -> Result<(), Error>

pub fn put(&mut self, enable: bool) -> Result<(), Error>

pub fn post(&mut self, enable: bool) -> Result<(), Error>

pub fn post_fields_copy(&mut self, data: &[u8]) -> Result<(), Error>

pub fn post_field_size(&mut self, size: u64) -> Result<(), Error>

pub fn httppost(&mut self, form: Form) -> Result<(), Error>

pub fn referer(&mut self, referer: &str) -> Result<(), Error>

pub fn useragent(&mut self, useragent: &str) -> Result<(), Error>

pub fn http_headers(&mut self, list: List) -> Result<(), Error>

pub fn cookie(&mut self, cookie: &str) -> Result<(), Error>

pub fn cookie_file<P: AsRef<Path>>(&mut self, file: P) -> Result<(), Error>

pub fn cookie_jar<P: AsRef<Path>>(&mut self, file: P) -> Result<(), Error>

pub fn cookie_session(&mut self, session: bool) -> Result<(), Error>

pub fn cookie_list(&mut self, cookie: &str) -> Result<(), Error>

pub fn get(&mut self, enable: bool) -> Result<(), Error>

pub fn ignore_content_length(&mut self, ignore: bool) -> Result<(), Error>

pub fn http_content_decoding(&mut self, enable: bool) -> Result<(), Error>

pub fn http_transfer_decoding(&mut self, enable: bool) -> Result<(), Error>

pub fn range(&mut self, range: &str) -> Result<(), Error>

pub fn resume_from(&mut self, from: u64) -> Result<(), Error>

pub fn unix_socket_path<P: AsRef<Path>>(
&mut self,
path: Option<P>
) -> Result<(), Error>

pub fn ssl_min_max_version(
&mut self,
min_version: SslVersion,
max_version: SslVersion
) -> Result<(), Error>