Struct StreamBuilder

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

a builder for Stream

Implementations

impl<'a> StreamBuilder<'a>

pub fn socks4(self, proxy: SocketAddr) -> Self

enable socks4 proxying

let builder = builder.socks4("127.0.0.1:9050".parse().unwrap());

pub fn socks4_with_userid(self, proxy: SocketAddr, userid: &'a str) -> Self

enable socks4 proxying with a userid

let builder = builder.socks4_with_userid("127.0.0.1:9050".parse().unwrap(), "meow");

pub fn socks5(self, proxy: SocketAddr) -> Self

enable socks5 proxying

let builder = builder.socks5("127.0.0.1:9050".parse().unwrap());

pub fn socks5_with_password( self, proxy: SocketAddr, username: &'a str, password: &'a str, ) -> Self

enable socks5 proxying with password authentication

let builder =
    builder.socks5_with_password("127.0.0.1:9050".parse().unwrap(), "AzureDiamond", "hunter2");

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

enable tls without any verification

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

pub fn tls_with_root( self, domain: Option<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(None, root);

pub fn tls_with_webpki( self, domain: Option<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 std::net::SocketAddr;
use tokio_rustls::rustls::pki_types::{CertificateDer, PrivateKeyDer, ServerName, pem::PemObject};

let builder = Stream::new_tcp("[::1]:6667").tls_danger_insecure(None);
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();

Errors

will return Error if an invalid combination of options has been given to the builder, or if it is unable to connect

Trait Implementations

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

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

Formats the value using the given formatter.