Struct tokio::net::TcpStream [−][src]
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
impl TcpStream
[src]
pub async fn connect<A: ToSocketAddrs>(addr: A) -> Result<TcpStream>
[src]
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.
pub fn from_std(stream: TcpStream) -> Result<TcpStream>
[src]
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.
pub fn local_addr(&self) -> Result<SocketAddr>
[src]
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()?);
pub fn peer_addr(&self) -> Result<SocketAddr>
[src]
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()?);
pub fn poll_peek(
&mut self,
cx: &mut Context<'_>,
buf: &mut [u8]
) -> Poll<Result<usize>>
[src]
&mut self,
cx: &mut Context<'_>,
buf: &mut [u8]
) -> Poll<Result<usize>>
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(()) }
pub async fn peek(&mut self, buf: &mut [u8]) -> Result<usize>
[src]
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.
pub fn shutdown(&self, how: Shutdown) -> Result<()>
[src]
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(()) }
pub fn nodelay(&self) -> Result<bool>
[src]
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()?);
pub fn set_nodelay(&self, nodelay: bool) -> Result<()>
[src]
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)?;
pub fn recv_buffer_size(&self) -> Result<usize>
[src]
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()?);
pub fn set_recv_buffer_size(&self, size: usize) -> Result<()>
[src]
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)?;
pub fn send_buffer_size(&self) -> Result<usize>
[src]
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()?);
pub fn set_send_buffer_size(&self, size: usize) -> Result<()>
[src]
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)?;
pub fn keepalive(&self) -> Result<Option<Duration>>
[src]
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()?);
pub fn set_keepalive(&self, keepalive: Option<Duration>) -> Result<()>
[src]
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)?;
pub fn ttl(&self) -> Result<u32>
[src]
Gets the value of the IP_TTL
option for this socket.
For more information about this option, see set_ttl
.
Examples
use tokio::net::TcpStream; let stream = TcpStream::connect("127.0.0.1:8080").await?; println!("{:?}", stream.ttl()?);
pub fn set_ttl(&self, ttl: u32) -> Result<()>
[src]
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)?;
pub fn linger(&self) -> Result<Option<Duration>>
[src]
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()?);
pub fn set_linger(&self, dur: Option<Duration>) -> Result<()>
[src]
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)?;
pub fn split<'a>(&'a mut self) -> (ReadHalf<'a>, WriteHalf<'a>)
[src]
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.
pub fn into_split(self) -> (OwnedReadHalf, OwnedWriteHalf)
[src]
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
impl AsRawFd for TcpStream
[src]
impl AsRef<TcpStream> for ReadHalf<'_>
[src]
impl AsRef<TcpStream> for WriteHalf<'_>
[src]
impl AsRef<TcpStream> for OwnedReadHalf
[src]
impl AsRef<TcpStream> for OwnedWriteHalf
[src]
impl AsyncRead for TcpStream
[src]
unsafe fn prepare_uninitialized_buffer(&self, _: &mut [MaybeUninit<u8>]) -> bool
[src]
fn poll_read(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut [u8]
) -> Poll<Result<usize>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut [u8]
) -> Poll<Result<usize>>
fn poll_read_buf<B: BufMut>(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut B
) -> Poll<Result<usize>> where
Self: Sized,
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut B
) -> Poll<Result<usize>> where
Self: Sized,
impl AsyncWrite for TcpStream
[src]
fn poll_write(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &[u8]
) -> Poll<Result<usize>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &[u8]
) -> Poll<Result<usize>>
fn poll_write_buf<B: Buf>(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut B
) -> Poll<Result<usize>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut B
) -> Poll<Result<usize>>
fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<()>>
[src]
fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<()>>
[src]
impl Debug for TcpStream
[src]
impl TryFrom<TcpStream> for TcpStream
[src]
Auto Trait Implementations
impl !RefUnwindSafe for TcpStream
impl Send for TcpStream
impl Sync for TcpStream
impl Unpin for TcpStream
impl !UnwindSafe for TcpStream
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut Tⓘ
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,