# Struct std::net::TcpListener [−] [src]

    pub struct TcpListener(_);

A structure representing a socket server.

# Examples

fn main() { use std::net::{TcpListener, TcpStream}; use std::thread; let listener = TcpListener::bind("127.0.0.1:80").unwrap(); fn handle_client(stream: TcpStream) { // ... } // accept connections and process them, spawning a new thread for each one for stream in listener.incoming() { match stream { Ok(stream) => { thread::spawn(move|| { // connection succeeded handle_client(stream) }); } Err(e) => { /* connection failed */ } } } // close the socket server drop(listener); }

    use std::net::{TcpListener, TcpStream};
    use std::thread;

    let listener = TcpListener::bind("127.0.0.1:80").unwrap();

    fn handle_client(stream: TcpStream) {
        // ...
    }

    // accept connections and process them, spawning a new thread for each one
    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                thread::spawn(move|| {
                    // connection succeeded
                    handle_client(stream)
                });
            }
            Err(e) => { /* connection failed */ }
        }
    }

    // close the socket server
    drop(listener);

## Methods

### `impl TcpListener`

#### `fn bind<A: ToSocketAddrs>(addr: A) -> Result<TcpListener>`

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.

#### `fn local_addr(&self) -> Result<SocketAddr>`

Returns the local socket address of this listener.

#### `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.

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

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.

#### `fn incoming(&self) -> Incoming`

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.

## Trait Implementations

### `impl Debug for TcpListener`

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

### `impl AsRawFd for TcpListener`

#### `fn as_raw_fd(&self) -> RawFd`

### `impl FromRawFd for TcpListener`

#### `unsafe fn from_raw_fd(fd: RawFd) -> TcpListener`

### `impl IntoRawFd for TcpListener`

#### `fn into_raw_fd(self) -> RawFd`

### `impl AsRawFd for TcpListener`

#### `fn as_raw_fd(&self) -> RawFd`

### `impl FromRawFd for TcpListener`

#### `unsafe fn from_raw_fd(fd: RawFd) -> TcpListener`

### `impl IntoRawFd for TcpListener`

#### `fn into_raw_fd(self) -> RawFd`

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize`)