src/libstd/net/udp.rs

   1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use fmt;
  12 use io::{self, Error, ErrorKind};
  13 use net::{ToSocketAddrs, SocketAddr, Ipv4Addr, Ipv6Addr};
  14 use sys_common::net as net_imp;
  15 use sys_common::{AsInner, FromInner, IntoInner};
  16 use time::Duration;
  17
  18 /// A User Datagram Protocol socket.
  19 ///
  20 /// This is an implementation of a bound UDP socket. This supports both IPv4 and
  21 /// IPv6 addresses, and there is no corresponding notion of a server because UDP
  22 /// is a datagram protocol.
  23 ///
  24 /// # Examples
  25 ///
  26 /// ```no_run
  27 /// use std::net::UdpSocket;
  28 ///
  29 /// # fn foo() -> std::io::Result<()> {
  30 /// {
  31 ///     let mut socket = try!(UdpSocket::bind("127.0.0.1:34254"));
  32 ///
  33 ///     // read from the socket
  34 ///     let mut buf = [0; 10];
  35 ///     let (amt, src) = try!(socket.recv_from(&mut buf));
  36 ///
  37 ///     // send a reply to the socket we received data from
  38 ///     let buf = &mut buf[..amt];
  39 ///     buf.reverse();
  40 ///     try!(socket.send_to(buf, &src));
  41 ///     # Ok(())
  42 /// } // the socket is closed here
  43 /// # }
  44 /// ```
  45 #[stable(feature = "rust1", since = "1.0.0")]
  46 pub struct UdpSocket(net_imp::UdpSocket);
  47
  48 impl UdpSocket {
  49     /// Creates a UDP socket from the given address.
  50     ///
  51     /// The address type can be any implementor of `ToSocketAddr` trait. See
  52     /// its documentation for concrete examples.
  53     #[stable(feature = "rust1", since = "1.0.0")]
  54     pub fn bind<A: ToSocketAddrs>(addr: A) -> io::Result<UdpSocket> {
  55         super::each_addr(addr, net_imp::UdpSocket::bind).map(UdpSocket)
  56     }
  57
  58     /// Receives data from the socket. On success, returns the number of bytes
  59     /// read and the address from whence the data came.
  60     #[stable(feature = "rust1", since = "1.0.0")]
  61     pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
  62         self.0.recv_from(buf)
  63     }
  64
  65     /// Sends data on the socket to the given address. On success, returns the
  66     /// number of bytes written.
  67     ///
  68     /// Address type can be any implementor of `ToSocketAddrs` trait. See its
  69     /// documentation for concrete examples.
  70     #[stable(feature = "rust1", since = "1.0.0")]
  71     pub fn send_to<A: ToSocketAddrs>(&self, buf: &[u8], addr: A)
  72                                      -> io::Result<usize> {
  73         match addr.to_socket_addrs()?.next() {
  74             Some(addr) => self.0.send_to(buf, &addr),
  75             None => Err(Error::new(ErrorKind::InvalidInput,
  76                                    "no addresses to send data to")),
  77         }
  78     }
  79
  80     /// Returns the socket address that this socket was created from.
  81     #[stable(feature = "rust1", since = "1.0.0")]
  82     pub fn local_addr(&self) -> io::Result<SocketAddr> {
  83         self.0.socket_addr()
  84     }
  85
  86     /// Creates a new independently owned handle to the underlying socket.
  87     ///
  88     /// The returned `UdpSocket` is a reference to the same socket that this
  89     /// object references. Both handles will read and write the same port, and
  90     /// options set on one socket will be propagated to the other.
  91     #[stable(feature = "rust1", since = "1.0.0")]
  92     pub fn try_clone(&self) -> io::Result<UdpSocket> {
  93         self.0.duplicate().map(UdpSocket)
  94     }
  95
  96     /// Sets the read timeout to the timeout specified.
  97     ///
  98     /// If the value specified is `None`, then `read` calls will block
  99     /// indefinitely. It is an error to pass the zero `Duration` to this
 100     /// method.
 101     ///
 102     /// # Note
 103     ///
 104     /// Platforms may return a different error code whenever a read times out as
 105     /// a result of setting this option. For example Unix typically returns an
 106     /// error of the kind `WouldBlock`, but Windows may return `TimedOut`.
 107     #[stable(feature = "socket_timeout", since = "1.4.0")]
 108     pub fn set_read_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
 109         self.0.set_read_timeout(dur)
 110     }
 111
 112     /// Sets the write timeout to the timeout specified.
 113     ///
 114     /// If the value specified is `None`, then `write` calls will block
 115     /// indefinitely. It is an error to pass the zero `Duration` to this
 116     /// method.
 117     ///
 118     /// # Note
 119     ///
 120     /// Platforms may return a different error code whenever a write times out
 121     /// as a result of setting this option. For example Unix typically returns
 122     /// an error of the kind `WouldBlock`, but Windows may return `TimedOut`.
 123     #[stable(feature = "socket_timeout", since = "1.4.0")]
 124     pub fn set_write_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
 125         self.0.set_write_timeout(dur)
 126     }
 127
 128     /// Returns the read timeout of this socket.
 129     ///
 130     /// If the timeout is `None`, then `read` calls will block indefinitely.
 131     #[stable(feature = "socket_timeout", since = "1.4.0")]
 132     pub fn read_timeout(&self) -> io::Result<Option<Duration>> {
 133         self.0.read_timeout()
 134     }
 135
 136     /// Returns the write timeout of this socket.
 137     ///
 138     /// If the timeout is `None`, then `write` calls will block indefinitely.
 139     #[stable(feature = "socket_timeout", since = "1.4.0")]
 140     pub fn write_timeout(&self) -> io::Result<Option<Duration>> {
 141         self.0.write_timeout()
 142     }
 143
 144     /// Sets the value of the `SO_BROADCAST` option for this socket.
 145     ///
 146     /// When enabled, this socket is allowed to send packets to a broadcast
 147     /// address.
 148     #[stable(feature = "net2_mutators", since = "1.9.0")]
 149     pub fn set_broadcast(&self, broadcast: bool) -> io::Result<()> {
 150         self.0.set_broadcast(broadcast)
 151     }
 152
 153     /// Gets the value of the `SO_BROADCAST` option for this socket.
 154     ///
 155     /// For more information about this option, see
 156     /// [`set_broadcast`][link].
 157     ///
 158     /// [link]: #method.set_broadcast
 159     #[stable(feature = "net2_mutators", since = "1.9.0")]
 160     pub fn broadcast(&self) -> io::Result<bool> {
 161         self.0.broadcast()
 162     }
 163
 164     /// Sets the value of the `IP_MULTICAST_LOOP` option for this socket.
 165     ///
 166     /// If enabled, multicast packets will be looped back to the local socket.
 167     /// Note that this may not have any affect on IPv6 sockets.
 168     #[stable(feature = "net2_mutators", since = "1.9.0")]
 169     pub fn set_multicast_loop_v4(&self, multicast_loop_v4: bool) -> io::Result<()> {
 170         self.0.set_multicast_loop_v4(multicast_loop_v4)
 171     }
 172
 173     /// Gets the value of the `IP_MULTICAST_LOOP` option for this socket.
 174     ///
 175     /// For more information about this option, see
 176     /// [`set_multicast_loop_v4`][link].
 177     ///
 178     /// [link]: #method.set_multicast_loop_v4
 179     #[stable(feature = "net2_mutators", since = "1.9.0")]
 180     pub fn multicast_loop_v4(&self) -> io::Result<bool> {
 181         self.0.multicast_loop_v4()
 182     }
 183
 184     /// Sets the value of the `IP_MULTICAST_TTL` option for this socket.
 185     ///
 186     /// Indicates the time-to-live value of outgoing multicast packets for
 187     /// this socket. The default value is 1 which means that multicast packets
 188     /// don't leave the local network unless explicitly requested.
 189     ///
 190     /// Note that this may not have any affect on IPv6 sockets.
 191     #[stable(feature = "net2_mutators", since = "1.9.0")]
 192     pub fn set_multicast_ttl_v4(&self, multicast_ttl_v4: u32) -> io::Result<()> {
 193         self.0.set_multicast_ttl_v4(multicast_ttl_v4)
 194     }
 195
 196     /// Gets the value of the `IP_MULTICAST_TTL` option for this socket.
 197     ///
 198     /// For more information about this option, see
 199     /// [`set_multicast_ttl_v4`][link].
 200     ///
 201     /// [link]: #method.set_multicast_ttl_v4
 202     #[stable(feature = "net2_mutators", since = "1.9.0")]
 203     pub fn multicast_ttl_v4(&self) -> io::Result<u32> {
 204         self.0.multicast_ttl_v4()
 205     }
 206
 207     /// Sets the value of the `IPV6_MULTICAST_LOOP` option for this socket.
 208     ///
 209     /// Controls whether this socket sees the multicast packets it sends itself.
 210     /// Note that this may not have any affect on IPv4 sockets.
 211     #[stable(feature = "net2_mutators", since = "1.9.0")]
 212     pub fn set_multicast_loop_v6(&self, multicast_loop_v6: bool) -> io::Result<()> {
 213         self.0.set_multicast_loop_v6(multicast_loop_v6)
 214     }
 215
 216     /// Gets the value of the `IPV6_MULTICAST_LOOP` option for this socket.
 217     ///
 218     /// For more information about this option, see
 219     /// [`set_multicast_loop_v6`][link].
 220     ///
 221     /// [link]: #method.set_multicast_loop_v6
 222     #[stable(feature = "net2_mutators", since = "1.9.0")]
 223     pub fn multicast_loop_v6(&self) -> io::Result<bool> {
 224         self.0.multicast_loop_v6()
 225     }
 226
 227     /// Sets the value for the `IP_TTL` option on this socket.
 228     ///
 229     /// This value sets the time-to-live field that is used in every packet sent
 230     /// from this socket.
 231     #[stable(feature = "net2_mutators", since = "1.9.0")]
 232     pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
 233         self.0.set_ttl(ttl)
 234     }
 235
 236     /// Gets the value of the `IP_TTL` option for this socket.
 237     ///
 238     /// For more information about this option, see [`set_ttl`][link].
 239     ///
 240     /// [link]: #method.set_ttl
 241     #[stable(feature = "net2_mutators", since = "1.9.0")]
 242     pub fn ttl(&self) -> io::Result<u32> {
 243         self.0.ttl()
 244     }
 245
 246     /// Executes an operation of the `IP_ADD_MEMBERSHIP` type.
 247     ///
 248     /// This function specifies a new multicast group for this socket to join.
 249     /// The address must be a valid multicast address, and `interface` is the
 250     /// address of the local interface with which the system should join the
 251     /// multicast group. If it's equal to `INADDR_ANY` then an appropriate
 252     /// interface is chosen by the system.
 253     #[stable(feature = "net2_mutators", since = "1.9.0")]
 254     pub fn join_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> {
 255         self.0.join_multicast_v4(multiaddr, interface)
 256     }
 257
 258     /// Executes an operation of the `IPV6_ADD_MEMBERSHIP` type.
 259     ///
 260     /// This function specifies a new multicast group for this socket to join.
 261     /// The address must be a valid multicast address, and `interface` is the
 262     /// index of the interface to join/leave (or 0 to indicate any interface).
 263     #[stable(feature = "net2_mutators", since = "1.9.0")]
 264     pub fn join_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> {
 265         self.0.join_multicast_v6(multiaddr, interface)
 266     }
 267
 268     /// Executes an operation of the `IP_DROP_MEMBERSHIP` type.
 269     ///
 270     /// For more information about this option, see
 271     /// [`join_multicast_v4`][link].
 272     ///
 273     /// [link]: #method.join_multicast_v4
 274     #[stable(feature = "net2_mutators", since = "1.9.0")]
 275     pub fn leave_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> {
 276         self.0.leave_multicast_v4(multiaddr, interface)
 277     }
 278
 279     /// Executes an operation of the `IPV6_DROP_MEMBERSHIP` type.
 280     ///
 281     /// For more information about this option, see
 282     /// [`join_multicast_v6`][link].
 283     ///
 284     /// [link]: #method.join_multicast_v6
 285     #[stable(feature = "net2_mutators", since = "1.9.0")]
 286     pub fn leave_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> {
 287         self.0.leave_multicast_v6(multiaddr, interface)
 288     }
 289
 290     /// Get the value of the `SO_ERROR` option on this socket.
 291     ///
 292     /// This will retrieve the stored error in the underlying socket, clearing
 293     /// the field in the process. This can be useful for checking errors between
 294     /// calls.
 295     #[stable(feature = "net2_mutators", since = "1.9.0")]
 296     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
 297         self.0.take_error()
 298     }
 299
 300     /// Connects this UDP socket to a remote address, allowing the `send` and
 301     /// `recv` syscalls to be used to send data and also applies filters to only
 302     /// receive data from the specified address.
 303     #[stable(feature = "net2_mutators", since = "1.9.0")]
 304     pub fn connect<A: ToSocketAddrs>(&self, addr: A) -> io::Result<()> {
 305         super::each_addr(addr, |addr| self.0.connect(addr))
 306     }
 307
 308     /// Sends data on the socket to the remote address to which it is connected.
 309     ///
 310     /// The `connect` method will connect this socket to a remote address. This
 311     /// method will fail if the socket is not connected.
 312     #[stable(feature = "net2_mutators", since = "1.9.0")]
 313     pub fn send(&self, buf: &[u8]) -> io::Result<usize> {
 314         self.0.send(buf)
 315     }
 316
 317     /// Receives data on the socket from the remote address to which it is
 318     /// connected.
 319     ///
 320     /// The `connect` method will connect this socket to a remote address. This
 321     /// method will fail if the socket is not connected.
 322     #[stable(feature = "net2_mutators", since = "1.9.0")]
 323     pub fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
 324         self.0.recv(buf)
 325     }
 326
 327     /// Moves this UDP socket into or out of nonblocking mode.
 328     ///
 329     /// On Unix this corresponds to calling fcntl, and on Windows this
 330     /// corresponds to calling ioctlsocket.
 331     #[stable(feature = "net2_mutators", since = "1.9.0")]
 332     pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
 333         self.0.set_nonblocking(nonblocking)
 334     }
 335 }
 336
 337 impl AsInner<net_imp::UdpSocket> for UdpSocket {
 338     fn as_inner(&self) -> &net_imp::UdpSocket { &self.0 }
 339 }
 340
 341 impl FromInner<net_imp::UdpSocket> for UdpSocket {
 342     fn from_inner(inner: net_imp::UdpSocket) -> UdpSocket { UdpSocket(inner) }
 343 }
 344
 345 impl IntoInner<net_imp::UdpSocket> for UdpSocket {
 346     fn into_inner(self) -> net_imp::UdpSocket { self.0 }
 347 }
 348
 349 #[stable(feature = "rust1", since = "1.0.0")]
 350 impl fmt::Debug for UdpSocket {
 351     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 352         self.0.fmt(f)
 353     }
 354 }
 355
 356 #[cfg(test)]
 357 mod tests {
 358     use prelude::v1::*;
 359
 360     use io::ErrorKind;
 361     use net::*;
 362     use net::test::{next_test_ip4, next_test_ip6};
 363     use sync::mpsc::channel;
 364     use sys_common::AsInner;
 365     use time::{Instant, Duration};
 366     use thread;
 367
 368     fn each_ip(f: &mut FnMut(SocketAddr, SocketAddr)) {
 369         f(next_test_ip4(), next_test_ip4());
 370         f(next_test_ip6(), next_test_ip6());
 371     }
 372
 373     macro_rules! t {
 374         ($e:expr) => {
 375             match $e {
 376                 Ok(t) => t,
 377                 Err(e) => panic!("received error for `{}`: {}", stringify!($e), e),
 378             }
 379         }
 380     }
 381
 382     #[test]
 383     fn bind_error() {
 384         match UdpSocket::bind("1.1.1.1:9999") {
 385             Ok(..) => panic!(),
 386             Err(e) => {
 387                 assert_eq!(e.kind(), ErrorKind::AddrNotAvailable)
 388             }
 389         }
 390     }
 391
 392     #[test]
 393     fn socket_smoke_test_ip4() {
 394         each_ip(&mut |server_ip, client_ip| {
 395             let (tx1, rx1) = channel();
 396             let (tx2, rx2) = channel();
 397
 398             let _t = thread::spawn(move|| {
 399                 let client = t!(UdpSocket::bind(&client_ip));
 400                 rx1.recv().unwrap();
 401                 t!(client.send_to(&[99], &server_ip));
 402                 tx2.send(()).unwrap();
 403             });
 404
 405             let server = t!(UdpSocket::bind(&server_ip));
 406             tx1.send(()).unwrap();
 407             let mut buf = [0];
 408             let (nread, src) = t!(server.recv_from(&mut buf));
 409             assert_eq!(nread, 1);
 410             assert_eq!(buf[0], 99);
 411             assert_eq!(src, client_ip);
 412             rx2.recv().unwrap();
 413         })
 414     }
 415
 416     #[test]
 417     fn socket_name_ip4() {
 418         each_ip(&mut |addr, _| {
 419             let server = t!(UdpSocket::bind(&addr));
 420             assert_eq!(addr, t!(server.local_addr()));
 421         })
 422     }
 423
 424     #[test]
 425     fn udp_clone_smoke() {
 426         each_ip(&mut |addr1, addr2| {
 427             let sock1 = t!(UdpSocket::bind(&addr1));
 428             let sock2 = t!(UdpSocket::bind(&addr2));
 429
 430             let _t = thread::spawn(move|| {
 431                 let mut buf = [0, 0];
 432                 assert_eq!(sock2.recv_from(&mut buf).unwrap(), (1, addr1));
 433                 assert_eq!(buf[0], 1);
 434                 t!(sock2.send_to(&[2], &addr1));
 435             });
 436
 437             let sock3 = t!(sock1.try_clone());
 438
 439             let (tx1, rx1) = channel();
 440             let (tx2, rx2) = channel();
 441             let _t = thread::spawn(move|| {
 442                 rx1.recv().unwrap();
 443                 t!(sock3.send_to(&[1], &addr2));
 444                 tx2.send(()).unwrap();
 445             });
 446             tx1.send(()).unwrap();
 447             let mut buf = [0, 0];
 448             assert_eq!(sock1.recv_from(&mut buf).unwrap(), (1, addr2));
 449             rx2.recv().unwrap();
 450         })
 451     }
 452
 453     #[test]
 454     fn udp_clone_two_read() {
 455         each_ip(&mut |addr1, addr2| {
 456             let sock1 = t!(UdpSocket::bind(&addr1));
 457             let sock2 = t!(UdpSocket::bind(&addr2));
 458             let (tx1, rx) = channel();
 459             let tx2 = tx1.clone();
 460
 461             let _t = thread::spawn(move|| {
 462                 t!(sock2.send_to(&[1], &addr1));
 463                 rx.recv().unwrap();
 464                 t!(sock2.send_to(&[2], &addr1));
 465                 rx.recv().unwrap();
 466             });
 467
 468             let sock3 = t!(sock1.try_clone());
 469
 470             let (done, rx) = channel();
 471             let _t = thread::spawn(move|| {
 472                 let mut buf = [0, 0];
 473                 t!(sock3.recv_from(&mut buf));
 474                 tx2.send(()).unwrap();
 475                 done.send(()).unwrap();
 476             });
 477             let mut buf = [0, 0];
 478             t!(sock1.recv_from(&mut buf));
 479             tx1.send(()).unwrap();
 480
 481             rx.recv().unwrap();
 482         })
 483     }
 484
 485     #[test]
 486     fn udp_clone_two_write() {
 487         each_ip(&mut |addr1, addr2| {
 488             let sock1 = t!(UdpSocket::bind(&addr1));
 489             let sock2 = t!(UdpSocket::bind(&addr2));
 490
 491             let (tx, rx) = channel();
 492             let (serv_tx, serv_rx) = channel();
 493
 494             let _t = thread::spawn(move|| {
 495                 let mut buf = [0, 1];
 496                 rx.recv().unwrap();
 497                 t!(sock2.recv_from(&mut buf));
 498                 serv_tx.send(()).unwrap();
 499             });
 500
 501             let sock3 = t!(sock1.try_clone());
 502
 503             let (done, rx) = channel();
 504             let tx2 = tx.clone();
 505             let _t = thread::spawn(move|| {
 506                 match sock3.send_to(&[1], &addr2) {
 507                     Ok(..) => { let _ = tx2.send(()); }
 508                     Err(..) => {}
 509                 }
 510                 done.send(()).unwrap();
 511             });
 512             match sock1.send_to(&[2], &addr2) {
 513                 Ok(..) => { let _ = tx.send(()); }
 514                 Err(..) => {}
 515             }
 516             drop(tx);
 517
 518             rx.recv().unwrap();
 519             serv_rx.recv().unwrap();
 520         })
 521     }
 522
 523     #[test]
 524     fn debug() {
 525         let name = if cfg!(windows) {"socket"} else {"fd"};
 526         let socket_addr = next_test_ip4();
 527
 528         let udpsock = t!(UdpSocket::bind(&socket_addr));
 529         let udpsock_inner = udpsock.0.socket().as_inner();
 530         let compare = format!("UdpSocket {{ addr: {:?}, {}: {:?} }}",
 531                               socket_addr, name, udpsock_inner);
 532         assert_eq!(format!("{:?}", udpsock), compare);
 533     }
 534
 535     // FIXME: re-enabled bitrig/openbsd/netbsd tests once their socket timeout code
 536     //        no longer has rounding errors.
 537     #[cfg_attr(any(target_os = "bitrig", target_os = "netbsd", target_os = "openbsd"), ignore)]
 538     #[test]
 539     fn timeouts() {
 540         let addr = next_test_ip4();
 541
 542         let stream = t!(UdpSocket::bind(&addr));
 543         let dur = Duration::new(15410, 0);
 544
 545         assert_eq!(None, t!(stream.read_timeout()));
 546
 547         t!(stream.set_read_timeout(Some(dur)));
 548         assert_eq!(Some(dur), t!(stream.read_timeout()));
 549
 550         assert_eq!(None, t!(stream.write_timeout()));
 551
 552         t!(stream.set_write_timeout(Some(dur)));
 553         assert_eq!(Some(dur), t!(stream.write_timeout()));
 554
 555         t!(stream.set_read_timeout(None));
 556         assert_eq!(None, t!(stream.read_timeout()));
 557
 558         t!(stream.set_write_timeout(None));
 559         assert_eq!(None, t!(stream.write_timeout()));
 560     }
 561
 562     #[test]
 563     fn test_read_timeout() {
 564         let addr = next_test_ip4();
 565
 566         let stream = t!(UdpSocket::bind(&addr));
 567         t!(stream.set_read_timeout(Some(Duration::from_millis(1000))));
 568
 569         let mut buf = [0; 10];
 570
 571         let start = Instant::now();
 572         let kind = stream.recv_from(&mut buf).err().expect("expected error").kind();
 573         assert!(kind == ErrorKind::WouldBlock || kind == ErrorKind::TimedOut);
 574         assert!(start.elapsed() > Duration::from_millis(400));
 575     }
 576
 577     #[test]
 578     fn test_read_with_timeout() {
 579         let addr = next_test_ip4();
 580
 581         let stream = t!(UdpSocket::bind(&addr));
 582         t!(stream.set_read_timeout(Some(Duration::from_millis(1000))));
 583
 584         t!(stream.send_to(b"hello world", &addr));
 585
 586         let mut buf = [0; 11];
 587         t!(stream.recv_from(&mut buf));
 588         assert_eq!(b"hello world", &buf[..]);
 589
 590         let start = Instant::now();
 591         let kind = stream.recv_from(&mut buf).err().expect("expected error").kind();
 592         assert!(kind == ErrorKind::WouldBlock || kind == ErrorKind::TimedOut);
 593         assert!(start.elapsed() > Duration::from_millis(400));
 594     }
 595
 596     #[test]
 597     fn connect_send_recv() {
 598         let addr = next_test_ip4();
 599
 600         let socket = t!(UdpSocket::bind(&addr));
 601         t!(socket.connect(addr));
 602
 603         t!(socket.send(b"hello world"));
 604
 605         let mut buf = [0; 11];
 606         t!(socket.recv(&mut buf));
 607         assert_eq!(b"hello world", &buf[..]);
 608     }
 609
 610     #[test]
 611     fn ttl() {
 612         let ttl = 100;
 613
 614         let addr = next_test_ip4();
 615
 616         let stream = t!(UdpSocket::bind(&addr));
 617
 618         t!(stream.set_ttl(ttl));
 619         assert_eq!(ttl, t!(stream.ttl()));
 620     }
 621
 622     #[test]
 623     fn set_nonblocking() {
 624         let addr = next_test_ip4();
 625
 626         let stream = t!(UdpSocket::bind(&addr));
 627
 628         t!(stream.set_nonblocking(true));
 629         t!(stream.set_nonblocking(false));
 630     }
 631 }