library/std/src/sys_common/net.rs

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