src/net/tcp.rs - third_party/mio - Git at Google

 //! Primitives for working with TCP

 use std::io::{Read, Write};
 use std::net::{self, SocketAddr, SocketAddrV4, SocketAddrV6, Ipv4Addr, Ipv6Addr};

 use net2::TcpBuilder;

 use {io, sys, Evented, Ready, Poll, PollOpt, Token};
 use super::SelectorId;

 /*
  *
  * ===== TcpStream =====
  *
  */

 #[derive(Debug)]
 pub struct TcpStream {
     sys: sys::TcpStream,
     selector_id: SelectorId,
 }

 pub use std::net::Shutdown;

 impl TcpStream {
     /// Create a new TCP stream an issue a non-blocking connect to the specified
     /// address.
     ///
     /// This convenience method is available and uses the system's default
     /// options when creating a socket which is then conntected. If fine-grained
     /// control over the creation of the socket is desired, you can use
     /// `net2::TcpBuilder` to configure a socket and then pass its socket to
     /// `TcpStream::connect_stream` to transfer ownership into mio and schedule
     /// the connect operation.
     pub fn connect(addr: &SocketAddr) -> io::Result<TcpStream> {
         let sock = try!(match *addr {
             SocketAddr::V4(..) => TcpBuilder::new_v4(),
             SocketAddr::V6(..) => TcpBuilder::new_v6(),
         });
         // Required on Windows for a future `connect_overlapped` operation to be
         // executed successfully.
         if cfg!(windows) {
             try!(sock.bind(&inaddr_any(addr)));
         }
         TcpStream::connect_stream(try!(sock.to_tcp_stream()), addr)
     }

     /// Creates a new `TcpStream` from the pending socket inside the given
     /// `std::net::TcpBuilder`, connecting it to the address specified.
     ///
     /// This constructor allows configuring the socket before it's actually
     /// connected, and this function will transfer ownership to the returned
     /// `TcpStream` if successful. An unconnected `TcpStream` can be created
     /// with the `net2::TcpBuilder` type (and also configured via that route).
     ///
     /// The platform specific behavior of this function looks like:
     ///
     /// * On Unix, the socket is placed into nonblocking mode and then a
     ///   `connect` call is issued.
     ///
     /// * On Windows, the address is stored internally and the connect operation
     ///   is issued when the returned `TcpStream` is registered with an event
     ///   loop. Note that on Windows you must `bind` a socket before it can be
     ///   connected, so if a custom `TcpBuilder` is used it should be bound
     ///   (perhaps to `INADDR_ANY`) before this method is called.
     pub fn connect_stream(stream: net::TcpStream,
                           addr: &SocketAddr) -> io::Result<TcpStream> {
         Ok(TcpStream {
             sys: try!(sys::TcpStream::connect(stream, addr)),
             selector_id: SelectorId::new(),
         })
     }

     /// Returns the socket address of the remote peer of this TCP connection.
     pub fn peer_addr(&self) -> io::Result<SocketAddr> {
         self.sys.peer_addr()
     }

     /// Returns the socket address of the local half of this TCP connection.
     pub fn local_addr(&self) -> io::Result<SocketAddr> {
         self.sys.local_addr()
     }

     /// Creates a new independently owned handle to the underlying socket.
     ///
     /// The returned `TcpStream` is a reference to the same stream that this
     /// object references. Both handles will read and write the same stream of
     /// data, and options set on one stream will be propagated to the other
     /// stream.
     pub fn try_clone(&self) -> io::Result<TcpStream> {
         self.sys.try_clone().map(|s| {
             TcpStream {
                 sys: s,
                 selector_id: self.selector_id.clone(),
             }
         })
     }

     /// 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`).
     pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
         self.sys.shutdown(how)
     }

     /// 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.
     pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {
         self.sys.set_nodelay(nodelay)
     }

     /// Gets the value of the `TCP_NODELAY` option on this socket.
     ///
     /// For more information about this option, see [`set_nodelay`][link].
     ///
     /// [link]: #method.set_nodelay
     pub fn nodelay(&self) -> io::Result<bool> {
         self.sys.nodelay()
     }

     /// 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 number of milliseconds specified will be the time to remain idle
     /// before sending a TCP keepalive probe.
     ///
     /// Some platforms specify this value in seconds, so sub-second millisecond
     /// specifications may be omitted.
     pub fn set_keepalive_ms(&self, keepalive: Option<u32>) -> io::Result<()> {
         self.sys.set_keepalive_ms(keepalive)
     }

     /// Returns whether keepalive messages are enabled on this socket, and if so
     /// the amount of milliseconds between them.
     ///
     /// For more information about this option, see [`set_keepalive_ms`][link].
     ///
     /// [link]: #method.set_keepalive_ms
     pub fn keepalive_ms(&self) -> io::Result<Option<u32>> {
         self.sys.keepalive_ms()
     }

     /// 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 set_ttl(&self, ttl: u32) -> io::Result<()> {
         self.sys.set_ttl(ttl)
     }

     /// Gets the value of the `IP_TTL` option for this socket.
     ///
     /// For more information about this option, see [`set_ttl`][link].
     ///
     /// [link]: #method.set_ttl
     pub fn ttl(&self) -> io::Result<u32> {
         self.sys.ttl()
     }

     /// 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.
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
         self.sys.take_error()
     }
 }

 fn inaddr_any(other: &SocketAddr) -> SocketAddr {
     match *other {
         SocketAddr::V4(..) => {
             let any = Ipv4Addr::new(0, 0, 0, 0);
             let addr = SocketAddrV4::new(any, 0);
             SocketAddr::V4(addr)
         }
         SocketAddr::V6(..) => {
             let any = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0);
             let addr = SocketAddrV6::new(any, 0, 0, 0);
             SocketAddr::V6(addr)
         }
     }
 }

 impl Read for TcpStream {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         (&self.sys).read(buf)
     }
 }

 impl<'a> Read for &'a TcpStream {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         (&self.sys).read(buf)
     }
 }

 impl Write for TcpStream {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         (&self.sys).write(buf)
     }

     fn flush(&mut self) -> io::Result<()> {
         (&self.sys).flush()
     }
 }

 impl<'a> Write for &'a TcpStream {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         (&self.sys).write(buf)
     }

     fn flush(&mut self) -> io::Result<()> {
         (&self.sys).flush()
     }
 }

 impl Evented for TcpStream {
     fn register(&self, poll: &Poll, token: Token,
                 interest: Ready, opts: PollOpt) -> io::Result<()> {
         try!(self.selector_id.associate_selector(poll));
         self.sys.register(poll, token, interest, opts)
     }

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

     fn deregister(&self, poll: &Poll) -> io::Result<()> {
         self.sys.deregister(poll)
     }
 }

 /*
  *
  * ===== TcpListener =====
  *
  */

 #[derive(Debug)]
 pub struct TcpListener {
     sys: sys::TcpListener,
     selector_id: SelectorId,
 }

 impl 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 bind(addr: &SocketAddr) -> io::Result<TcpListener> {
         // Create the socket
         let sock = try!(match *addr {
             SocketAddr::V4(..) => TcpBuilder::new_v4(),
             SocketAddr::V6(..) => TcpBuilder::new_v6(),
         });

         // Set SO_REUSEADDR, but only on Unix (mirrors what libstd does)
         if cfg!(unix) {
             try!(sock.reuse_address(true));
         }

         // Bind the socket
         try!(sock.bind(addr));

         // listen
         let listener = try!(sock.listen(1024));
         Ok(TcpListener {
             sys: try!(sys::TcpListener::new(listener, addr)),
             selector_id: SelectorId::new(),
         })
     }

     /// 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 from_listener(listener: net::TcpListener, addr: &SocketAddr)
                          -> io::Result<TcpListener> {
         sys::TcpListener::new(listener, addr).map(|s| {
             TcpListener {
                 sys: s,
                 selector_id: SelectorId::new(),
             }
         })
     }

     /// Accepts a new `TcpStream`.
     ///
     /// Returns a `Ok(None)` when the socket `WOULDBLOCK`, this means the stream
     /// will be ready at a later point. If an accepted stream is returned, the
     /// address of the peer is returned along with it
     pub fn accept(&self) -> io::Result<(TcpStream, SocketAddr)> {
         self.sys.accept().map(|(s, a)| {
             let stream = TcpStream {
                 sys: s,
                 selector_id: SelectorId::new(),
             };

             (stream, a)
         })
     }

     /// Returns the local socket address of this listener.
     pub fn local_addr(&self) -> io::Result<SocketAddr> {
         self.sys.local_addr()
     }

     /// 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 try_clone(&self) -> io::Result<TcpListener> {
         self.sys.try_clone().map(|s| {
             TcpListener {
                 sys: s,
                 selector_id: self.selector_id.clone(),
             }
         })
     }

     /// 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 set_ttl(&self, ttl: u32) -> io::Result<()> {
         self.sys.set_ttl(ttl)
     }

     /// Gets the value of the `IP_TTL` option for this socket.
     ///
     /// For more information about this option, see [`set_ttl`][link].
     ///
     /// [link]: #method.set_ttl
     pub fn ttl(&self) -> io::Result<u32> {
         self.sys.ttl()
     }

     /// 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 set_only_v6(&self, only_v6: bool) -> io::Result<()> {
         self.sys.set_only_v6(only_v6)
     }

     /// Gets the value of the `IPV6_V6ONLY` option for this socket.
     ///
     /// For more information about this option, see [`set_only_v6`][link].
     ///
     /// [link]: #method.set_only_v6
     pub fn only_v6(&self) -> io::Result<bool> {
         self.sys.only_v6()
     }

     /// 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.
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
         self.sys.take_error()
     }
 }

 impl Evented for TcpListener {
     fn register(&self, poll: &Poll, token: Token,
                 interest: Ready, opts: PollOpt) -> io::Result<()> {
         try!(self.selector_id.associate_selector(poll));
         self.sys.register(poll, token, interest, opts)
     }

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

     fn deregister(&self, poll: &Poll) -> io::Result<()> {
         self.sys.deregister(poll)
     }
 }

 /*
  *
  * ===== UNIX ext =====
  *
  */

 #[cfg(unix)]
 use std::os::unix::io::{IntoRawFd, AsRawFd, FromRawFd, RawFd};

 #[cfg(unix)]
 impl IntoRawFd for TcpStream {
     fn into_raw_fd(self) -> RawFd {
         self.sys.into_raw_fd()
     }
 }

 #[cfg(unix)]
 impl AsRawFd for TcpStream {
     fn as_raw_fd(&self) -> RawFd {
         self.sys.as_raw_fd()
     }
 }

 #[cfg(unix)]
 impl FromRawFd for TcpStream {
     unsafe fn from_raw_fd(fd: RawFd) -> TcpStream {
         TcpStream {
             sys: FromRawFd::from_raw_fd(fd),
             selector_id: SelectorId::new(),
         }
     }
 }

 #[cfg(unix)]
 impl IntoRawFd for TcpListener {
     fn into_raw_fd(self) -> RawFd {
         self.sys.into_raw_fd()
     }
 }

 #[cfg(unix)]
 impl AsRawFd for TcpListener {
     fn as_raw_fd(&self) -> RawFd {
         self.sys.as_raw_fd()
     }
 }

 #[cfg(unix)]
 impl FromRawFd for TcpListener {
     unsafe fn from_raw_fd(fd: RawFd) -> TcpListener {
         TcpListener {
             sys: FromRawFd::from_raw_fd(fd),
             selector_id: SelectorId::new(),
         }
     }
 }
	//! Primitives for working with TCP

	use std::io::{Read, Write};
	use std::net::{self, SocketAddr, SocketAddrV4, SocketAddrV6, Ipv4Addr, Ipv6Addr};

	use net2::TcpBuilder;

	use {io, sys, Evented, Ready, Poll, PollOpt, Token};
	use super::SelectorId;

	/*
	*
	* ===== TcpStream =====
	*
	*/

	#[derive(Debug)]
	pub struct TcpStream {
	sys: sys::TcpStream,
	selector_id: SelectorId,
	}

	pub use std::net::Shutdown;

	impl TcpStream {
	/// Create a new TCP stream an issue a non-blocking connect to the specified
	/// address.
	///
	/// This convenience method is available and uses the system's default
	/// options when creating a socket which is then conntected. If fine-grained
	/// control over the creation of the socket is desired, you can use
	/// `net2::TcpBuilder` to configure a socket and then pass its socket to
	/// `TcpStream::connect_stream` to transfer ownership into mio and schedule
	/// the connect operation.
	pub fn connect(addr: &SocketAddr) -> io::Result<TcpStream> {
	let sock = try!(match *addr {
	SocketAddr::V4(..) => TcpBuilder::new_v4(),
	SocketAddr::V6(..) => TcpBuilder::new_v6(),
	});
	// Required on Windows for a future `connect_overlapped` operation to be
	// executed successfully.
	if cfg!(windows) {
	try!(sock.bind(&inaddr_any(addr)));
	}
	TcpStream::connect_stream(try!(sock.to_tcp_stream()), addr)
	}

	/// Creates a new `TcpStream` from the pending socket inside the given
	/// `std::net::TcpBuilder`, connecting it to the address specified.
	///
	/// This constructor allows configuring the socket before it's actually
	/// connected, and this function will transfer ownership to the returned
	/// `TcpStream` if successful. An unconnected `TcpStream` can be created
	/// with the `net2::TcpBuilder` type (and also configured via that route).
	///
	/// The platform specific behavior of this function looks like:
	///
	/// * On Unix, the socket is placed into nonblocking mode and then a
	/// `connect` call is issued.
	///
	/// * On Windows, the address is stored internally and the connect operation
	/// is issued when the returned `TcpStream` is registered with an event
	/// loop. Note that on Windows you must `bind` a socket before it can be
	/// connected, so if a custom `TcpBuilder` is used it should be bound
	/// (perhaps to `INADDR_ANY`) before this method is called.
	pub fn connect_stream(stream: net::TcpStream,
	addr: &SocketAddr) -> io::Result<TcpStream> {
	Ok(TcpStream {
	sys: try!(sys::TcpStream::connect(stream, addr)),
	selector_id: SelectorId::new(),
	})
	}

	/// Returns the socket address of the remote peer of this TCP connection.
	pub fn peer_addr(&self) -> io::Result<SocketAddr> {
	self.sys.peer_addr()
	}

	/// Returns the socket address of the local half of this TCP connection.
	pub fn local_addr(&self) -> io::Result<SocketAddr> {
	self.sys.local_addr()
	}

	/// Creates a new independently owned handle to the underlying socket.
	///
	/// The returned `TcpStream` is a reference to the same stream that this
	/// object references. Both handles will read and write the same stream of
	/// data, and options set on one stream will be propagated to the other
	/// stream.
	pub fn try_clone(&self) -> io::Result<TcpStream> {
	self.sys.try_clone().map(\|s\| {
	TcpStream {
	sys: s,
	selector_id: self.selector_id.clone(),
	}
	})
	}

	/// 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`).
	pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
	self.sys.shutdown(how)
	}

	/// 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.
	pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {
	self.sys.set_nodelay(nodelay)
	}

	/// Gets the value of the `TCP_NODELAY` option on this socket.
	///
	/// For more information about this option, see [`set_nodelay`][link].
	///
	/// [link]: #method.set_nodelay
	pub fn nodelay(&self) -> io::Result<bool> {
	self.sys.nodelay()
	}

	/// 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 number of milliseconds specified will be the time to remain idle
	/// before sending a TCP keepalive probe.
	///
	/// Some platforms specify this value in seconds, so sub-second millisecond
	/// specifications may be omitted.
	pub fn set_keepalive_ms(&self, keepalive: Option<u32>) -> io::Result<()> {
	self.sys.set_keepalive_ms(keepalive)
	}

	/// Returns whether keepalive messages are enabled on this socket, and if so
	/// the amount of milliseconds between them.
	///
	/// For more information about this option, see [`set_keepalive_ms`][link].
	///
	/// [link]: #method.set_keepalive_ms
	pub fn keepalive_ms(&self) -> io::Result<Option<u32>> {
	self.sys.keepalive_ms()
	}

	/// 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 set_ttl(&self, ttl: u32) -> io::Result<()> {
	self.sys.set_ttl(ttl)
	}

	/// Gets the value of the `IP_TTL` option for this socket.
	///
	/// For more information about this option, see [`set_ttl`][link].
	///
	/// [link]: #method.set_ttl
	pub fn ttl(&self) -> io::Result<u32> {
	self.sys.ttl()
	}

	/// 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.
	pub fn take_error(&self) -> io::Result<Option<io::Error>> {
	self.sys.take_error()
	}
	}

	fn inaddr_any(other: &SocketAddr) -> SocketAddr {
	match *other {
	SocketAddr::V4(..) => {
	let any = Ipv4Addr::new(0, 0, 0, 0);
	let addr = SocketAddrV4::new(any, 0);
	SocketAddr::V4(addr)
	}
	SocketAddr::V6(..) => {
	let any = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0);
	let addr = SocketAddrV6::new(any, 0, 0, 0);
	SocketAddr::V6(addr)
	}
	}
	}

	impl Read for TcpStream {
	fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
	(&self.sys).read(buf)
	}
	}

	impl<'a> Read for &'a TcpStream {
	fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
	(&self.sys).read(buf)
	}
	}

	impl Write for TcpStream {
	fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
	(&self.sys).write(buf)
	}

	fn flush(&mut self) -> io::Result<()> {
	(&self.sys).flush()
	}
	}

	impl<'a> Write for &'a TcpStream {
	fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
	(&self.sys).write(buf)
	}

	fn flush(&mut self) -> io::Result<()> {
	(&self.sys).flush()
	}
	}

	impl Evented for TcpStream {
	fn register(&self, poll: &Poll, token: Token,
	interest: Ready, opts: PollOpt) -> io::Result<()> {
	try!(self.selector_id.associate_selector(poll));
	self.sys.register(poll, token, interest, opts)
	}

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

	fn deregister(&self, poll: &Poll) -> io::Result<()> {
	self.sys.deregister(poll)
	}
	}

	/*
	*
	* ===== TcpListener =====
	*
	*/

	#[derive(Debug)]
	pub struct TcpListener {
	sys: sys::TcpListener,
	selector_id: SelectorId,
	}

	impl 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 bind(addr: &SocketAddr) -> io::Result<TcpListener> {
	// Create the socket
	let sock = try!(match *addr {
	SocketAddr::V4(..) => TcpBuilder::new_v4(),
	SocketAddr::V6(..) => TcpBuilder::new_v6(),
	});

	// Set SO_REUSEADDR, but only on Unix (mirrors what libstd does)
	if cfg!(unix) {
	try!(sock.reuse_address(true));
	}

	// Bind the socket
	try!(sock.bind(addr));

	// listen
	let listener = try!(sock.listen(1024));
	Ok(TcpListener {
	sys: try!(sys::TcpListener::new(listener, addr)),
	selector_id: SelectorId::new(),
	})
	}

	/// 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 from_listener(listener: net::TcpListener, addr: &SocketAddr)
	-> io::Result<TcpListener> {
	sys::TcpListener::new(listener, addr).map(\|s\| {
	TcpListener {
	sys: s,
	selector_id: SelectorId::new(),
	}
	})
	}

	/// Accepts a new `TcpStream`.
	///
	/// Returns a `Ok(None)` when the socket `WOULDBLOCK`, this means the stream
	/// will be ready at a later point. If an accepted stream is returned, the
	/// address of the peer is returned along with it
	pub fn accept(&self) -> io::Result<(TcpStream, SocketAddr)> {
	self.sys.accept().map(\|(s, a)\| {
	let stream = TcpStream {
	sys: s,
	selector_id: SelectorId::new(),
	};

	(stream, a)
	})
	}

	/// Returns the local socket address of this listener.
	pub fn local_addr(&self) -> io::Result<SocketAddr> {
	self.sys.local_addr()
	}

	/// 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 try_clone(&self) -> io::Result<TcpListener> {
	self.sys.try_clone().map(\|s\| {
	TcpListener {
	sys: s,
	selector_id: self.selector_id.clone(),
	}
	})
	}

	/// 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 set_ttl(&self, ttl: u32) -> io::Result<()> {
	self.sys.set_ttl(ttl)
	}

	/// Gets the value of the `IP_TTL` option for this socket.
	///
	/// For more information about this option, see [`set_ttl`][link].
	///
	/// [link]: #method.set_ttl
	pub fn ttl(&self) -> io::Result<u32> {
	self.sys.ttl()
	}

	/// 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 set_only_v6(&self, only_v6: bool) -> io::Result<()> {
	self.sys.set_only_v6(only_v6)
	}

	/// Gets the value of the `IPV6_V6ONLY` option for this socket.
	///
	/// For more information about this option, see [`set_only_v6`][link].
	///
	/// [link]: #method.set_only_v6
	pub fn only_v6(&self) -> io::Result<bool> {
	self.sys.only_v6()
	}

	/// 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.
	pub fn take_error(&self) -> io::Result<Option<io::Error>> {
	self.sys.take_error()
	}
	}

	impl Evented for TcpListener {
	fn register(&self, poll: &Poll, token: Token,
	interest: Ready, opts: PollOpt) -> io::Result<()> {
	try!(self.selector_id.associate_selector(poll));
	self.sys.register(poll, token, interest, opts)
	}

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

	fn deregister(&self, poll: &Poll) -> io::Result<()> {
	self.sys.deregister(poll)
	}
	}

	/*
	*
	* ===== UNIX ext =====
	*
	*/

	#[cfg(unix)]
	use std::os::unix::io::{IntoRawFd, AsRawFd, FromRawFd, RawFd};

	#[cfg(unix)]
	impl IntoRawFd for TcpStream {
	fn into_raw_fd(self) -> RawFd {
	self.sys.into_raw_fd()
	}
	}

	#[cfg(unix)]
	impl AsRawFd for TcpStream {
	fn as_raw_fd(&self) -> RawFd {
	self.sys.as_raw_fd()
	}
	}

	#[cfg(unix)]
	impl FromRawFd for TcpStream {
	unsafe fn from_raw_fd(fd: RawFd) -> TcpStream {
	TcpStream {
	sys: FromRawFd::from_raw_fd(fd),
	selector_id: SelectorId::new(),
	}
	}
	}

	#[cfg(unix)]
	impl IntoRawFd for TcpListener {
	fn into_raw_fd(self) -> RawFd {
	self.sys.into_raw_fd()
	}
	}

	#[cfg(unix)]
	impl AsRawFd for TcpListener {
	fn as_raw_fd(&self) -> RawFd {
	self.sys.as_raw_fd()
	}
	}

	#[cfg(unix)]
	impl FromRawFd for TcpListener {
	unsafe fn from_raw_fd(fd: RawFd) -> TcpListener {
	TcpListener {
	sys: FromRawFd::from_raw_fd(fd),
	selector_id: SelectorId::new(),
	}
	}
	}