Struct StreamBuilder

pub struct StreamBuilder<'a> { /* private fields */ }

a builder for Stream

Implementations

impl<'a> StreamBuilder<'a>

pub fn socks4(self, target: impl IntoTargetAddr<'a>) -> Self

👎Deprecated: the current behavior is unintentional and will be replaced for v0.2.0

enable socks4 proxying

let addr = "127.0.0.1:9050".parse().unwrap();
let builder = Stream::new_tcp(&addr);
let builder = builder.socks4("irc.example.com:6667");

pub fn socks4_with_userid( self, target: impl IntoTargetAddr<'a>, userid: &'a str, ) -> Self

👎Deprecated: the current behavior is unintentional and will be replaced for v0.2.0

enable socks4 proxying with a userid

let addr = "127.0.0.1:9050".parse().unwrap();
let builder = Stream::new_tcp(&addr);
let builder = builder.socks4_with_userid("irc.example.com:6667", "meow");

pub fn socks5(self, target: impl IntoTargetAddr<'a>) -> Self

👎Deprecated: the current behavior is unintentional and will be replaced for v0.2.0

enable socks5 proxying

let addr = "127.0.0.1:9050".parse().unwrap();
let builder = Stream::new_tcp(&addr);
let builder = builder.socks5("irc.example.com:6667");

pub fn socks5_with_password( self, target: impl IntoTargetAddr<'a>, username: &'a str, password: &'a str, ) -> Self

👎Deprecated: the current behavior is unintentional and will be replaced for v0.2.0

enable socks5 proxying with password authentication

let addr = "127.0.0.1:9050".parse().unwrap();
let builder = Stream::new_tcp(&addr);
let builder = builder.socks5_with_password("irc.example.com:6667", "AzureDiamond", "hunter2");

pub fn tls_danger_insecure(self, domain: ServerName<'static>) -> Self

enable tls without any verification

use tokio_rustls::rustls::pki_types::ServerName;
let builder = builder.tls_danger_insecure(ServerName::try_from("google.com").unwrap());

pub fn tls_with_root( self, domain: ServerName<'static>, root: impl Into<Arc<RootCertStore>>, ) -> Self

enable tls with root certificate verification

can also be used to pin a self-signed cert as long as it has a CA:FALSE constraint

use tokio_rustls::rustls::RootCertStore;
use tokio_rustls::rustls::pki_types::{CertificateDer, ServerName, pem::PemObject};

let mut root = RootCertStore::empty();
root.add_parsable_certificates(
    CertificateDer::pem_file_iter("/etc/ssl/cert.pem")
        .unwrap()
        .flatten(),
);
let builder = builder.tls_with_root(ServerName::try_from("google.com").unwrap(), root);

pub fn tls_with_webpki( self, domain: ServerName<'static>, webpki: Arc<WebPkiServerVerifier>, ) -> Self

enable tls with a webpki verifier

pub fn client_cert( self, cert_chain: Vec<CertificateDer<'static>>, key_der: PrivateKeyDer<'static>, ) -> Self

use a tls client certificate

requires tls to be enabled

use irc_connect::Stream;
use tokio_rustls::rustls::pki_types::{CertificateDer, PrivateKeyDer, ServerName, pem::PemObject};

let addr = "[::1]:6667".parse().unwrap();
let builder = Stream::new_tcp(&addr).tls_danger_insecure(ServerName::from(addr.ip()));
let cert = CertificateDer::pem_file_iter("cert.pem")
    .unwrap()
    .collect::<Result<Vec<_>, _>>()
    .unwrap();
let key = PrivateKeyDer::from_pem_file("cert.key").unwrap();
let builder = builder.client_cert(cert, key);

pub async fn connect(self) -> Result<Stream, Error>

finish building and open the connection

let stream = builder.connect().await.unwrap();

Trait Implementations

impl<'a> Debug for StreamBuilder<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.