Struct actix_rt::net::TcpStream [−][src]
pub struct TcpStream { /* fields omitted */ }
Expand description
A TCP stream between a local and a remote socket.
A TCP stream can either be created by connecting to an endpoint, via the
connect
method, or by accepting a connection from a listener.
Reading and writing to a TcpStream
is usually done using the
convenience methods found on the AsyncReadExt
and AsyncWriteExt
traits. Examples import these traits through the prelude.
Examples
use tokio::net::TcpStream;
use tokio::prelude::*;
use std::error::Error;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
// Connect to a peer
let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
// Write some data.
stream.write_all(b"hello world!").await?;
Ok(())
}
The write_all
method is defined on the AsyncWriteExt
trait.
Implementations
Opens a TCP connection to a remote host.
addr
is an address of the remote host. Anything which implements the
ToSocketAddrs
trait can be supplied as the address. Note that
strings only implement this trait when the dns
feature is enabled,
as strings may contain domain names that need to be resolved.
If addr
yields multiple addresses, connect will be attempted with each
of the addresses until a connection is successful. If none of the
addresses result in a successful connection, the error returned from the
last connection attempt (the last address) is returned.
Examples
use tokio::net::TcpStream;
use tokio::prelude::*;
use std::error::Error;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
// Connect to a peer
let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
// Write some data.
stream.write_all(b"hello world!").await?;
Ok(())
}
Without the dns
feature:
use tokio::net::TcpStream;
use tokio::prelude::*;
use std::error::Error;
use std::net::Ipv4Addr;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
// Connect to a peer
let mut stream = TcpStream::connect((Ipv4Addr::new(127, 0, 0, 1), 8080)).await?;
// Write some data.
stream.write_all(b"hello world!").await?;
Ok(())
}
The write_all
method is defined on the AsyncWriteExt
trait.
Creates new TcpStream
from a std::net::TcpStream
.
This function will convert a TCP stream created by the standard library to a TCP stream ready to be used with the provided event loop handle.
Examples
use std::error::Error;
use tokio::net::TcpStream;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
let std_stream = std::net::TcpStream::connect("127.0.0.1:34254")?;
let stream = TcpStream::from_std(std_stream)?;
Ok(())
}
Panics
This function panics if thread-local runtime is not set.
The runtime is usually set implicitly when this function is called
from a future driven by a tokio runtime, otherwise runtime can be set
explicitly with Handle::enter
function.
Returns the local address that this stream is bound to.
Examples
use tokio::net::TcpStream;
let stream = TcpStream::connect("127.0.0.1:8080").await?;
println!("{:?}", stream.local_addr()?);
Returns the remote address that this stream is connected to.
Examples
use tokio::net::TcpStream;
let stream = TcpStream::connect("127.0.0.1:8080").await?;
println!("{:?}", stream.peer_addr()?);
Attempts to receive data on the socket, without removing that data from the queue, registering the current task for wakeup if data is not yet available.
Return value
The function returns:
Poll::Pending
if data is not yet available.Poll::Ready(Ok(n))
if data is available.n
is the number of bytes peeked.Poll::Ready(Err(e))
if an error is encountered.
Errors
This function may encounter any standard I/O error except WouldBlock
.
Examples
use tokio::io;
use tokio::net::TcpStream;
use futures::future::poll_fn;
#[tokio::main]
async fn main() -> io::Result<()> {
let mut stream = TcpStream::connect("127.0.0.1:8000").await?;
let mut buf = [0; 10];
poll_fn(|cx| {
stream.poll_peek(cx, &mut buf)
}).await?;
Ok(())
}
Receives data on the socket from the remote address to which it is connected, without removing that data from the queue. On success, returns the number of bytes peeked.
Successive calls return the same data. This is accomplished by passing
MSG_PEEK
as a flag to the underlying recv system call.
Examples
use tokio::net::TcpStream;
use tokio::prelude::*;
use std::error::Error;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
// Connect to a peer
let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
let mut b1 = [0; 10];
let mut b2 = [0; 10];
// Peek at the data
let n = stream.peek(&mut b1).await?;
// Read the data
assert_eq!(n, stream.read(&mut b2[..n]).await?);
assert_eq!(&b1[..n], &b2[..n]);
Ok(())
}
The read
method is defined on the AsyncReadExt
trait.
Shuts down the read, write, or both halves of this connection.
This function will cause all pending and future I/O on the specified
portions to return immediately with an appropriate value (see the
documentation of Shutdown
).
Examples
use tokio::net::TcpStream;
use std::error::Error;
use std::net::Shutdown;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
// Connect to a peer
let stream = TcpStream::connect("127.0.0.1:8080").await?;
// Shutdown the stream
stream.shutdown(Shutdown::Write)?;
Ok(())
}
Gets the value of the TCP_NODELAY
option on this socket.
For more information about this option, see set_nodelay
.
Examples
use tokio::net::TcpStream;
let stream = TcpStream::connect("127.0.0.1:8080").await?;
println!("{:?}", stream.nodelay()?);
Sets the value of the TCP_NODELAY
option on this socket.
If set, this option disables the Nagle algorithm. This means that segments are always sent as soon as possible, even if there is only a small amount of data. When not set, data is buffered until there is a sufficient amount to send out, thereby avoiding the frequent sending of small packets.
Examples
use tokio::net::TcpStream;
let stream = TcpStream::connect("127.0.0.1:8080").await?;
stream.set_nodelay(true)?;
Gets the value of the SO_RCVBUF
option on this socket.
For more information about this option, see set_recv_buffer_size
.
Examples
use tokio::net::TcpStream;
let stream = TcpStream::connect("127.0.0.1:8080").await?;
println!("{:?}", stream.recv_buffer_size()?);
Sets the value of the SO_RCVBUF
option on this socket.
Changes the size of the operating system’s receive buffer associated with the socket.
Examples
use tokio::net::TcpStream;
let stream = TcpStream::connect("127.0.0.1:8080").await?;
stream.set_recv_buffer_size(100)?;
Gets the value of the SO_SNDBUF
option on this socket.
For more information about this option, see set_send_buffer_size
.
Examples
use tokio::net::TcpStream;
let stream = TcpStream::connect("127.0.0.1:8080").await?;
println!("{:?}", stream.send_buffer_size()?);
Sets the value of the SO_SNDBUF
option on this socket.
Changes the size of the operating system’s send buffer associated with the socket.
Examples
use tokio::net::TcpStream;
let stream = TcpStream::connect("127.0.0.1:8080").await?;
stream.set_send_buffer_size(100)?;
Returns whether keepalive messages are enabled on this socket, and if so the duration of time between them.
For more information about this option, see set_keepalive
.
Examples
use tokio::net::TcpStream;
let stream = TcpStream::connect("127.0.0.1:8080").await?;
println!("{:?}", stream.keepalive()?);
Sets whether keepalive messages are enabled to be sent on this socket.
On Unix, this option will set the SO_KEEPALIVE
as well as the
TCP_KEEPALIVE
or TCP_KEEPIDLE
option (depending on your platform).
On Windows, this will set the SIO_KEEPALIVE_VALS
option.
If None
is specified then keepalive messages are disabled, otherwise
the duration specified will be the time to remain idle before sending a
TCP keepalive probe.
Some platforms specify this value in seconds, so sub-second specifications may be omitted.
Examples
use tokio::net::TcpStream;
let stream = TcpStream::connect("127.0.0.1:8080").await?;
stream.set_keepalive(None)?;
Sets the value for the IP_TTL
option on this socket.
This value sets the time-to-live field that is used in every packet sent from this socket.
Examples
use tokio::net::TcpStream;
let stream = TcpStream::connect("127.0.0.1:8080").await?;
stream.set_ttl(123)?;
Reads the linger duration for this socket by getting the SO_LINGER
option.
For more information about this option, see set_linger
.
Examples
use tokio::net::TcpStream;
let stream = TcpStream::connect("127.0.0.1:8080").await?;
println!("{:?}", stream.linger()?);
Sets the linger duration of this socket by setting the SO_LINGER
option.
This option controls the action taken when a stream has unsent messages
and the stream is closed. If SO_LINGER
is set, the system
shall block the process until it can transmit the data or until the
time expires.
If SO_LINGER
is not specified, and the stream is closed, the system
handles the call in a way that allows the process to continue as quickly
as possible.
Examples
use tokio::net::TcpStream;
let stream = TcpStream::connect("127.0.0.1:8080").await?;
stream.set_linger(None)?;
Splits a TcpStream
into a read half and a write half, which can be used
to read and write the stream concurrently.
This method is more efficient than into_split
, but the halves cannot be
moved into independently spawned tasks.
Splits a TcpStream
into a read half and a write half, which can be used
to read and write the stream concurrently.
Unlike split
, the owned halves can be moved to separate tasks, however
this comes at the cost of a heap allocation.
Note: Dropping the write half will shut down the write half of the TCP
stream. This is equivalent to calling shutdown(Write)
on the TcpStream
.
Trait Implementations
Auto Trait Implementations
impl !RefUnwindSafe for TcpStream
impl !UnwindSafe for TcpStream
Blanket Implementations
Creates a new AsyncRead
instance that chains this stream with
next
. Read more
Pulls some bytes from this source into the specified buffer, returning how many bytes were read. Read more
Pulls some bytes from this source into the specified buffer, advancing the buffer’s internal cursor. Read more
Reads the exact number of bytes required to fill buf
. Read more
Reads an unsigned 8 bit integer from the underlying reader. Read more
Reads a signed 8 bit integer from the underlying reader. Read more
Reads an unsigned 16-bit integer in big-endian order from the underlying reader. Read more
Reads a signed 16-bit integer in big-endian order from the underlying reader. Read more
Reads an unsigned 32-bit integer in big-endian order from the underlying reader. Read more
Reads a signed 32-bit integer in big-endian order from the underlying reader. Read more
Reads an unsigned 64-bit integer in big-endian order from the underlying reader. Read more
Reads an signed 64-bit integer in big-endian order from the underlying reader. Read more
Reads an unsigned 128-bit integer in big-endian order from the underlying reader. Read more
Reads an signed 128-bit integer in big-endian order from the underlying reader. Read more
Reads an unsigned 16-bit integer in little-endian order from the underlying reader. Read more
Reads a signed 16-bit integer in little-endian order from the underlying reader. Read more
Reads an unsigned 32-bit integer in little-endian order from the underlying reader. Read more
Reads a signed 32-bit integer in little-endian order from the underlying reader. Read more
Reads an unsigned 64-bit integer in little-endian order from the underlying reader. Read more
Reads an signed 64-bit integer in little-endian order from the underlying reader. Read more
Reads an unsigned 128-bit integer in little-endian order from the underlying reader. Read more
Reads an signed 128-bit integer in little-endian order from the underlying reader. Read more
Reads all bytes until EOF in this source, placing them into buf
. Read more
fn read_to_string(&'a mut self, dst: &'a mut String) -> ReadToString<'a, Self> where
Self: Unpin,
fn read_to_string(&'a mut self, dst: &'a mut String) -> ReadToString<'a, Self> where
Self: Unpin,
Reads all bytes until EOF in this source, appending them to buf
. Read more
Writes a buffer into this writer, returning how many bytes were written. Read more
Writes a buffer into this writer, advancing the buffer’s internal cursor. Read more
Attempts to write an entire buffer into this writer. Read more
Writes an unsigned 8-bit integer to the underlying writer. Read more
Writes an unsigned 8-bit integer to the underlying writer. Read more
Writes an unsigned 16-bit integer in big-endian order to the underlying writer. Read more
Writes a signed 16-bit integer in big-endian order to the underlying writer. Read more
Writes an unsigned 32-bit integer in big-endian order to the underlying writer. Read more
Writes a signed 32-bit integer in big-endian order to the underlying writer. Read more
Writes an unsigned 64-bit integer in big-endian order to the underlying writer. Read more
Writes an signed 64-bit integer in big-endian order to the underlying writer. Read more
Writes an unsigned 128-bit integer in big-endian order to the underlying writer. Read more
Writes an signed 128-bit integer in big-endian order to the underlying writer. Read more
Writes an unsigned 16-bit integer in little-endian order to the underlying writer. Read more
Writes a signed 16-bit integer in little-endian order to the underlying writer. Read more
Writes an unsigned 32-bit integer in little-endian order to the underlying writer. Read more
Writes a signed 32-bit integer in little-endian order to the underlying writer. Read more
Writes an unsigned 64-bit integer in little-endian order to the underlying writer. Read more
Writes an signed 64-bit integer in little-endian order to the underlying writer. Read more
Writes an unsigned 128-bit integer in little-endian order to the underlying writer. Read more
Writes an signed 128-bit integer in little-endian order to the underlying writer. Read more
Flushes this output stream, ensuring that all intermediately buffered contents reach their destination. Read more
Mutably borrows from an owned value. Read more