1#[cfg(test)]
2mod tests;
3
4use crate::ffi::{c_int, c_void};
5use crate::io::{self, BorrowedCursor, ErrorKind, IoSlice, IoSliceMut};
6use crate::net::{Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr, SocketAddrV4, SocketAddrV6};
7use crate::sys::common::small_c_string::run_with_cstr;
8use crate::sys_common::{AsInner, FromInner};
9use crate::time::Duration;
10use crate::{cmp, fmt, mem, ptr};
11
12cfg_if::cfg_if! {
13 if #[cfg(target_os = "hermit")] {
14 mod hermit;
15 pub use hermit::*;
16 } else if #[cfg(target_os = "solid_asp3")] {
17 mod solid;
18 pub use solid::*;
19 } else if #[cfg(target_family = "unix")] {
20 mod unix;
21 pub use unix::*;
22 } else if #[cfg(all(target_os = "wasi", target_env = "p2"))] {
23 mod wasip2;
24 pub use wasip2::*;
25 } else if #[cfg(target_os = "windows")] {
26 mod windows;
27 pub use windows::*;
28 }
29}
30
31use netc as c;
32
33cfg_if::cfg_if! {
34 if #[cfg(any(
35 target_os = "dragonfly",
36 target_os = "freebsd",
37 target_os = "openbsd",
38 target_os = "netbsd",
39 target_os = "illumos",
40 target_os = "solaris",
41 target_os = "haiku",
42 target_os = "l4re",
43 target_os = "nto",
44 target_os = "nuttx",
45 target_vendor = "apple",
46 ))] {
47 use c::IPV6_JOIN_GROUP as IPV6_ADD_MEMBERSHIP;
48 use c::IPV6_LEAVE_GROUP as IPV6_DROP_MEMBERSHIP;
49 } else {
50 use c::IPV6_ADD_MEMBERSHIP;
51 use c::IPV6_DROP_MEMBERSHIP;
52 }
53}
54
55cfg_if::cfg_if! {
56 if #[cfg(any(
57 target_os = "linux", target_os = "android",
58 target_os = "hurd",
59 target_os = "dragonfly", target_os = "freebsd",
60 target_os = "openbsd", target_os = "netbsd",
61 target_os = "solaris", target_os = "illumos",
62 target_os = "haiku", target_os = "nto"))] {
63 use libc::MSG_NOSIGNAL;
64 } else {
65 const MSG_NOSIGNAL: c_int = 0x0;
66 }
67}
68
69cfg_if::cfg_if! {
70 if #[cfg(any(
71 target_os = "dragonfly", target_os = "freebsd",
72 target_os = "openbsd", target_os = "netbsd",
73 target_os = "solaris", target_os = "illumos",
74 target_os = "nto"))] {
75 use crate::ffi::c_uchar;
76 type IpV4MultiCastType = c_uchar;
77 } else {
78 type IpV4MultiCastType = c_int;
79 }
80}
81
82fn ip_v4_addr_to_c(addr: &Ipv4Addr) -> c::in_addr {
87 c::in_addr { s_addr: u32::from_ne_bytes(addr.octets()) }
90}
91
92fn ip_v6_addr_to_c(addr: &Ipv6Addr) -> c::in6_addr {
93 c::in6_addr { s6_addr: addr.octets() }
94}
95
96fn ip_v4_addr_from_c(addr: c::in_addr) -> Ipv4Addr {
97 Ipv4Addr::from(addr.s_addr.to_ne_bytes())
98}
99
100fn ip_v6_addr_from_c(addr: c::in6_addr) -> Ipv6Addr {
101 Ipv6Addr::from(addr.s6_addr)
102}
103
104fn socket_addr_v4_to_c(addr: &SocketAddrV4) -> c::sockaddr_in {
105 c::sockaddr_in {
106 sin_family: c::AF_INET as c::sa_family_t,
107 sin_port: addr.port().to_be(),
108 sin_addr: ip_v4_addr_to_c(addr.ip()),
109 ..unsafe { mem::zeroed() }
110 }
111}
112
113fn socket_addr_v6_to_c(addr: &SocketAddrV6) -> c::sockaddr_in6 {
114 c::sockaddr_in6 {
115 sin6_family: c::AF_INET6 as c::sa_family_t,
116 sin6_port: addr.port().to_be(),
117 sin6_addr: ip_v6_addr_to_c(addr.ip()),
118 sin6_flowinfo: addr.flowinfo(),
119 sin6_scope_id: addr.scope_id(),
120 ..unsafe { mem::zeroed() }
121 }
122}
123
124fn socket_addr_v4_from_c(addr: c::sockaddr_in) -> SocketAddrV4 {
125 SocketAddrV4::new(ip_v4_addr_from_c(addr.sin_addr), u16::from_be(addr.sin_port))
126}
127
128fn socket_addr_v6_from_c(addr: c::sockaddr_in6) -> SocketAddrV6 {
129 SocketAddrV6::new(
130 ip_v6_addr_from_c(addr.sin6_addr),
131 u16::from_be(addr.sin6_port),
132 addr.sin6_flowinfo,
133 addr.sin6_scope_id,
134 )
135}
136
137#[repr(C)]
142union SocketAddrCRepr {
143 v4: c::sockaddr_in,
144 v6: c::sockaddr_in6,
145}
146
147impl SocketAddrCRepr {
148 fn as_ptr(&self) -> *const c::sockaddr {
149 self as *const _ as *const c::sockaddr
150 }
151}
152
153fn socket_addr_to_c(addr: &SocketAddr) -> (SocketAddrCRepr, c::socklen_t) {
154 match addr {
155 SocketAddr::V4(a) => {
156 let sockaddr = SocketAddrCRepr { v4: socket_addr_v4_to_c(a) };
157 (sockaddr, size_of::<c::sockaddr_in>() as c::socklen_t)
158 }
159 SocketAddr::V6(a) => {
160 let sockaddr = SocketAddrCRepr { v6: socket_addr_v6_to_c(a) };
161 (sockaddr, size_of::<c::sockaddr_in6>() as c::socklen_t)
162 }
163 }
164}
165
166unsafe fn socket_addr_from_c(
167 storage: *const c::sockaddr_storage,
168 len: usize,
169) -> io::Result<SocketAddr> {
170 match (*storage).ss_family as c_int {
171 c::AF_INET => {
172 assert!(len >= size_of::<c::sockaddr_in>());
173 Ok(SocketAddr::V4(socket_addr_v4_from_c(unsafe {
174 *(storage as *const _ as *const c::sockaddr_in)
175 })))
176 }
177 c::AF_INET6 => {
178 assert!(len >= size_of::<c::sockaddr_in6>());
179 Ok(SocketAddr::V6(socket_addr_v6_from_c(unsafe {
180 *(storage as *const _ as *const c::sockaddr_in6)
181 })))
182 }
183 _ => Err(io::const_error!(ErrorKind::InvalidInput, "invalid argument")),
184 }
185}
186
187pub fn setsockopt<T>(
192 sock: &Socket,
193 level: c_int,
194 option_name: c_int,
195 option_value: T,
196) -> io::Result<()> {
197 unsafe {
198 cvt(c::setsockopt(
199 sock.as_raw(),
200 level,
201 option_name,
202 (&raw const option_value) as *const _,
203 size_of::<T>() as c::socklen_t,
204 ))?;
205 Ok(())
206 }
207}
208
209pub fn getsockopt<T: Copy>(sock: &Socket, level: c_int, option_name: c_int) -> io::Result<T> {
210 unsafe {
211 let mut option_value: T = mem::zeroed();
212 let mut option_len = size_of::<T>() as c::socklen_t;
213 cvt(c::getsockopt(
214 sock.as_raw(),
215 level,
216 option_name,
217 (&raw mut option_value) as *mut _,
218 &mut option_len,
219 ))?;
220 Ok(option_value)
221 }
222}
223
224fn sockname<F>(f: F) -> io::Result<SocketAddr>
225where
226 F: FnOnce(*mut c::sockaddr, *mut c::socklen_t) -> c_int,
227{
228 unsafe {
229 let mut storage: c::sockaddr_storage = mem::zeroed();
230 let mut len = size_of_val(&storage) as c::socklen_t;
231 cvt(f((&raw mut storage) as *mut _, &mut len))?;
232 socket_addr_from_c(&storage, len as usize)
233 }
234}
235
236#[cfg(target_os = "android")]
237fn to_ipv6mr_interface(value: u32) -> c_int {
238 value as c_int
239}
240
241#[cfg(not(target_os = "android"))]
242fn to_ipv6mr_interface(value: u32) -> crate::ffi::c_uint {
243 value as crate::ffi::c_uint
244}
245
246pub struct LookupHost {
251 original: *mut c::addrinfo,
252 cur: *mut c::addrinfo,
253 port: u16,
254}
255
256impl LookupHost {
257 pub fn port(&self) -> u16 {
258 self.port
259 }
260}
261
262impl Iterator for LookupHost {
263 type Item = SocketAddr;
264 fn next(&mut self) -> Option<SocketAddr> {
265 loop {
266 unsafe {
267 let cur = self.cur.as_ref()?;
268 self.cur = cur.ai_next;
269 match socket_addr_from_c(cur.ai_addr.cast(), cur.ai_addrlen as usize) {
270 Ok(addr) => return Some(addr),
271 Err(_) => continue,
272 }
273 }
274 }
275 }
276}
277
278unsafe impl Sync for LookupHost {}
279unsafe impl Send for LookupHost {}
280
281impl Drop for LookupHost {
282 fn drop(&mut self) {
283 unsafe { c::freeaddrinfo(self.original) }
284 }
285}
286
287impl TryFrom<&str> for LookupHost {
288 type Error = io::Error;
289
290 fn try_from(s: &str) -> io::Result<LookupHost> {
291 macro_rules! try_opt {
292 ($e:expr, $msg:expr) => {
293 match $e {
294 Some(r) => r,
295 None => return Err(io::const_error!(io::ErrorKind::InvalidInput, $msg)),
296 }
297 };
298 }
299
300 let (host, port_str) = try_opt!(s.rsplit_once(':'), "invalid socket address");
302 let port: u16 = try_opt!(port_str.parse().ok(), "invalid port value");
303 (host, port).try_into()
304 }
305}
306
307impl<'a> TryFrom<(&'a str, u16)> for LookupHost {
308 type Error = io::Error;
309
310 fn try_from((host, port): (&'a str, u16)) -> io::Result<LookupHost> {
311 init();
312
313 run_with_cstr(host.as_bytes(), &|c_host| {
314 let mut hints: c::addrinfo = unsafe { mem::zeroed() };
315 hints.ai_socktype = c::SOCK_STREAM;
316 let mut res = ptr::null_mut();
317 unsafe {
318 cvt_gai(c::getaddrinfo(c_host.as_ptr(), ptr::null(), &hints, &mut res))
319 .map(|_| LookupHost { original: res, cur: res, port })
320 }
321 })
322 }
323}
324
325pub struct TcpStream {
330 inner: Socket,
331}
332
333impl TcpStream {
334 pub fn connect(addr: io::Result<&SocketAddr>) -> io::Result<TcpStream> {
335 let addr = addr?;
336
337 init();
338
339 let sock = Socket::new(addr, c::SOCK_STREAM)?;
340 sock.connect(addr)?;
341 Ok(TcpStream { inner: sock })
342 }
343
344 pub fn connect_timeout(addr: &SocketAddr, timeout: Duration) -> io::Result<TcpStream> {
345 init();
346
347 let sock = Socket::new(addr, c::SOCK_STREAM)?;
348 sock.connect_timeout(addr, timeout)?;
349 Ok(TcpStream { inner: sock })
350 }
351
352 #[inline]
353 pub fn socket(&self) -> &Socket {
354 &self.inner
355 }
356
357 pub fn into_socket(self) -> Socket {
358 self.inner
359 }
360
361 pub fn set_read_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
362 self.inner.set_timeout(dur, c::SO_RCVTIMEO)
363 }
364
365 pub fn set_write_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
366 self.inner.set_timeout(dur, c::SO_SNDTIMEO)
367 }
368
369 pub fn read_timeout(&self) -> io::Result<Option<Duration>> {
370 self.inner.timeout(c::SO_RCVTIMEO)
371 }
372
373 pub fn write_timeout(&self) -> io::Result<Option<Duration>> {
374 self.inner.timeout(c::SO_SNDTIMEO)
375 }
376
377 pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
378 self.inner.peek(buf)
379 }
380
381 pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
382 self.inner.read(buf)
383 }
384
385 pub fn read_buf(&self, buf: BorrowedCursor<'_>) -> io::Result<()> {
386 self.inner.read_buf(buf)
387 }
388
389 pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
390 self.inner.read_vectored(bufs)
391 }
392
393 #[inline]
394 pub fn is_read_vectored(&self) -> bool {
395 self.inner.is_read_vectored()
396 }
397
398 pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
399 let len = cmp::min(buf.len(), <wrlen_t>::MAX as usize) as wrlen_t;
400 let ret = cvt(unsafe {
401 c::send(self.inner.as_raw(), buf.as_ptr() as *const c_void, len, MSG_NOSIGNAL)
402 })?;
403 Ok(ret as usize)
404 }
405
406 pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
407 self.inner.write_vectored(bufs)
408 }
409
410 #[inline]
411 pub fn is_write_vectored(&self) -> bool {
412 self.inner.is_write_vectored()
413 }
414
415 pub fn peer_addr(&self) -> io::Result<SocketAddr> {
416 sockname(|buf, len| unsafe { c::getpeername(self.inner.as_raw(), buf, len) })
417 }
418
419 pub fn socket_addr(&self) -> io::Result<SocketAddr> {
420 sockname(|buf, len| unsafe { c::getsockname(self.inner.as_raw(), buf, len) })
421 }
422
423 pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
424 self.inner.shutdown(how)
425 }
426
427 pub fn duplicate(&self) -> io::Result<TcpStream> {
428 self.inner.duplicate().map(|s| TcpStream { inner: s })
429 }
430
431 pub fn set_linger(&self, linger: Option<Duration>) -> io::Result<()> {
432 self.inner.set_linger(linger)
433 }
434
435 pub fn linger(&self) -> io::Result<Option<Duration>> {
436 self.inner.linger()
437 }
438
439 pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {
440 self.inner.set_nodelay(nodelay)
441 }
442
443 pub fn nodelay(&self) -> io::Result<bool> {
444 self.inner.nodelay()
445 }
446
447 pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
448 setsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL, ttl as c_int)
449 }
450
451 pub fn ttl(&self) -> io::Result<u32> {
452 let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL)?;
453 Ok(raw as u32)
454 }
455
456 pub fn take_error(&self) -> io::Result<Option<io::Error>> {
457 self.inner.take_error()
458 }
459
460 pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
461 self.inner.set_nonblocking(nonblocking)
462 }
463}
464
465impl AsInner<Socket> for TcpStream {
466 #[inline]
467 fn as_inner(&self) -> &Socket {
468 &self.inner
469 }
470}
471
472impl FromInner<Socket> for TcpStream {
473 fn from_inner(socket: Socket) -> TcpStream {
474 TcpStream { inner: socket }
475 }
476}
477
478impl fmt::Debug for TcpStream {
479 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
480 let mut res = f.debug_struct("TcpStream");
481
482 if let Ok(addr) = self.socket_addr() {
483 res.field("addr", &addr);
484 }
485
486 if let Ok(peer) = self.peer_addr() {
487 res.field("peer", &peer);
488 }
489
490 let name = if cfg!(windows) { "socket" } else { "fd" };
491 res.field(name, &self.inner.as_raw()).finish()
492 }
493}
494
495pub struct TcpListener {
500 inner: Socket,
501}
502
503impl TcpListener {
504 pub fn bind(addr: io::Result<&SocketAddr>) -> io::Result<TcpListener> {
505 let addr = addr?;
506
507 init();
508
509 let sock = Socket::new(addr, c::SOCK_STREAM)?;
510
511 #[cfg(not(windows))]
519 setsockopt(&sock, c::SOL_SOCKET, c::SO_REUSEADDR, 1 as c_int)?;
520
521 let (addr, len) = socket_addr_to_c(addr);
523 cvt(unsafe { c::bind(sock.as_raw(), addr.as_ptr(), len as _) })?;
524
525 cfg_if::cfg_if! {
526 if #[cfg(target_os = "horizon")] {
527 let backlog = 20;
531 } else if #[cfg(target_os = "haiku")] {
532 let backlog = 32;
535 } else {
536 let backlog = 128;
538 }
539 }
540
541 cvt(unsafe { c::listen(sock.as_raw(), backlog) })?;
543 Ok(TcpListener { inner: sock })
544 }
545
546 #[inline]
547 pub fn socket(&self) -> &Socket {
548 &self.inner
549 }
550
551 pub fn into_socket(self) -> Socket {
552 self.inner
553 }
554
555 pub fn socket_addr(&self) -> io::Result<SocketAddr> {
556 sockname(|buf, len| unsafe { c::getsockname(self.inner.as_raw(), buf, len) })
557 }
558
559 pub fn accept(&self) -> io::Result<(TcpStream, SocketAddr)> {
560 let mut storage: mem::MaybeUninit<c::sockaddr_storage> = mem::MaybeUninit::uninit();
564 let mut len = size_of_val(&storage) as c::socklen_t;
565 let sock = self.inner.accept(storage.as_mut_ptr() as *mut _, &mut len)?;
566 let addr = unsafe { socket_addr_from_c(storage.as_ptr(), len as usize)? };
567 Ok((TcpStream { inner: sock }, addr))
568 }
569
570 pub fn duplicate(&self) -> io::Result<TcpListener> {
571 self.inner.duplicate().map(|s| TcpListener { inner: s })
572 }
573
574 pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
575 setsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL, ttl as c_int)
576 }
577
578 pub fn ttl(&self) -> io::Result<u32> {
579 let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL)?;
580 Ok(raw as u32)
581 }
582
583 pub fn set_only_v6(&self, only_v6: bool) -> io::Result<()> {
584 setsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_V6ONLY, only_v6 as c_int)
585 }
586
587 pub fn only_v6(&self) -> io::Result<bool> {
588 let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_V6ONLY)?;
589 Ok(raw != 0)
590 }
591
592 pub fn take_error(&self) -> io::Result<Option<io::Error>> {
593 self.inner.take_error()
594 }
595
596 pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
597 self.inner.set_nonblocking(nonblocking)
598 }
599}
600
601impl FromInner<Socket> for TcpListener {
602 fn from_inner(socket: Socket) -> TcpListener {
603 TcpListener { inner: socket }
604 }
605}
606
607impl fmt::Debug for TcpListener {
608 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
609 let mut res = f.debug_struct("TcpListener");
610
611 if let Ok(addr) = self.socket_addr() {
612 res.field("addr", &addr);
613 }
614
615 let name = if cfg!(windows) { "socket" } else { "fd" };
616 res.field(name, &self.inner.as_raw()).finish()
617 }
618}
619
620pub struct UdpSocket {
625 inner: Socket,
626}
627
628impl UdpSocket {
629 pub fn bind(addr: io::Result<&SocketAddr>) -> io::Result<UdpSocket> {
630 let addr = addr?;
631
632 init();
633
634 let sock = Socket::new(addr, c::SOCK_DGRAM)?;
635 let (addr, len) = socket_addr_to_c(addr);
636 cvt(unsafe { c::bind(sock.as_raw(), addr.as_ptr(), len as _) })?;
637 Ok(UdpSocket { inner: sock })
638 }
639
640 #[inline]
641 pub fn socket(&self) -> &Socket {
642 &self.inner
643 }
644
645 pub fn into_socket(self) -> Socket {
646 self.inner
647 }
648
649 pub fn peer_addr(&self) -> io::Result<SocketAddr> {
650 sockname(|buf, len| unsafe { c::getpeername(self.inner.as_raw(), buf, len) })
651 }
652
653 pub fn socket_addr(&self) -> io::Result<SocketAddr> {
654 sockname(|buf, len| unsafe { c::getsockname(self.inner.as_raw(), buf, len) })
655 }
656
657 pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
658 self.inner.recv_from(buf)
659 }
660
661 pub fn peek_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
662 self.inner.peek_from(buf)
663 }
664
665 pub fn send_to(&self, buf: &[u8], dst: &SocketAddr) -> io::Result<usize> {
666 let len = cmp::min(buf.len(), <wrlen_t>::MAX as usize) as wrlen_t;
667 let (dst, dstlen) = socket_addr_to_c(dst);
668 let ret = cvt(unsafe {
669 c::sendto(
670 self.inner.as_raw(),
671 buf.as_ptr() as *const c_void,
672 len,
673 MSG_NOSIGNAL,
674 dst.as_ptr(),
675 dstlen,
676 )
677 })?;
678 Ok(ret as usize)
679 }
680
681 pub fn duplicate(&self) -> io::Result<UdpSocket> {
682 self.inner.duplicate().map(|s| UdpSocket { inner: s })
683 }
684
685 pub fn set_read_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
686 self.inner.set_timeout(dur, c::SO_RCVTIMEO)
687 }
688
689 pub fn set_write_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
690 self.inner.set_timeout(dur, c::SO_SNDTIMEO)
691 }
692
693 pub fn read_timeout(&self) -> io::Result<Option<Duration>> {
694 self.inner.timeout(c::SO_RCVTIMEO)
695 }
696
697 pub fn write_timeout(&self) -> io::Result<Option<Duration>> {
698 self.inner.timeout(c::SO_SNDTIMEO)
699 }
700
701 pub fn set_broadcast(&self, broadcast: bool) -> io::Result<()> {
702 setsockopt(&self.inner, c::SOL_SOCKET, c::SO_BROADCAST, broadcast as c_int)
703 }
704
705 pub fn broadcast(&self) -> io::Result<bool> {
706 let raw: c_int = getsockopt(&self.inner, c::SOL_SOCKET, c::SO_BROADCAST)?;
707 Ok(raw != 0)
708 }
709
710 pub fn set_multicast_loop_v4(&self, multicast_loop_v4: bool) -> io::Result<()> {
711 setsockopt(
712 &self.inner,
713 c::IPPROTO_IP,
714 c::IP_MULTICAST_LOOP,
715 multicast_loop_v4 as IpV4MultiCastType,
716 )
717 }
718
719 pub fn multicast_loop_v4(&self) -> io::Result<bool> {
720 let raw: IpV4MultiCastType = getsockopt(&self.inner, c::IPPROTO_IP, c::IP_MULTICAST_LOOP)?;
721 Ok(raw != 0)
722 }
723
724 pub fn set_multicast_ttl_v4(&self, multicast_ttl_v4: u32) -> io::Result<()> {
725 setsockopt(
726 &self.inner,
727 c::IPPROTO_IP,
728 c::IP_MULTICAST_TTL,
729 multicast_ttl_v4 as IpV4MultiCastType,
730 )
731 }
732
733 pub fn multicast_ttl_v4(&self) -> io::Result<u32> {
734 let raw: IpV4MultiCastType = getsockopt(&self.inner, c::IPPROTO_IP, c::IP_MULTICAST_TTL)?;
735 Ok(raw as u32)
736 }
737
738 pub fn set_multicast_loop_v6(&self, multicast_loop_v6: bool) -> io::Result<()> {
739 setsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_MULTICAST_LOOP, multicast_loop_v6 as c_int)
740 }
741
742 pub fn multicast_loop_v6(&self) -> io::Result<bool> {
743 let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_MULTICAST_LOOP)?;
744 Ok(raw != 0)
745 }
746
747 pub fn join_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> {
748 let mreq = c::ip_mreq {
749 imr_multiaddr: ip_v4_addr_to_c(multiaddr),
750 imr_interface: ip_v4_addr_to_c(interface),
751 };
752 setsockopt(&self.inner, c::IPPROTO_IP, c::IP_ADD_MEMBERSHIP, mreq)
753 }
754
755 pub fn join_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> {
756 let mreq = c::ipv6_mreq {
757 ipv6mr_multiaddr: ip_v6_addr_to_c(multiaddr),
758 ipv6mr_interface: to_ipv6mr_interface(interface),
759 };
760 setsockopt(&self.inner, c::IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, mreq)
761 }
762
763 pub fn leave_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> {
764 let mreq = c::ip_mreq {
765 imr_multiaddr: ip_v4_addr_to_c(multiaddr),
766 imr_interface: ip_v4_addr_to_c(interface),
767 };
768 setsockopt(&self.inner, c::IPPROTO_IP, c::IP_DROP_MEMBERSHIP, mreq)
769 }
770
771 pub fn leave_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> {
772 let mreq = c::ipv6_mreq {
773 ipv6mr_multiaddr: ip_v6_addr_to_c(multiaddr),
774 ipv6mr_interface: to_ipv6mr_interface(interface),
775 };
776 setsockopt(&self.inner, c::IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, mreq)
777 }
778
779 pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
780 setsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL, ttl as c_int)
781 }
782
783 pub fn ttl(&self) -> io::Result<u32> {
784 let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL)?;
785 Ok(raw as u32)
786 }
787
788 pub fn take_error(&self) -> io::Result<Option<io::Error>> {
789 self.inner.take_error()
790 }
791
792 pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
793 self.inner.set_nonblocking(nonblocking)
794 }
795
796 pub fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
797 self.inner.read(buf)
798 }
799
800 pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
801 self.inner.peek(buf)
802 }
803
804 pub fn send(&self, buf: &[u8]) -> io::Result<usize> {
805 let len = cmp::min(buf.len(), <wrlen_t>::MAX as usize) as wrlen_t;
806 let ret = cvt(unsafe {
807 c::send(self.inner.as_raw(), buf.as_ptr() as *const c_void, len, MSG_NOSIGNAL)
808 })?;
809 Ok(ret as usize)
810 }
811
812 pub fn connect(&self, addr: io::Result<&SocketAddr>) -> io::Result<()> {
813 let (addr, len) = socket_addr_to_c(addr?);
814 cvt_r(|| unsafe { c::connect(self.inner.as_raw(), addr.as_ptr(), len) }).map(drop)
815 }
816}
817
818impl FromInner<Socket> for UdpSocket {
819 fn from_inner(socket: Socket) -> UdpSocket {
820 UdpSocket { inner: socket }
821 }
822}
823
824impl fmt::Debug for UdpSocket {
825 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
826 let mut res = f.debug_struct("UdpSocket");
827
828 if let Ok(addr) = self.socket_addr() {
829 res.field("addr", &addr);
830 }
831
832 let name = if cfg!(windows) { "socket" } else { "fd" };
833 res.field(name, &self.inner.as_raw()).finish()
834 }
835}