2 use crate::io::prelude::*;
3 use crate::io::{self, ErrorKind, IoSlice, IoSliceMut};
6 target_os = "dragonfly",
7 target_os = "emscripten",
11 target_os = "openbsd",
13 use crate::iter::FromIterator;
15 target_os = "android",
16 target_os = "dragonfly",
17 target_os = "emscripten",
18 target_os = "freebsd",
21 target_os = "openbsd",
23 use crate::os::unix::io::AsRawFd;
24 use crate::sys_common::io::test::tmpdir;
26 use crate::time::Duration;
28 macro_rules! or_panic {
32 Err(e) => panic!("{e}"),
40 let socket_path = dir.path().join("sock");
44 let listener = or_panic!(UnixListener::bind(&socket_path));
45 let thread = thread::spawn(move || {
46 let mut stream = or_panic!(listener.accept()).0;
48 or_panic!(stream.read(&mut buf));
49 assert_eq!(&msg1[..], &buf[..]);
50 or_panic!(stream.write_all(msg2));
53 let mut stream = or_panic!(UnixStream::connect(&socket_path));
54 assert_eq!(Some(&*socket_path), stream.peer_addr().unwrap().as_pathname());
55 or_panic!(stream.write_all(msg1));
57 or_panic!(stream.read_to_end(&mut buf));
58 assert_eq!(&msg2[..], &buf[..]);
61 thread.join().unwrap();
66 let (mut s1, mut s2) = or_panic!(UnixStream::pair());
68 let len = or_panic!(s1.write_vectored(&[
69 IoSlice::new(b"hello"),
71 IoSlice::new(b"world!")
75 let mut buf1 = [0; 6];
76 let mut buf2 = [0; 7];
78 or_panic!(s2.read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],));
80 assert_eq!(&buf1, b"hello ");
81 assert_eq!(&buf2, b"world!\0");
89 let (mut s1, mut s2) = or_panic!(UnixStream::pair());
90 let thread = thread::spawn(move || {
91 // s1 must be moved in or the test will hang!
93 or_panic!(s1.read(&mut buf));
94 assert_eq!(&msg1[..], &buf[..]);
95 or_panic!(s1.write_all(msg2));
98 or_panic!(s2.write_all(msg1));
100 or_panic!(s2.read_to_end(&mut buf));
101 assert_eq!(&msg2[..], &buf[..]);
104 thread.join().unwrap();
110 let socket_path = dir.path().join("sock");
114 let listener = or_panic!(UnixListener::bind(&socket_path));
115 let thread = thread::spawn(move || {
116 let mut stream = or_panic!(listener.accept()).0;
117 or_panic!(stream.write_all(msg1));
118 or_panic!(stream.write_all(msg2));
121 let mut stream = or_panic!(UnixStream::connect(&socket_path));
122 let mut stream2 = or_panic!(stream.try_clone());
124 let mut buf = [0; 5];
125 or_panic!(stream.read(&mut buf));
126 assert_eq!(&msg1[..], &buf[..]);
127 or_panic!(stream2.read(&mut buf));
128 assert_eq!(&msg2[..], &buf[..]);
130 thread.join().unwrap();
136 let socket_path = dir.path().join("sock");
138 let listener = or_panic!(UnixListener::bind(&socket_path));
139 let thread = thread::spawn(move || {
140 for stream in listener.incoming().take(2) {
141 let mut stream = or_panic!(stream);
143 or_panic!(stream.read(&mut buf));
148 let mut stream = or_panic!(UnixStream::connect(&socket_path));
149 or_panic!(stream.write_all(&[0]));
152 thread.join().unwrap();
158 let socket_path = dir.path().join(
159 "asdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfa\
160 sasdfasdfasdasdfasdfasdfadfasdfasdfasdfasdfasdf",
162 match UnixStream::connect(&socket_path) {
163 Err(ref e) if e.kind() == io::ErrorKind::InvalidInput => {}
164 Err(e) => panic!("unexpected error {e}"),
165 Ok(_) => panic!("unexpected success"),
168 match UnixListener::bind(&socket_path) {
169 Err(ref e) if e.kind() == io::ErrorKind::InvalidInput => {}
170 Err(e) => panic!("unexpected error {e}"),
171 Ok(_) => panic!("unexpected success"),
174 match UnixDatagram::bind(&socket_path) {
175 Err(ref e) if e.kind() == io::ErrorKind::InvalidInput => {}
176 Err(e) => panic!("unexpected error {e}"),
177 Ok(_) => panic!("unexpected success"),
184 let socket_path = dir.path().join("sock");
186 let _listener = or_panic!(UnixListener::bind(&socket_path));
188 let stream = or_panic!(UnixStream::connect(&socket_path));
189 let dur = Duration::new(15410, 0);
191 assert_eq!(None, or_panic!(stream.read_timeout()));
193 or_panic!(stream.set_read_timeout(Some(dur)));
194 assert_eq!(Some(dur), or_panic!(stream.read_timeout()));
196 assert_eq!(None, or_panic!(stream.write_timeout()));
198 or_panic!(stream.set_write_timeout(Some(dur)));
199 assert_eq!(Some(dur), or_panic!(stream.write_timeout()));
201 or_panic!(stream.set_read_timeout(None));
202 assert_eq!(None, or_panic!(stream.read_timeout()));
204 or_panic!(stream.set_write_timeout(None));
205 assert_eq!(None, or_panic!(stream.write_timeout()));
209 fn test_read_timeout() {
211 let socket_path = dir.path().join("sock");
213 let _listener = or_panic!(UnixListener::bind(&socket_path));
215 let mut stream = or_panic!(UnixStream::connect(&socket_path));
216 or_panic!(stream.set_read_timeout(Some(Duration::from_millis(1000))));
218 let mut buf = [0; 10];
219 let kind = stream.read_exact(&mut buf).err().expect("expected error").kind();
221 kind == ErrorKind::WouldBlock || kind == ErrorKind::TimedOut,
222 "unexpected_error: {:?}",
228 fn test_read_with_timeout() {
230 let socket_path = dir.path().join("sock");
232 let listener = or_panic!(UnixListener::bind(&socket_path));
234 let mut stream = or_panic!(UnixStream::connect(&socket_path));
235 or_panic!(stream.set_read_timeout(Some(Duration::from_millis(1000))));
237 let mut other_end = or_panic!(listener.accept()).0;
238 or_panic!(other_end.write_all(b"hello world"));
240 let mut buf = [0; 11];
241 or_panic!(stream.read(&mut buf));
242 assert_eq!(b"hello world", &buf[..]);
244 let kind = stream.read_exact(&mut buf).err().expect("expected error").kind();
246 kind == ErrorKind::WouldBlock || kind == ErrorKind::TimedOut,
247 "unexpected_error: {:?}",
252 // Ensure the `set_read_timeout` and `set_write_timeout` calls return errors
253 // when passed zero Durations
255 fn test_unix_stream_timeout_zero_duration() {
257 let socket_path = dir.path().join("sock");
259 let listener = or_panic!(UnixListener::bind(&socket_path));
260 let stream = or_panic!(UnixStream::connect(&socket_path));
262 let result = stream.set_write_timeout(Some(Duration::new(0, 0)));
263 let err = result.unwrap_err();
264 assert_eq!(err.kind(), ErrorKind::InvalidInput);
266 let result = stream.set_read_timeout(Some(Duration::new(0, 0)));
267 let err = result.unwrap_err();
268 assert_eq!(err.kind(), ErrorKind::InvalidInput);
274 fn test_unix_datagram() {
276 let path1 = dir.path().join("sock1");
277 let path2 = dir.path().join("sock2");
279 let sock1 = or_panic!(UnixDatagram::bind(&path1));
280 let sock2 = or_panic!(UnixDatagram::bind(&path2));
282 let msg = b"hello world";
283 or_panic!(sock1.send_to(msg, &path2));
284 let mut buf = [0; 11];
285 or_panic!(sock2.recv_from(&mut buf));
286 assert_eq!(msg, &buf[..]);
290 fn test_unnamed_unix_datagram() {
292 let path1 = dir.path().join("sock1");
294 let sock1 = or_panic!(UnixDatagram::bind(&path1));
295 let sock2 = or_panic!(UnixDatagram::unbound());
297 let msg = b"hello world";
298 or_panic!(sock2.send_to(msg, &path1));
299 let mut buf = [0; 11];
300 let (usize, addr) = or_panic!(sock1.recv_from(&mut buf));
301 assert_eq!(usize, 11);
302 assert!(addr.is_unnamed());
303 assert_eq!(msg, &buf[..]);
307 fn test_unix_datagram_connect_to_recv_addr() {
309 let path1 = dir.path().join("sock1");
310 let path2 = dir.path().join("sock2");
312 let sock1 = or_panic!(UnixDatagram::bind(&path1));
313 let sock2 = or_panic!(UnixDatagram::bind(&path2));
315 let msg = b"hello world";
316 let sock1_addr = or_panic!(sock1.local_addr());
317 or_panic!(sock2.send_to_addr(msg, &sock1_addr));
318 let mut buf = [0; 11];
319 let (_, addr) = or_panic!(sock1.recv_from(&mut buf));
321 let new_msg = b"hello back";
322 let mut new_buf = [0; 10];
323 or_panic!(sock2.connect_addr(&addr));
324 or_panic!(sock2.send(new_msg)); // set by connect_addr
325 let usize = or_panic!(sock2.recv(&mut new_buf));
326 assert_eq!(usize, 10);
327 assert_eq!(new_msg, &new_buf[..]);
331 fn test_connect_unix_datagram() {
333 let path1 = dir.path().join("sock1");
334 let path2 = dir.path().join("sock2");
336 let bsock1 = or_panic!(UnixDatagram::bind(&path1));
337 let bsock2 = or_panic!(UnixDatagram::bind(&path2));
338 let sock = or_panic!(UnixDatagram::unbound());
339 or_panic!(sock.connect(&path1));
342 let msg = b"hello there";
343 or_panic!(sock.send(msg));
344 let mut buf = [0; 11];
345 let (usize, addr) = or_panic!(bsock1.recv_from(&mut buf));
346 assert_eq!(usize, 11);
347 assert!(addr.is_unnamed());
348 assert_eq!(msg, &buf[..]);
350 // Changing default socket works too
351 or_panic!(sock.connect(&path2));
352 or_panic!(sock.send(msg));
353 or_panic!(bsock2.recv_from(&mut buf));
357 fn test_unix_datagram_recv() {
359 let path1 = dir.path().join("sock1");
361 let sock1 = or_panic!(UnixDatagram::bind(&path1));
362 let sock2 = or_panic!(UnixDatagram::unbound());
363 or_panic!(sock2.connect(&path1));
365 let msg = b"hello world";
366 or_panic!(sock2.send(msg));
367 let mut buf = [0; 11];
368 let size = or_panic!(sock1.recv(&mut buf));
369 assert_eq!(size, 11);
370 assert_eq!(msg, &buf[..]);
376 let msg2 = b"world!";
378 let (s1, s2) = or_panic!(UnixDatagram::pair());
379 let thread = thread::spawn(move || {
380 // s1 must be moved in or the test will hang!
381 let mut buf = [0; 5];
382 or_panic!(s1.recv(&mut buf));
383 assert_eq!(&msg1[..], &buf[..]);
384 or_panic!(s1.send(msg2));
387 or_panic!(s2.send(msg1));
388 let mut buf = [0; 6];
389 or_panic!(s2.recv(&mut buf));
390 assert_eq!(&msg2[..], &buf[..]);
393 thread.join().unwrap();
396 // Ensure the `set_read_timeout` and `set_write_timeout` calls return errors
397 // when passed zero Durations
399 fn test_unix_datagram_timeout_zero_duration() {
401 let path = dir.path().join("sock");
403 let datagram = or_panic!(UnixDatagram::bind(&path));
405 let result = datagram.set_write_timeout(Some(Duration::new(0, 0)));
406 let err = result.unwrap_err();
407 assert_eq!(err.kind(), ErrorKind::InvalidInput);
409 let result = datagram.set_read_timeout(Some(Duration::new(0, 0)));
410 let err = result.unwrap_err();
411 assert_eq!(err.kind(), ErrorKind::InvalidInput);
415 fn abstract_namespace_not_allowed_connect() {
416 assert!(UnixStream::connect("\0asdf").is_err());
419 #[cfg(any(target_os = "android", target_os = "linux"))]
421 fn test_abstract_stream_connect() {
425 let socket_addr = or_panic!(SocketAddr::from_abstract_namespace(b"namespace"));
426 let listener = or_panic!(UnixListener::bind_addr(&socket_addr));
428 let thread = thread::spawn(move || {
429 let mut stream = or_panic!(listener.accept()).0;
430 let mut buf = [0; 5];
431 or_panic!(stream.read(&mut buf));
432 assert_eq!(&msg1[..], &buf[..]);
433 or_panic!(stream.write_all(msg2));
436 let mut stream = or_panic!(UnixStream::connect_addr(&socket_addr));
438 let peer = or_panic!(stream.peer_addr());
439 assert_eq!(peer.as_abstract_namespace().unwrap(), b"namespace");
441 or_panic!(stream.write_all(msg1));
442 let mut buf = vec![];
443 or_panic!(stream.read_to_end(&mut buf));
444 assert_eq!(&msg2[..], &buf[..]);
447 thread.join().unwrap();
450 #[cfg(any(target_os = "android", target_os = "linux"))]
452 fn test_abstract_stream_iter() {
453 let addr = or_panic!(SocketAddr::from_abstract_namespace(b"hidden"));
454 let listener = or_panic!(UnixListener::bind_addr(&addr));
456 let thread = thread::spawn(move || {
457 for stream in listener.incoming().take(2) {
458 let mut stream = or_panic!(stream);
460 or_panic!(stream.read(&mut buf));
465 let mut stream = or_panic!(UnixStream::connect_addr(&addr));
466 or_panic!(stream.write_all(&[0]));
469 thread.join().unwrap();
472 #[cfg(any(target_os = "android", target_os = "linux"))]
474 fn test_abstract_datagram_bind_send_to_addr() {
475 let addr1 = or_panic!(SocketAddr::from_abstract_namespace(b"ns1"));
476 let sock1 = or_panic!(UnixDatagram::bind_addr(&addr1));
478 let local = or_panic!(sock1.local_addr());
479 assert_eq!(local.as_abstract_namespace().unwrap(), b"ns1");
481 let addr2 = or_panic!(SocketAddr::from_abstract_namespace(b"ns2"));
482 let sock2 = or_panic!(UnixDatagram::bind_addr(&addr2));
484 let msg = b"hello world";
485 or_panic!(sock1.send_to_addr(msg, &addr2));
486 let mut buf = [0; 11];
487 let (len, addr) = or_panic!(sock2.recv_from(&mut buf));
488 assert_eq!(msg, &buf[..]);
490 assert_eq!(addr.as_abstract_namespace().unwrap(), b"ns1");
493 #[cfg(any(target_os = "android", target_os = "linux"))]
495 fn test_abstract_datagram_connect_addr() {
496 let addr1 = or_panic!(SocketAddr::from_abstract_namespace(b"ns3"));
497 let bsock1 = or_panic!(UnixDatagram::bind_addr(&addr1));
499 let sock = or_panic!(UnixDatagram::unbound());
500 or_panic!(sock.connect_addr(&addr1));
502 let msg = b"hello world";
503 or_panic!(sock.send(msg));
504 let mut buf = [0; 11];
505 let (len, addr) = or_panic!(bsock1.recv_from(&mut buf));
507 assert_eq!(addr.is_unnamed(), true);
508 assert_eq!(msg, &buf[..]);
510 let addr2 = or_panic!(SocketAddr::from_abstract_namespace(b"ns4"));
511 let bsock2 = or_panic!(UnixDatagram::bind_addr(&addr2));
513 or_panic!(sock.connect_addr(&addr2));
514 or_panic!(sock.send(msg));
515 or_panic!(bsock2.recv_from(&mut buf));
518 #[cfg(any(target_os = "android", target_os = "linux"))]
520 fn test_abstract_namespace_too_long() {
521 match SocketAddr::from_abstract_namespace(
522 b"abcdefghijklmnopqrstuvwxyzabcdefghijklmn\
523 opqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghi\
524 jklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz",
526 Err(ref e) if e.kind() == io::ErrorKind::InvalidInput => {}
527 Err(e) => panic!("unexpected error {e}"),
528 Ok(_) => panic!("unexpected success"),
532 #[cfg(any(target_os = "android", target_os = "linux"))]
534 fn test_abstract_namespace_no_pathname_and_not_unnamed() {
535 let namespace = b"local";
536 let addr = or_panic!(SocketAddr::from_abstract_namespace(&namespace[..]));
537 assert_eq!(addr.as_pathname(), None);
538 assert_eq!(addr.as_abstract_namespace(), Some(&namespace[..]));
539 assert_eq!(addr.is_unnamed(), false);
543 fn test_unix_stream_peek() {
544 let (txdone, rxdone) = crate::sync::mpsc::channel();
547 let path = dir.path().join("sock");
549 let listener = or_panic!(UnixListener::bind(&path));
550 let thread = thread::spawn(move || {
551 let mut stream = or_panic!(listener.accept()).0;
552 or_panic!(stream.write_all(&[1, 3, 3, 7]));
553 or_panic!(rxdone.recv());
556 let mut stream = or_panic!(UnixStream::connect(&path));
557 let mut buf = [0; 10];
559 assert_eq!(or_panic!(stream.peek(&mut buf)), 4);
561 assert_eq!(or_panic!(stream.read(&mut buf)), 4);
563 or_panic!(stream.set_nonblocking(true));
564 match stream.peek(&mut buf) {
565 Ok(_) => panic!("expected error"),
566 Err(ref e) if e.kind() == ErrorKind::WouldBlock => {}
567 Err(e) => panic!("unexpected error: {e}"),
570 or_panic!(txdone.send(()));
571 thread.join().unwrap();
575 fn test_unix_datagram_peek() {
577 let path1 = dir.path().join("sock");
579 let sock1 = or_panic!(UnixDatagram::bind(&path1));
580 let sock2 = or_panic!(UnixDatagram::unbound());
581 or_panic!(sock2.connect(&path1));
583 let msg = b"hello world";
584 or_panic!(sock2.send(msg));
586 let mut buf = [0; 11];
587 let size = or_panic!(sock1.peek(&mut buf));
588 assert_eq!(size, 11);
589 assert_eq!(msg, &buf[..]);
592 let mut buf = [0; 11];
593 let size = or_panic!(sock1.recv(&mut buf));
594 assert_eq!(size, 11);
595 assert_eq!(msg, &buf[..]);
599 fn test_unix_datagram_peek_from() {
601 let path1 = dir.path().join("sock");
603 let sock1 = or_panic!(UnixDatagram::bind(&path1));
604 let sock2 = or_panic!(UnixDatagram::unbound());
605 or_panic!(sock2.connect(&path1));
607 let msg = b"hello world";
608 or_panic!(sock2.send(msg));
610 let mut buf = [0; 11];
611 let (size, _) = or_panic!(sock1.peek_from(&mut buf));
612 assert_eq!(size, 11);
613 assert_eq!(msg, &buf[..]);
616 let mut buf = [0; 11];
617 let size = or_panic!(sock1.recv(&mut buf));
618 assert_eq!(size, 11);
619 assert_eq!(msg, &buf[..]);
623 target_os = "android",
624 target_os = "dragonfly",
625 target_os = "emscripten",
626 target_os = "freebsd",
628 target_os = "netbsd",
629 target_os = "openbsd",
632 fn test_send_vectored_fds_unix_stream() {
633 let (s1, s2) = or_panic!(UnixStream::pair());
636 let bufs_send = &[IoSlice::new(&buf1[..])][..];
638 let mut ancillary1_buffer = [0; 128];
639 let mut ancillary1 = SocketAncillary::new(&mut ancillary1_buffer[..]);
640 assert!(ancillary1.add_fds(&[s1.as_raw_fd()][..]));
642 let usize = or_panic!(s1.send_vectored_with_ancillary(&bufs_send, &mut ancillary1));
643 assert_eq!(usize, 8);
645 let mut buf2 = [0; 8];
646 let mut bufs_recv = &mut [IoSliceMut::new(&mut buf2[..])][..];
648 let mut ancillary2_buffer = [0; 128];
649 let mut ancillary2 = SocketAncillary::new(&mut ancillary2_buffer[..]);
651 let usize = or_panic!(s2.recv_vectored_with_ancillary(&mut bufs_recv, &mut ancillary2));
652 assert_eq!(usize, 8);
653 assert_eq!(buf1, buf2);
655 let mut ancillary_data_vec = Vec::from_iter(ancillary2.messages());
656 assert_eq!(ancillary_data_vec.len(), 1);
657 if let AncillaryData::ScmRights(scm_rights) = ancillary_data_vec.pop().unwrap().unwrap() {
658 let fd_vec = Vec::from_iter(scm_rights);
659 assert_eq!(fd_vec.len(), 1);
661 libc::close(fd_vec[0]);
664 unreachable!("must be ScmRights");
668 #[cfg(any(target_os = "android", target_os = "emscripten", target_os = "linux",))]
670 fn test_send_vectored_with_ancillary_to_unix_datagram() {
671 fn getpid() -> libc::pid_t {
672 unsafe { libc::getpid() }
675 fn getuid() -> libc::uid_t {
676 unsafe { libc::getuid() }
679 fn getgid() -> libc::gid_t {
680 unsafe { libc::getgid() }
684 let path1 = dir.path().join("sock1");
685 let path2 = dir.path().join("sock2");
687 let bsock1 = or_panic!(UnixDatagram::bind(&path1));
688 let bsock2 = or_panic!(UnixDatagram::bind(&path2));
690 or_panic!(bsock2.set_passcred(true));
693 let bufs_send = &[IoSlice::new(&buf1[..])][..];
695 let mut ancillary1_buffer = [0; 128];
696 let mut ancillary1 = SocketAncillary::new(&mut ancillary1_buffer[..]);
697 let mut cred1 = SocketCred::new();
698 cred1.set_pid(getpid());
699 cred1.set_uid(getuid());
700 cred1.set_gid(getgid());
701 assert!(ancillary1.add_creds(&[cred1.clone()][..]));
704 or_panic!(bsock1.send_vectored_with_ancillary_to(&bufs_send, &mut ancillary1, &path2));
705 assert_eq!(usize, 8);
707 let mut buf2 = [0; 8];
708 let mut bufs_recv = &mut [IoSliceMut::new(&mut buf2[..])][..];
710 let mut ancillary2_buffer = [0; 128];
711 let mut ancillary2 = SocketAncillary::new(&mut ancillary2_buffer[..]);
713 let (usize, truncated, _addr) =
714 or_panic!(bsock2.recv_vectored_with_ancillary_from(&mut bufs_recv, &mut ancillary2));
715 assert_eq!(ancillary2.truncated(), false);
716 assert_eq!(usize, 8);
717 assert_eq!(truncated, false);
718 assert_eq!(buf1, buf2);
720 let mut ancillary_data_vec = Vec::from_iter(ancillary2.messages());
721 assert_eq!(ancillary_data_vec.len(), 1);
722 if let AncillaryData::ScmCredentials(scm_credentials) =
723 ancillary_data_vec.pop().unwrap().unwrap()
725 let cred_vec = Vec::from_iter(scm_credentials);
726 assert_eq!(cred_vec.len(), 1);
727 assert_eq!(cred1.get_pid(), cred_vec[0].get_pid());
728 assert_eq!(cred1.get_uid(), cred_vec[0].get_uid());
729 assert_eq!(cred1.get_gid(), cred_vec[0].get_gid());
731 unreachable!("must be ScmCredentials");
736 target_os = "android",
737 target_os = "dragonfly",
738 target_os = "emscripten",
739 target_os = "freebsd",
741 target_os = "netbsd",
742 target_os = "openbsd",
745 fn test_send_vectored_with_ancillary_unix_datagram() {
747 let path1 = dir.path().join("sock1");
748 let path2 = dir.path().join("sock2");
750 let bsock1 = or_panic!(UnixDatagram::bind(&path1));
751 let bsock2 = or_panic!(UnixDatagram::bind(&path2));
754 let bufs_send = &[IoSlice::new(&buf1[..])][..];
756 let mut ancillary1_buffer = [0; 128];
757 let mut ancillary1 = SocketAncillary::new(&mut ancillary1_buffer[..]);
758 assert!(ancillary1.add_fds(&[bsock1.as_raw_fd()][..]));
760 or_panic!(bsock1.connect(&path2));
761 let usize = or_panic!(bsock1.send_vectored_with_ancillary(&bufs_send, &mut ancillary1));
762 assert_eq!(usize, 8);
764 let mut buf2 = [0; 8];
765 let mut bufs_recv = &mut [IoSliceMut::new(&mut buf2[..])][..];
767 let mut ancillary2_buffer = [0; 128];
768 let mut ancillary2 = SocketAncillary::new(&mut ancillary2_buffer[..]);
770 let (usize, truncated) =
771 or_panic!(bsock2.recv_vectored_with_ancillary(&mut bufs_recv, &mut ancillary2));
772 assert_eq!(usize, 8);
773 assert_eq!(truncated, false);
774 assert_eq!(buf1, buf2);
776 let mut ancillary_data_vec = Vec::from_iter(ancillary2.messages());
777 assert_eq!(ancillary_data_vec.len(), 1);
778 if let AncillaryData::ScmRights(scm_rights) = ancillary_data_vec.pop().unwrap().unwrap() {
779 let fd_vec = Vec::from_iter(scm_rights);
780 assert_eq!(fd_vec.len(), 1);
782 libc::close(fd_vec[0]);
785 unreachable!("must be ScmRights");