Creates a newTcpListener which will be bound to the specifiedaddress.

The returned listener is ready for accepting connections.

Binding with a port number of 0 will request that the OS assigns a portto this listener. The port allocated can be queried via theTcpListener::local_addr method.

The address type can be any implementor ofToSocketAddrs trait. Seeits documentation for concrete examples.

Ifaddr yields multiple addresses,bind will be attempted witheach of the addresses until one succeeds and returns the listener. Ifnone of the addresses succeed in creating a listener, the error returnedfrom the last attempt (the last address) is returned.

§Examples

Creates a TCP listener bound to127.0.0.1:80:

usestd::net::TcpListener;letlistener = TcpListener::bind("127.0.0.1:80").unwrap();

Creates a TCP listener bound to127.0.0.1:80. If that fails, create aTCP listener bound to127.0.0.1:443:

usestd::net::{SocketAddr, TcpListener};letaddrs = [    SocketAddr::from(([127,0,0,1],80)),    SocketAddr::from(([127,0,0,1],443)),];letlistener = TcpListener::bind(&addrs[..]).unwrap();

Creates a TCP listener bound to a port assigned by the operating systemat127.0.0.1.

usestd::net::TcpListener;letsocket = TcpListener::bind("127.0.0.1:0").unwrap();

Returns the local socket address of this listener.

§Examples

usestd::net::{Ipv4Addr, SocketAddr, SocketAddrV4, TcpListener};letlistener = 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)));

Creates a new independently owned handle to the underlying socket.

The returnedTcpListener is a reference to the same socket that thisobject references. Both handles can be used to accept incomingconnections and options set on one listener will affect the other.

§Examples

usestd::net::TcpListener;letlistener = TcpListener::bind("127.0.0.1:8080").unwrap();letlistener_clone = listener.try_clone().unwrap();

Accept a new incoming connection from this listener.

This function will block the calling thread until a new TCP connectionis established. When established, the correspondingTcpStream and theremote peer’s address will be returned.

§Examples

usestd::net::TcpListener;letlistener = TcpListener::bind("127.0.0.1:8080").unwrap();matchlistener.accept() {Ok((_socket, addr)) =>println!("new client: {addr:?}"),Err(e) =>println!("couldn't get client: {e:?}"),}

Returns an iterator over the connections being received on thislistener.

The returned iterator will never returnNone and will also not yieldthe peer’sSocketAddr structure. Iterating over it is equivalent tocallingTcpListener::accept in a loop.

§Examples

usestd::net::{TcpListener, TcpStream};fnhandle_connection(stream: TcpStream) {//...}fnmain() -> std::io::Result<()> {letlistener = TcpListener::bind("127.0.0.1:80")?;forstreaminlistener.incoming() {matchstream {Ok(stream) => {                handle_connection(stream);            }Err(e) => {/* connection failed */}        }    }Ok(())}

Turn this into an iterator over the connections being received on thislistener.

The returned iterator will never returnNone and will also not yieldthe peer’sSocketAddr structure. Iterating over it is equivalent tocallingTcpListener::accept in a loop.

§Examples

#![feature(tcplistener_into_incoming)]usestd::net::{TcpListener, TcpStream};fnlisten_on(port: u16) ->implIterator<Item = TcpStream> {letlistener = TcpListener::bind(("127.0.0.1", port)).unwrap();    listener.into_incoming()        .filter_map(Result::ok)/* Ignore failed connections */}fnmain() -> std::io::Result<()> {forstreaminlisten_on(80) {/* handle the connection here */}Ok(())}

Sets the value for theIP_TTL option on this socket.

This value sets the time-to-live field that is used in every packet sentfrom this socket.

§Examples

usestd::net::TcpListener;letlistener = TcpListener::bind("127.0.0.1:80").unwrap();listener.set_ttl(100).expect("could not set TTL");

Gets the value of theIP_TTL option for this socket.

For more information about this option, seeTcpListener::set_ttl.

§Examples

usestd::net::TcpListener;letlistener = 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);

Gets the value of theSO_ERROR option on this socket.

This will retrieve the stored error in the underlying socket, clearingthe field in the process. This can be useful for checking errors betweencalls.

§Examples

usestd::net::TcpListener;letlistener = TcpListener::bind("127.0.0.1:80").unwrap();listener.take_error().expect("No error was expected");

Moves this TCP stream into or out of nonblocking mode.

This will result in theaccept operation becoming nonblocking,i.e., immediately returning from their calls. If the IO operation issuccessful,Ok is returned and no further action is required. If theIO operation could not be completed and needs to be retried, an errorwith kindio::ErrorKind::WouldBlock is returned.

On Unix platforms, calling this method corresponds to callingfcntlFIONBIO. On Windows calling this method corresponds to callingioctlsocketFIONBIO.

§Examples

Bind a TCP listener to an address, listen for connections, and readbytes in nonblocking mode:

usestd::io;usestd::net::TcpListener;letlistener = TcpListener::bind("127.0.0.1:7878").unwrap();listener.set_nonblocking(true).expect("Cannot set non-blocking");forstreaminlistener.incoming() {matchstream {Ok(s) => {// do something with the TcpStreamhandle_connection(s);        }Err(refe)ife.kind() == io::ErrorKind::WouldBlock => {// wait until network socket is ready, typically implemented            // via platform-specific APIs such as epoll or IOCPwait_for_fd();continue;        }Err(e) =>panic!("encountered IO error: {e}"),    }}

Takes ownership of aTcpListener’s socket file descriptor.

Takes ownership of aTcpListener’s socket.

Returns the argument unchanged.

CallsU::from(self).

That is, this conversion is whatever the implementation ofFrom<T> for U chooses to do.