src/libstd/sys_common/net.rs

   1 use crate::cmp;
   2 use crate::convert::{TryFrom, TryInto};
   3 use crate::ffi::CString;
   4 use crate::fmt;
   5 use crate::io::{self, Error, ErrorKind, IoSlice, IoSliceMut};
   6 use crate::mem;
   7 use crate::net::{Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr};
   8 use crate::ptr;
   9 use crate::sys::net::netc as c;
  10 use crate::sys::net::{cvt, cvt_gai, cvt_r, init, wrlen_t, Socket};
  11 use crate::sys_common::{AsInner, FromInner, IntoInner};
  12 use crate::time::Duration;
  13
  14 use libc::{c_int, c_void};
  15 #[cfg(any(target_os = "dragonfly", target_os = "freebsd",
  16           target_os = "openbsd", target_os = "netbsd",
  17           target_os = "solaris"))]
  18 use libc::{c_uchar};
  19
  20 #[cfg(not(any(
  21     target_os = "dragonfly",
  22     target_os = "freebsd",
  23     target_os = "ios",
  24     target_os = "macos",
  25     target_os = "openbsd",
  26     target_os = "netbsd",
  27     target_os = "solaris",
  28     target_os = "haiku",
  29     target_os = "l4re"
  30 )))]
  31 use crate::sys::net::netc::IPV6_ADD_MEMBERSHIP;
  32 #[cfg(not(any(
  33     target_os = "dragonfly",
  34     target_os = "freebsd",
  35     target_os = "ios",
  36     target_os = "macos",
  37     target_os = "openbsd",
  38     target_os = "netbsd",
  39     target_os = "solaris",
  40     target_os = "haiku",
  41     target_os = "l4re"
  42 )))]
  43 use crate::sys::net::netc::IPV6_DROP_MEMBERSHIP;
  44 #[cfg(any(
  45     target_os = "dragonfly",
  46     target_os = "freebsd",
  47     target_os = "ios",
  48     target_os = "macos",
  49     target_os = "openbsd",
  50     target_os = "netbsd",
  51     target_os = "solaris",
  52     target_os = "haiku",
  53     target_os = "l4re"
  54 ))]
  55 use crate::sys::net::netc::IPV6_JOIN_GROUP as IPV6_ADD_MEMBERSHIP;
  56 #[cfg(any(
  57     target_os = "dragonfly",
  58     target_os = "freebsd",
  59     target_os = "ios",
  60     target_os = "macos",
  61     target_os = "openbsd",
  62     target_os = "netbsd",
  63     target_os = "solaris",
  64     target_os = "haiku",
  65     target_os = "l4re"
  66 ))]
  67 use crate::sys::net::netc::IPV6_LEAVE_GROUP as IPV6_DROP_MEMBERSHIP;
  68
  69 #[cfg(any(
  70     target_os = "linux",
  71     target_os = "android",
  72     target_os = "dragonfly",
  73     target_os = "freebsd",
  74     target_os = "openbsd",
  75     target_os = "netbsd",
  76     target_os = "haiku"
  77 ))]
  78 use libc::MSG_NOSIGNAL;
  79 #[cfg(not(any(
  80     target_os = "linux",
  81     target_os = "android",
  82     target_os = "dragonfly",
  83     target_os = "freebsd",
  84     target_os = "openbsd",
  85     target_os = "netbsd",
  86     target_os = "haiku"
  87 )))]
  88 const MSG_NOSIGNAL: c_int = 0x0;
  89
  90 ////////////////////////////////////////////////////////////////////////////////
  91 // sockaddr and misc bindings
  92 ////////////////////////////////////////////////////////////////////////////////
  93
  94 pub fn setsockopt<T>(sock: &Socket, opt: c_int, val: c_int, payload: T) -> io::Result<()> {
  95     unsafe {
  96         let payload = &payload as *const T as *const c_void;
  97         cvt(c::setsockopt(
  98             *sock.as_inner(),
  99             opt,
 100             val,
 101             payload,
 102             mem::size_of::<T>() as c::socklen_t,
 103         ))?;
 104         Ok(())
 105     }
 106 }
 107
 108 pub fn getsockopt<T: Copy>(sock: &Socket, opt: c_int, val: c_int) -> io::Result<T> {
 109     unsafe {
 110         let mut slot: T = mem::zeroed();
 111         let mut len = mem::size_of::<T>() as c::socklen_t;
 112         cvt(c::getsockopt(*sock.as_inner(), opt, val, &mut slot as *mut _ as *mut _, &mut len))?;
 113         assert_eq!(len as usize, mem::size_of::<T>());
 114         Ok(slot)
 115     }
 116 }
 117
 118 fn sockname<F>(f: F) -> io::Result<SocketAddr>
 119 where
 120     F: FnOnce(*mut c::sockaddr, *mut c::socklen_t) -> c_int,
 121 {
 122     unsafe {
 123         let mut storage: c::sockaddr_storage = mem::zeroed();
 124         let mut len = mem::size_of_val(&storage) as c::socklen_t;
 125         cvt(f(&mut storage as *mut _ as *mut _, &mut len))?;
 126         sockaddr_to_addr(&storage, len as usize)
 127     }
 128 }
 129
 130 pub fn sockaddr_to_addr(storage: &c::sockaddr_storage, len: usize) -> io::Result<SocketAddr> {
 131     match storage.ss_family as c_int {
 132         c::AF_INET => {
 133             assert!(len as usize >= mem::size_of::<c::sockaddr_in>());
 134             Ok(SocketAddr::V4(FromInner::from_inner(unsafe {
 135                 *(storage as *const _ as *const c::sockaddr_in)
 136             })))
 137         }
 138         c::AF_INET6 => {
 139             assert!(len as usize >= mem::size_of::<c::sockaddr_in6>());
 140             Ok(SocketAddr::V6(FromInner::from_inner(unsafe {
 141                 *(storage as *const _ as *const c::sockaddr_in6)
 142             })))
 143         }
 144         _ => Err(Error::new(ErrorKind::InvalidInput, "invalid argument")),
 145     }
 146 }
 147
 148 #[cfg(target_os = "android")]
 149 fn to_ipv6mr_interface(value: u32) -> c_int {
 150     value as c_int
 151 }
 152
 153 #[cfg(not(target_os = "android"))]
 154 fn to_ipv6mr_interface(value: u32) -> libc::c_uint {
 155     value as libc::c_uint
 156 }
 157
 158 ////////////////////////////////////////////////////////////////////////////////
 159 // get_host_addresses
 160 ////////////////////////////////////////////////////////////////////////////////
 161
 162 pub struct LookupHost {
 163     original: *mut c::addrinfo,
 164     cur: *mut c::addrinfo,
 165     port: u16,
 166 }
 167
 168 impl LookupHost {
 169     pub fn port(&self) -> u16 {
 170         self.port
 171     }
 172 }
 173
 174 impl Iterator for LookupHost {
 175     type Item = SocketAddr;
 176     fn next(&mut self) -> Option<SocketAddr> {
 177         loop {
 178             unsafe {
 179                 let cur = self.cur.as_ref()?;
 180                 self.cur = cur.ai_next;
 181                 match sockaddr_to_addr(mem::transmute(cur.ai_addr), cur.ai_addrlen as usize) {
 182                     Ok(addr) => return Some(addr),
 183                     Err(_) => continue,
 184                 }
 185             }
 186         }
 187     }
 188 }
 189
 190 unsafe impl Sync for LookupHost {}
 191 unsafe impl Send for LookupHost {}
 192
 193 impl Drop for LookupHost {
 194     fn drop(&mut self) {
 195         unsafe { c::freeaddrinfo(self.original) }
 196     }
 197 }
 198
 199 impl TryFrom<&str> for LookupHost {
 200     type Error = io::Error;
 201
 202     fn try_from(s: &str) -> io::Result<LookupHost> {
 203         macro_rules! try_opt {
 204             ($e:expr, $msg:expr) => {
 205                 match $e {
 206                     Some(r) => r,
 207                     None => return Err(io::Error::new(io::ErrorKind::InvalidInput, $msg)),
 208                 }
 209             };
 210         }
 211
 212         // split the string by ':' and convert the second part to u16
 213         let mut parts_iter = s.rsplitn(2, ':');
 214         let port_str = try_opt!(parts_iter.next(), "invalid socket address");
 215         let host = try_opt!(parts_iter.next(), "invalid socket address");
 216         let port: u16 = try_opt!(port_str.parse().ok(), "invalid port value");
 217
 218         (host, port).try_into()
 219     }
 220 }
 221
 222 impl<'a> TryFrom<(&'a str, u16)> for LookupHost {
 223     type Error = io::Error;
 224
 225     fn try_from((host, port): (&'a str, u16)) -> io::Result<LookupHost> {
 226         init();
 227
 228         let c_host = CString::new(host)?;
 229         let mut hints: c::addrinfo = unsafe { mem::zeroed() };
 230         hints.ai_socktype = c::SOCK_STREAM;
 231         let mut res = ptr::null_mut();
 232         unsafe {
 233             cvt_gai(c::getaddrinfo(c_host.as_ptr(), ptr::null(), &hints, &mut res))
 234                 .map(|_| LookupHost { original: res, cur: res, port })
 235         }
 236     }
 237 }
 238
 239 ////////////////////////////////////////////////////////////////////////////////
 240 // TCP streams
 241 ////////////////////////////////////////////////////////////////////////////////
 242
 243 pub struct TcpStream {
 244     inner: Socket,
 245 }
 246
 247 impl TcpStream {
 248     pub fn connect(addr: io::Result<&SocketAddr>) -> io::Result<TcpStream> {
 249         let addr = addr?;
 250
 251         init();
 252
 253         let sock = Socket::new(addr, c::SOCK_STREAM)?;
 254
 255         let (addrp, len) = addr.into_inner();
 256         cvt_r(|| unsafe { c::connect(*sock.as_inner(), addrp, len) })?;
 257         Ok(TcpStream { inner: sock })
 258     }
 259
 260     pub fn connect_timeout(addr: &SocketAddr, timeout: Duration) -> io::Result<TcpStream> {
 261         init();
 262
 263         let sock = Socket::new(addr, c::SOCK_STREAM)?;
 264         sock.connect_timeout(addr, timeout)?;
 265         Ok(TcpStream { inner: sock })
 266     }
 267
 268     pub fn socket(&self) -> &Socket {
 269         &self.inner
 270     }
 271
 272     pub fn into_socket(self) -> Socket {
 273         self.inner
 274     }
 275
 276     pub fn set_read_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
 277         self.inner.set_timeout(dur, c::SO_RCVTIMEO)
 278     }
 279
 280     pub fn set_write_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
 281         self.inner.set_timeout(dur, c::SO_SNDTIMEO)
 282     }
 283
 284     pub fn read_timeout(&self) -> io::Result<Option<Duration>> {
 285         self.inner.timeout(c::SO_RCVTIMEO)
 286     }
 287
 288     pub fn write_timeout(&self) -> io::Result<Option<Duration>> {
 289         self.inner.timeout(c::SO_SNDTIMEO)
 290     }
 291
 292     pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
 293         self.inner.peek(buf)
 294     }
 295
 296     pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
 297         self.inner.read(buf)
 298     }
 299
 300     pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
 301         self.inner.read_vectored(bufs)
 302     }
 303
 304     pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
 305         let len = cmp::min(buf.len(), <wrlen_t>::max_value() as usize) as wrlen_t;
 306         let ret = cvt(unsafe {
 307             c::send(*self.inner.as_inner(), buf.as_ptr() as *const c_void, len, MSG_NOSIGNAL)
 308         })?;
 309         Ok(ret as usize)
 310     }
 311
 312     pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
 313         self.inner.write_vectored(bufs)
 314     }
 315
 316     pub fn peer_addr(&self) -> io::Result<SocketAddr> {
 317         sockname(|buf, len| unsafe { c::getpeername(*self.inner.as_inner(), buf, len) })
 318     }
 319
 320     pub fn socket_addr(&self) -> io::Result<SocketAddr> {
 321         sockname(|buf, len| unsafe { c::getsockname(*self.inner.as_inner(), buf, len) })
 322     }
 323
 324     pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
 325         self.inner.shutdown(how)
 326     }
 327
 328     pub fn duplicate(&self) -> io::Result<TcpStream> {
 329         self.inner.duplicate().map(|s| TcpStream { inner: s })
 330     }
 331
 332     pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {
 333         self.inner.set_nodelay(nodelay)
 334     }
 335
 336     pub fn nodelay(&self) -> io::Result<bool> {
 337         self.inner.nodelay()
 338     }
 339
 340     pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
 341         setsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL, ttl as c_int)
 342     }
 343
 344     pub fn ttl(&self) -> io::Result<u32> {
 345         let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL)?;
 346         Ok(raw as u32)
 347     }
 348
 349     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
 350         self.inner.take_error()
 351     }
 352
 353     pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
 354         self.inner.set_nonblocking(nonblocking)
 355     }
 356 }
 357
 358 impl FromInner<Socket> for TcpStream {
 359     fn from_inner(socket: Socket) -> TcpStream {
 360         TcpStream { inner: socket }
 361     }
 362 }
 363
 364 impl fmt::Debug for TcpStream {
 365     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 366         let mut res = f.debug_struct("TcpStream");
 367
 368         if let Ok(addr) = self.socket_addr() {
 369             res.field("addr", &addr);
 370         }
 371
 372         if let Ok(peer) = self.peer_addr() {
 373             res.field("peer", &peer);
 374         }
 375
 376         let name = if cfg!(windows) { "socket" } else { "fd" };
 377         res.field(name, &self.inner.as_inner()).finish()
 378     }
 379 }
 380
 381 ////////////////////////////////////////////////////////////////////////////////
 382 // TCP listeners
 383 ////////////////////////////////////////////////////////////////////////////////
 384
 385 pub struct TcpListener {
 386     inner: Socket,
 387 }
 388
 389 impl TcpListener {
 390     pub fn bind(addr: io::Result<&SocketAddr>) -> io::Result<TcpListener> {
 391         let addr = addr?;
 392
 393         init();
 394
 395         let sock = Socket::new(addr, c::SOCK_STREAM)?;
 396
 397         // On platforms with Berkeley-derived sockets, this allows
 398         // to quickly rebind a socket, without needing to wait for
 399         // the OS to clean up the previous one.
 400         if !cfg!(windows) {
 401             setsockopt(&sock, c::SOL_SOCKET, c::SO_REUSEADDR, 1 as c_int)?;
 402         }
 403
 404         // Bind our new socket
 405         let (addrp, len) = addr.into_inner();
 406         cvt(unsafe { c::bind(*sock.as_inner(), addrp, len as _) })?;
 407
 408         // Start listening
 409         cvt(unsafe { c::listen(*sock.as_inner(), 128) })?;
 410         Ok(TcpListener { inner: sock })
 411     }
 412
 413     pub fn socket(&self) -> &Socket {
 414         &self.inner
 415     }
 416
 417     pub fn into_socket(self) -> Socket {
 418         self.inner
 419     }
 420
 421     pub fn socket_addr(&self) -> io::Result<SocketAddr> {
 422         sockname(|buf, len| unsafe { c::getsockname(*self.inner.as_inner(), buf, len) })
 423     }
 424
 425     pub fn accept(&self) -> io::Result<(TcpStream, SocketAddr)> {
 426         let mut storage: c::sockaddr_storage = unsafe { mem::zeroed() };
 427         let mut len = mem::size_of_val(&storage) as c::socklen_t;
 428         let sock = self.inner.accept(&mut storage as *mut _ as *mut _, &mut len)?;
 429         let addr = sockaddr_to_addr(&storage, len as usize)?;
 430         Ok((TcpStream { inner: sock }, addr))
 431     }
 432
 433     pub fn duplicate(&self) -> io::Result<TcpListener> {
 434         self.inner.duplicate().map(|s| TcpListener { inner: s })
 435     }
 436
 437     pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
 438         setsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL, ttl as c_int)
 439     }
 440
 441     pub fn ttl(&self) -> io::Result<u32> {
 442         let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL)?;
 443         Ok(raw as u32)
 444     }
 445
 446     pub fn set_only_v6(&self, only_v6: bool) -> io::Result<()> {
 447         setsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_V6ONLY, only_v6 as c_int)
 448     }
 449
 450     pub fn only_v6(&self) -> io::Result<bool> {
 451         let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_V6ONLY)?;
 452         Ok(raw != 0)
 453     }
 454
 455     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
 456         self.inner.take_error()
 457     }
 458
 459     pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
 460         self.inner.set_nonblocking(nonblocking)
 461     }
 462 }
 463
 464 impl FromInner<Socket> for TcpListener {
 465     fn from_inner(socket: Socket) -> TcpListener {
 466         TcpListener { inner: socket }
 467     }
 468 }
 469
 470 impl fmt::Debug for TcpListener {
 471     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 472         let mut res = f.debug_struct("TcpListener");
 473
 474         if let Ok(addr) = self.socket_addr() {
 475             res.field("addr", &addr);
 476         }
 477
 478         let name = if cfg!(windows) { "socket" } else { "fd" };
 479         res.field(name, &self.inner.as_inner()).finish()
 480     }
 481 }
 482
 483 ////////////////////////////////////////////////////////////////////////////////
 484 // UDP
 485 ////////////////////////////////////////////////////////////////////////////////
 486
 487 pub struct UdpSocket {
 488     inner: Socket,
 489 }
 490
 491 impl UdpSocket {
 492     pub fn bind(addr: io::Result<&SocketAddr>) -> io::Result<UdpSocket> {
 493         let addr = addr?;
 494
 495         init();
 496
 497         let sock = Socket::new(addr, c::SOCK_DGRAM)?;
 498         let (addrp, len) = addr.into_inner();
 499         cvt(unsafe { c::bind(*sock.as_inner(), addrp, len as _) })?;
 500         Ok(UdpSocket { inner: sock })
 501     }
 502
 503     pub fn socket(&self) -> &Socket {
 504         &self.inner
 505     }
 506
 507     pub fn into_socket(self) -> Socket {
 508         self.inner
 509     }
 510
 511     pub fn peer_addr(&self) -> io::Result<SocketAddr> {
 512         sockname(|buf, len| unsafe { c::getpeername(*self.inner.as_inner(), buf, len) })
 513     }
 514
 515     pub fn socket_addr(&self) -> io::Result<SocketAddr> {
 516         sockname(|buf, len| unsafe { c::getsockname(*self.inner.as_inner(), buf, len) })
 517     }
 518
 519     pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
 520         self.inner.recv_from(buf)
 521     }
 522
 523     pub fn peek_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
 524         self.inner.peek_from(buf)
 525     }
 526
 527     pub fn send_to(&self, buf: &[u8], dst: &SocketAddr) -> io::Result<usize> {
 528         let len = cmp::min(buf.len(), <wrlen_t>::max_value() as usize) as wrlen_t;
 529         let (dstp, dstlen) = dst.into_inner();
 530         let ret = cvt(unsafe {
 531             c::sendto(
 532                 *self.inner.as_inner(),
 533                 buf.as_ptr() as *const c_void,
 534                 len,
 535                 MSG_NOSIGNAL,
 536                 dstp,
 537                 dstlen,
 538             )
 539         })?;
 540         Ok(ret as usize)
 541     }
 542
 543     pub fn duplicate(&self) -> io::Result<UdpSocket> {
 544         self.inner.duplicate().map(|s| UdpSocket { inner: s })
 545     }
 546
 547     pub fn set_read_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
 548         self.inner.set_timeout(dur, c::SO_RCVTIMEO)
 549     }
 550
 551     pub fn set_write_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
 552         self.inner.set_timeout(dur, c::SO_SNDTIMEO)
 553     }
 554
 555     pub fn read_timeout(&self) -> io::Result<Option<Duration>> {
 556         self.inner.timeout(c::SO_RCVTIMEO)
 557     }
 558
 559     pub fn write_timeout(&self) -> io::Result<Option<Duration>> {
 560         self.inner.timeout(c::SO_SNDTIMEO)
 561     }
 562
 563     pub fn set_broadcast(&self, broadcast: bool) -> io::Result<()> {
 564         setsockopt(&self.inner, c::SOL_SOCKET, c::SO_BROADCAST, broadcast as c_int)
 565     }
 566
 567     pub fn broadcast(&self) -> io::Result<bool> {
 568         let raw: c_int = getsockopt(&self.inner, c::SOL_SOCKET, c::SO_BROADCAST)?;
 569         Ok(raw != 0)
 570     }
 571
 572     pub fn set_multicast_loop_v6(&self, multicast_loop_v6: bool) -> io::Result<()> {
 573         setsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_MULTICAST_LOOP, multicast_loop_v6 as c_int)
 574     }
 575
 576     pub fn multicast_loop_v6(&self) -> io::Result<bool> {
 577         let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_MULTICAST_LOOP)?;
 578         Ok(raw != 0)
 579     }
 580
 581     pub fn join_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> {
 582         let mreq = c::ip_mreq {
 583             imr_multiaddr: *multiaddr.as_inner(),
 584             imr_interface: *interface.as_inner(),
 585         };
 586         setsockopt(&self.inner, c::IPPROTO_IP, c::IP_ADD_MEMBERSHIP, mreq)
 587     }
 588
 589     pub fn join_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> {
 590         let mreq = c::ipv6_mreq {
 591             ipv6mr_multiaddr: *multiaddr.as_inner(),
 592             ipv6mr_interface: to_ipv6mr_interface(interface),
 593         };
 594         setsockopt(&self.inner, c::IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, mreq)
 595     }
 596
 597     pub fn leave_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> {
 598         let mreq = c::ip_mreq {
 599             imr_multiaddr: *multiaddr.as_inner(),
 600             imr_interface: *interface.as_inner(),
 601         };
 602         setsockopt(&self.inner, c::IPPROTO_IP, c::IP_DROP_MEMBERSHIP, mreq)
 603     }
 604
 605     pub fn leave_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> {
 606         let mreq = c::ipv6_mreq {
 607             ipv6mr_multiaddr: *multiaddr.as_inner(),
 608             ipv6mr_interface: to_ipv6mr_interface(interface),
 609         };
 610         setsockopt(&self.inner, c::IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, mreq)
 611     }
 612
 613     pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
 614         setsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL, ttl as c_int)
 615     }
 616
 617     pub fn ttl(&self) -> io::Result<u32> {
 618         let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL)?;
 619         Ok(raw as u32)
 620     }
 621
 622     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
 623         self.inner.take_error()
 624     }
 625
 626     pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
 627         self.inner.set_nonblocking(nonblocking)
 628     }
 629
 630     pub fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
 631         self.inner.read(buf)
 632     }
 633
 634     pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
 635         self.inner.peek(buf)
 636     }
 637
 638     pub fn send(&self, buf: &[u8]) -> io::Result<usize> {
 639         let len = cmp::min(buf.len(), <wrlen_t>::max_value() as usize) as wrlen_t;
 640         let ret = cvt(unsafe {
 641             c::send(*self.inner.as_inner(), buf.as_ptr() as *const c_void, len, MSG_NOSIGNAL)
 642         })?;
 643         Ok(ret as usize)
 644     }
 645
 646     pub fn connect(&self, addr: io::Result<&SocketAddr>) -> io::Result<()> {
 647         let (addrp, len) = addr?.into_inner();
 648         cvt_r(|| unsafe { c::connect(*self.inner.as_inner(), addrp, len) }).map(drop)
 649     }
 650 }
 651
 652 #[cfg(not(any(target_os = "dragonfly", target_os = "freebsd",
 653               target_os = "openbsd", target_os = "netbsd",
 654               target_os = "solaris")))]
 655 impl UdpSocket {
 656     pub fn set_multicast_loop_v4(&self, multicast_loop_v4: bool) -> io::Result<()> {
 657         setsockopt(&self.inner, c::IPPROTO_IP, c::IP_MULTICAST_LOOP, multicast_loop_v4 as c_int)
 658     }
 659
 660     pub fn multicast_loop_v4(&self) -> io::Result<bool> {
 661         let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IP, c::IP_MULTICAST_LOOP)?;
 662         Ok(raw != 0)
 663     }
 664
 665     pub fn set_multicast_ttl_v4(&self, multicast_ttl_v4: u32) -> io::Result<()> {
 666         setsockopt(&self.inner, c::IPPROTO_IP, c::IP_MULTICAST_TTL, multicast_ttl_v4 as c_int)
 667     }
 668
 669     pub fn multicast_ttl_v4(&self) -> io::Result<u32> {
 670         let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IP, c::IP_MULTICAST_TTL)?;
 671         Ok(raw as u32)
 672     }
 673 }
 674
 675 #[cfg(any(target_os = "dragonfly", target_os = "freebsd",
 676           target_os = "openbsd", target_os = "netbsd",
 677           target_os = "solaris"))]
 678 impl UdpSocket {
 679     pub fn set_multicast_loop_v4(&self, multicast_loop_v4: bool) -> io::Result<()> {
 680         setsockopt(&self.inner, c::IPPROTO_IP, c::IP_MULTICAST_LOOP, multicast_loop_v4 as c_uchar)
 681     }
 682
 683     pub fn multicast_loop_v4(&self) -> io::Result<bool> {
 684         let raw: c_uchar = getsockopt(&self.inner, c::IPPROTO_IP, c::IP_MULTICAST_LOOP)?;
 685         Ok(raw != 0)
 686     }
 687
 688     pub fn set_multicast_ttl_v4(&self, multicast_ttl_v4: u32) -> io::Result<()> {
 689         setsockopt(&self.inner, c::IPPROTO_IP, c::IP_MULTICAST_TTL, multicast_ttl_v4 as c_uchar)
 690     }
 691
 692     pub fn multicast_ttl_v4(&self) -> io::Result<u32> {
 693         let raw: c_uchar = getsockopt(&self.inner, c::IPPROTO_IP, c::IP_MULTICAST_TTL)?;
 694         Ok(raw as u32)
 695     }
 696 }
 697
 698 impl FromInner<Socket> for UdpSocket {
 699     fn from_inner(socket: Socket) -> UdpSocket {
 700         UdpSocket { inner: socket }
 701     }
 702 }
 703
 704 impl fmt::Debug for UdpSocket {
 705     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 706         let mut res = f.debug_struct("UdpSocket");
 707
 708         if let Ok(addr) = self.socket_addr() {
 709             res.field("addr", &addr);
 710         }
 711
 712         let name = if cfg!(windows) { "socket" } else { "fd" };
 713         res.field(name, &self.inner.as_inner()).finish()
 714     }
 715 }
 716
 717 #[cfg(test)]
 718 mod tests {
 719     use super::*;
 720     use crate::collections::HashMap;
 721
 722     #[test]
 723     fn no_lookup_host_duplicates() {
 724         let mut addrs = HashMap::new();
 725         let lh = match LookupHost::try_from(("localhost", 0)) {
 726             Ok(lh) => lh,
 727             Err(e) => panic!("couldn't resolve `localhost': {}", e),
 728         };
 729         for sa in lh {
 730             *addrs.entry(sa).or_insert(0) += 1;
 731         }
 732         assert_eq!(
 733             addrs.iter().filter(|&(_, &v)| v > 1).collect::<Vec<_>>(),
 734             vec![],
 735             "There should be no duplicate localhost entries"
 736         );
 737     }
 738 }