pub struct TcpListener(_);
A TCP socket server, listening for connections.
After creating a TcpListener
by bind
ing it to a socket address, it listens
for incoming TCP connections. These can be accepted by calling accept
or by
iterating over the Incoming
iterator returned by incoming
.
The socket will be closed when the value is dropped.
The Transmission Control Protocol is specified in IETF RFC 793.
use std::net::{TcpListener, TcpStream};
fn handle_client(stream: TcpStream) {
}
fn main() -> io::Result<()> {
let listener = TcpListener::bind("127.0.0.1:80")?;
for stream in listener.incoming() {
handle_client(stream?);
}
Ok(())
}Run
Creates a new TcpListener
which will be bound to the specified
address.
The returned listener is ready for accepting connections.
Binding with a port number of 0 will request that the OS assigns a port
to this listener. The port allocated can be queried via the
local_addr
method.
The address type can be any implementor of ToSocketAddrs
trait. See
its documentation for concrete examples.
If addr
yields multiple addresses, bind
will be attempted with
each of the addresses until one succeeds and returns the listener. If
none of the addresses succeed in creating a listener, the error returned
from the last attempt (the last address) is returned.
Create a TCP listener bound to 127.0.0.1:80
:
use std::net::TcpListener;
let listener = TcpListener::bind("127.0.0.1:80").unwrap();Run
Create a TCP listener bound to 127.0.0.1:80
. If that fails, create a
TCP listener bound to 127.0.0.1:443
:
use std::net::{SocketAddr, TcpListener};
let addrs = [
SocketAddr::from(([127, 0, 0, 1], 80)),
SocketAddr::from(([127, 0, 0, 1], 443)),
];
let listener = TcpListener::bind(&addrs[..]).unwrap();Run
Returns the local socket address of this listener.
use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4, TcpListener};
let listener = TcpListener::bind("127.0.0.1:8080").unwrap();
assert_eq!(listener.local_addr().unwrap(),
SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080)));Run
Creates a new independently owned handle to the underlying socket.
The returned TcpListener
is a reference to the same socket that this
object references. Both handles can be used to accept incoming
connections and options set on one listener will affect the other.
use std::net::TcpListener;
let listener = TcpListener::bind("127.0.0.1:8080").unwrap();
let listener_clone = listener.try_clone().unwrap();Run
Accept a new incoming connection from this listener.
This function will block the calling thread until a new TCP connection
is established. When established, the corresponding TcpStream
and the
remote peer's address will be returned.
use std::net::TcpListener;
let listener = TcpListener::bind("127.0.0.1:8080").unwrap();
match listener.accept() {
Ok((_socket, addr)) => println!("new client: {:?}", addr),
Err(e) => println!("couldn't get client: {:?}", e),
}Run
Returns an iterator over the connections being received on this
listener.
The returned iterator will never return None
and will also not yield
the peer's SocketAddr
structure. Iterating over it is equivalent to
calling accept
in a loop.
use std::net::TcpListener;
let listener = TcpListener::bind("127.0.0.1:80").unwrap();
for stream in listener.incoming() {
match stream {
Ok(stream) => {
println!("new client!");
}
Err(e) => { }
}
}Run
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.
use std::net::TcpListener;
let listener = TcpListener::bind("127.0.0.1:80").unwrap();
listener.set_ttl(100).expect("could not set TTL");Run
Gets the value of the IP_TTL
option for this socket.
For more information about this option, see set_ttl
.
use std::net::TcpListener;
let listener = TcpListener::bind("127.0.0.1:80").unwrap();
listener.set_ttl(100).expect("could not set TTL");
assert_eq!(listener.ttl().unwrap_or(0), 100);Run
Deprecated since 1.16.0
: this option can only be set before the socket is bound
Deprecated since 1.16.0
: this option can only be set before the socket is bound
Get the value of the SO_ERROR
option on this socket.
This will retrieve the stored error in the underlying socket, clearing
the field in the process. This can be useful for checking errors between
calls.
use std::net::TcpListener;
let listener = TcpListener::bind("127.0.0.1:80").unwrap();
listener.take_error().expect("No error was expected");Run
Moves this TCP stream into or out of nonblocking mode.
This will result in the accept
operation becoming nonblocking,
i.e. immediately returning from their calls. If the IO operation is
successful, Ok
is returned and no further action is required. If the
IO operation could not be completed and needs to be retried, an error
with kind io::ErrorKind::WouldBlock
is returned.
On Unix platforms, calling this method corresponds to calling fcntl
FIONBIO
. On Windows calling this method corresponds to calling
ioctlsocket
FIONBIO
.
Bind a TCP listener to an address, listen for connections, and read
bytes in nonblocking mode:
use std::io;
use std::net::TcpListener;
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
listener.set_nonblocking(true).expect("Cannot set non-blocking");
for stream in listener.incoming() {
match stream {
Ok(s) => {
handle_connection(s);
}
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
wait_for_fd();
continue;
}
Err(e) => panic!("encountered IO error: {}", e),
}
}Run
This is supported on Unix only.
This is supported on Unix only.
Constructs a new instance of Self
from the given raw file descriptor. Read more
This is supported on Unix only.
Consumes this object, returning the raw underlying file descriptor. Read more
This is supported on Windows only.
Extracts the underlying raw socket from this object.
This is supported on Windows only.
Creates a new I/O object from the given raw socket. Read more
This is supported on Windows only.
Consumes this object, returning the raw underlying socket. Read more
Formats the value using the given formatter. Read more
type Error = !
🔬 This is a nightly-only experimental API. (
try_from
#33417)
The type returned in the event of a conversion error.
🔬 This is a nightly-only experimental API. (
try_from
#33417)
type Error = <U as TryFrom<T>>::Error
🔬 This is a nightly-only experimental API. (
try_from
#33417)
The type returned in the event of a conversion error.
🔬 This is a nightly-only experimental API. (
try_from
#33417)
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more
🔬 This is a nightly-only experimental API. (get_type_id
#27745)
this method will likely be replaced by an associated static