Struct new_tokio_smtp::io::Io

pub struct Io { /* fields omitted */ }

A Io object representing a smtp connection with buffers, socket and ehlo data

Implementations

impl Io

pub fn flush(self) -> Flushing

return a futures resolving back to this instance once all output data is flushed

pub fn flush_line_from_parts(self, line: &[&str]) -> Flushing

writes cmd and then "\r\n" to buffer.input and then calls flush

pub fn poll_flush(&mut self) -> Poll<(), Error>

writes data from the output buffer to the socket and polls flush

This first poll the writing of data from output to socket until output is empty, then it will start polling flush on the socket.

impl Io

pub fn parse_response(self) -> Parsing

parse a "normal" smtp response

Panics

Panics if the write buffer is not empty

pub fn read_from_socket(&mut self) -> Result<ReadState, Error>

read data from the socket to buffer.input until it would block or the socket closed

The input buffer is increased in increments of 256 bytes (INPUT_BUFFER_INC_SIZE)

pub fn try_pop_line<F, R, E>(
    &mut self,
    parse_line_fn: F
) -> Result<Option<R>, E> where
    F: FnOnce(&[u8]) -> Result<R, E>, 

Implementation Limitations

Be aware that try_read_line does only work on continuous buffers. I.e. it would fail if self.in_buffer() is a Chain

impl Io

pub fn write_dot_stashed<S>(self, source: S) -> DotStashedWrite<S> where
    S: Stream<Error = Error>,
    S::Item: Buf, 

write all data from source to the output socket using dot-stashing

This includes the end of message sequence "\r\n.\r\n", through this implementation makes sure not to add a additional "\r\n" to the end of the file if it isn't needed.

impl Io

pub fn connect_insecure(
    addr: &SocketAddr
) -> Map<ConnectFuture, fn(_: TcpStream) -> Io>

create a new Tcp only connection to the given address

pub fn connect_secure<S>(
    addr: &SocketAddr,
    config: TlsConfig<S>
) -> impl Future<Item = Io, Error = Error> + Send where
    S: SetupTls, 

create a new Tcp-Tls connection to the given address using the given tls config

impl Io

pub fn split(self) -> (Socket, Buffers, Option<EhloData>)

split this instance into it's parts

pub fn write_line_from_parts(&mut self, parts: &[&str])

writes all strings in parts to the output buffer followed by "\r\n"

pub fn socket_mut(&mut self) -> &mut Socket

returns a &mut to the inner Socket abstraction

pub fn socket(&self) -> &Socket

returns a & to the inner Socket abstraction

pub fn is_secure(&self) -> bool

true if the socket uses Tls

(can also be true in case of a mock socket)

pub fn out_buffer(&mut self, need_rem: usize) -> &mut BytesMut

returns a &mut to a (the) output buffer having at last need_rem bytes free capacity

pub fn in_buffer(&mut self) -> &mut BytesMut

returns a &mut to the input buffer

pub fn ehlo_data(&self) -> Option<&EhloData>

access the stored ehlo data

pub fn set_ehlo_data(&mut self, data: EhloData)

store different helo data

pub fn has_capability<C>(&self, cap: C) -> bool where
    C: AsRef<str>, 

checks if a specific EsmtpKeyword had been in the last Ehlo response

pub fn exec_simple_cmd(self, parts: &[&str]) -> ExecFuture

used to impl. simple commands e.g. con.send_simple_cmd(&["NOOP"])

Trait Implementations

impl Debug for Io

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

Formats the value using the given formatter.

impl From<(Socket, Buffers, EhloData)> for Io

fn from((socket, buffer, ehlo_data): (Socket, Buffers, EhloData)) -> Self

Performs the conversion.

impl From<(Socket, Buffers, Option<EhloData>)> for Io

fn from(
    (socket, buffer, ehlo_data): (Socket, Buffers, Option<EhloData>)
) -> Self

Performs the conversion.

impl From<(Socket, Buffers)> for Io

fn from((socket, buffer): (Socket, Buffers)) -> Self

Performs the conversion.

impl From<Connection> for Io

fn from(con: Connection) -> Self

Performs the conversion.

impl From<Io> for Connection

create a new Connection from a Io instance

The Io instance should contain a Socket which is still alive.

fn from(io: Io) -> Self

Performs the conversion.

impl From<Socket> for Io

fn from(socket: Socket) -> Self

Performs the conversion.

impl From<TcpStream> for Io

fn from(stream: TcpStream) -> Self

Performs the conversion.

impl From<TlsStream<TcpStream>> for Io

fn from(stream: TlsStream<TcpStream>) -> Self

Performs the conversion.