Struct new_tokio_smtp::ConnectionConfig

pub struct ConnectionConfig<A, S = DefaultTlsSetup> where
    S: SetupTls,
    A: Cmd,  {
    pub addr: SocketAddr,
    pub auth_cmd: A,
    pub security: Security<S>,
    pub client_id: ClientId,
    pub syntax_error_handling: SyntaxErrorHandling,
}

Configuration specifing how to setup an SMTP connection.

Use the ConnectionBuilder to crate it. (Expect if you need a unencrypted connection, in which case you have to crate it by hand. It's not recommended to use unencrypted connections for mail).

Example

use new_tokio_smtp::{ConnectionBuilder, Domain};
use new_tokio_smtp::command::auth::Login;

// For connecting with auth Login using the defaults, i.e.:
// STARTTLS, port 587 and the ip gotten from resolving
// the passed in domain/host name as well as the hostname
// as client identity.
let host = "smtp.gmail.com".parse()
    .expect("malformed domain/host name");
let config = ConnectionBuilder
    ::new(host)
    .expect("could not resolve host name")
    .auth(Login::new("user", "password"))
    .build();

Fields

addr: SocketAddr

the address and port to connect to (i.e. the ones of the smtp server)

auth_cmd: A

a command used for authentication (use NOOP if you don't auth)

security: Security<S>

the kind of TLS mechanism used when setting up the connection

client_id: ClientId

the client identity, i.e. your "identity"

This is relevant for the communication between smtp server, through for connecting to an MSA (e.g. thunderbird connecting to gmail) using localhost ([127.0.0.1]) is enough

syntax_error_handling: SyntaxErrorHandling

How strict error handling is done.

Implementations

impl<A> ConnectionConfig<A, DefaultTlsSetup> where
    A: Cmd, 

pub fn connect(
    self
) -> impl Future<Item = Connection, Error = ConnectingFailed> + Send

Calls Connection::connect(self).

impl ConnectionConfig<Noop, DefaultTlsSetup>

pub fn builder_local_unencrypted() -> LocalNonSecureBuilder<Noop>

Creates a connection to 127.0.0.1 without any form of encryption.

While this is possible it is not a good idea use this for anything but test setups.

pub fn builder(
    host: Domain
) -> Result<ConnectionBuilder<Noop, DefaultTlsSetup>, Error>

pub fn builder_with_port(
    host: Domain,
    port: u16
) -> Result<ConnectionBuilder<Noop, DefaultTlsSetup>, Error>

pub fn builder_with_addr(
    addr: SocketAddr,
    domain: Domain
) -> ConnectionBuilder<Noop, DefaultTlsSetup>

Trait Implementations

impl<A: Clone, S: Clone> Clone for ConnectionConfig<A, S> where
    S: SetupTls,
    A: Cmd, 

fn clone(&self) -> ConnectionConfig<A, S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A: Debug, S: Debug> Debug for ConnectionConfig<A, S> where
    S: SetupTls,
    A: Cmd, 

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

Formats the value using the given formatter.