Struct mio::net::TcpListener

pub struct TcpListener { /* fields omitted */ }

A structure representing a socket server

Examples

use mio::{Events, Ready, Poll, PollOpt, Token};
use mio::net::TcpListener;
use std::time::Duration;

let listener = TcpListener::bind(&"127.0.0.1:34255".parse()?)?;

let poll = Poll::new()?;
let mut events = Events::with_capacity(128);

// Register the socket with `Poll`
poll.register(&listener, Token(0), Ready::readable(),
              PollOpt::edge())?;

poll.poll(&mut events, Some(Duration::from_millis(100)))?;

// There may be a socket ready to be accepted

Methods

impl TcpListener

pub fn bind(addr: &SocketAddr) -> Result<TcpListener>

Convenience method to bind a new TCP listener to the specified address to receive new connections.

This function will take the following steps:

1. Create a new TCP socket.
2. Set the SO_REUSEADDR option on the socket.
3. Bind the socket to the specified address.
4. Call listen on the socket to prepare it to receive new connections.

If fine-grained control over the binding and listening process for a socket is desired then the net2::TcpBuilder methods can be used in combination with the TcpListener::from_listener method to transfer ownership into mio.

pub fn from_std(listener: TcpListener) -> Result<TcpListener>

Creates a new TcpListener from an instance of a std::net::TcpListener type.

This function will set the listener provided into nonblocking mode on Unix, and otherwise the stream will just be wrapped up in an mio stream ready to accept new connections and become associated with an event loop.

The address provided must be the address that the listener is bound to.

pub fn accept(&self) -> Result<(TcpStream, SocketAddr)>

Accepts a new TcpStream.

This may return an Err(e) where e.kind() is io::ErrorKind::WouldBlock. This means a stream may be ready at a later point and one should wait for a notification before calling accept again.

If an accepted stream is returned, the remote address of the peer is returned along with it.

pub fn accept_std(&self) -> Result<(TcpStream, SocketAddr)>

Accepts a new std::net::TcpStream.

This method is the same as accept, except that it returns a TCP socket in blocking mode which isn't bound to mio. This can be later then converted to a mio type, if necessary.

pub fn local_addr(&self) -> Result<SocketAddr>

Returns the local socket address of this listener.

pub fn try_clone(&self) -> Result<TcpListener>

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.

pub fn set_ttl(&self, ttl: u32) -> Result<()>

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.

pub fn ttl(&self) -> Result<u32>

Gets the value of the IP_TTL option for this socket.

For more information about this option, see set_ttl.

pub fn set_only_v6(&self, only_v6: bool) -> Result<()>

Sets the value for the IPV6_V6ONLY option on this socket.

If this is set to true then the socket is restricted to sending and receiving IPv6 packets only. In this case two IPv4 and IPv6 applications can bind the same port at the same time.

If this is set to false then the socket can be used to send and receive packets from an IPv4-mapped IPv6 address.

pub fn only_v6(&self) -> Result<bool>

Gets the value of the IPV6_V6ONLY option for this socket.

For more information about this option, see set_only_v6.

pub fn take_error(&self) -> Result<Option<Error>>

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.

Trait Implementations

impl AsRawFd for TcpListener

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl Debug for TcpListener

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

Formats the value using the given formatter.

impl Evented for TcpListener

fn register(
    &self,
    poll: &Poll,
    token: Token,
    interest: Ready,
    opts: PollOpt
) -> Result<()>

Register self with the given Poll instance.

fn reregister(
    &self,
    poll: &Poll,
    token: Token,
    interest: Ready,
    opts: PollOpt
) -> Result<()>

Re-register self with the given Poll instance.

fn deregister(&self, poll: &Poll) -> Result<()>

Deregister self from the given Poll instance

impl FromRawFd for TcpListener

unsafe fn from_raw_fd(fd: RawFd) -> TcpListener

Constructs a new instance of Self from the given raw file descriptor.

impl IntoRawFd for TcpListener

fn into_raw_fd(self) -> RawFd

Consumes this object, returning the raw underlying file descriptor.