library/std/src/os/unix/net/tests.rs

   1 use super::*;
   2 use crate::io::prelude::*;
   3 use crate::io::{self, ErrorKind, IoSlice, IoSliceMut};
   4 #[cfg(any(target_os = "android", target_os = "linux"))]
   5 use crate::os::unix::io::AsRawFd;
   6 use crate::sys_common::io::test::tmpdir;
   7 use crate::thread;
   8 use crate::time::Duration;
   9
  10 #[cfg(target_os = "android")]
  11 use crate::os::android::net::SocketAddrExt;
  12
  13 #[cfg(target_os = "linux")]
  14 use crate::os::linux::net::SocketAddrExt;
  15
  16 macro_rules! or_panic {
  17     ($e:expr) => {
  18         match $e {
  19             Ok(e) => e,
  20             Err(e) => panic!("{e}"),
  21         }
  22     };
  23 }
  24
  25 #[test]
  26 fn basic() {
  27     let dir = tmpdir();
  28     let socket_path = dir.path().join("sock");
  29     let msg1 = b"hello";
  30     let msg2 = b"world!";
  31
  32     let listener = or_panic!(UnixListener::bind(&socket_path));
  33     let thread = thread::spawn(move || {
  34         let mut stream = or_panic!(listener.accept()).0;
  35         let mut buf = [0; 5];
  36         or_panic!(stream.read(&mut buf));
  37         assert_eq!(&msg1[..], &buf[..]);
  38         or_panic!(stream.write_all(msg2));
  39     });
  40
  41     let mut stream = or_panic!(UnixStream::connect(&socket_path));
  42     assert_eq!(Some(&*socket_path), stream.peer_addr().unwrap().as_pathname());
  43     or_panic!(stream.write_all(msg1));
  44     let mut buf = vec![];
  45     or_panic!(stream.read_to_end(&mut buf));
  46     assert_eq!(&msg2[..], &buf[..]);
  47     drop(stream);
  48
  49     thread.join().unwrap();
  50 }
  51
  52 #[test]
  53 fn vectored() {
  54     let (mut s1, mut s2) = or_panic!(UnixStream::pair());
  55
  56     let len = or_panic!(s1.write_vectored(&[
  57         IoSlice::new(b"hello"),
  58         IoSlice::new(b" "),
  59         IoSlice::new(b"world!")
  60     ],));
  61     assert_eq!(len, 12);
  62
  63     let mut buf1 = [0; 6];
  64     let mut buf2 = [0; 7];
  65     let len =
  66         or_panic!(s2.read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],));
  67     assert_eq!(len, 12);
  68     assert_eq!(&buf1, b"hello ");
  69     assert_eq!(&buf2, b"world!\0");
  70 }
  71
  72 #[test]
  73 fn pair() {
  74     let msg1 = b"hello";
  75     let msg2 = b"world!";
  76
  77     let (mut s1, mut s2) = or_panic!(UnixStream::pair());
  78     let thread = thread::spawn(move || {
  79         // s1 must be moved in or the test will hang!
  80         let mut buf = [0; 5];
  81         or_panic!(s1.read(&mut buf));
  82         assert_eq!(&msg1[..], &buf[..]);
  83         or_panic!(s1.write_all(msg2));
  84     });
  85
  86     or_panic!(s2.write_all(msg1));
  87     let mut buf = vec![];
  88     or_panic!(s2.read_to_end(&mut buf));
  89     assert_eq!(&msg2[..], &buf[..]);
  90     drop(s2);
  91
  92     thread.join().unwrap();
  93 }
  94
  95 #[test]
  96 fn try_clone() {
  97     let dir = tmpdir();
  98     let socket_path = dir.path().join("sock");
  99     let msg1 = b"hello";
 100     let msg2 = b"world";
 101
 102     let listener = or_panic!(UnixListener::bind(&socket_path));
 103     let thread = thread::spawn(move || {
 104         let mut stream = or_panic!(listener.accept()).0;
 105         or_panic!(stream.write_all(msg1));
 106         or_panic!(stream.write_all(msg2));
 107     });
 108
 109     let mut stream = or_panic!(UnixStream::connect(&socket_path));
 110     let mut stream2 = or_panic!(stream.try_clone());
 111
 112     let mut buf = [0; 5];
 113     or_panic!(stream.read(&mut buf));
 114     assert_eq!(&msg1[..], &buf[..]);
 115     or_panic!(stream2.read(&mut buf));
 116     assert_eq!(&msg2[..], &buf[..]);
 117
 118     thread.join().unwrap();
 119 }
 120
 121 #[test]
 122 fn iter() {
 123     let dir = tmpdir();
 124     let socket_path = dir.path().join("sock");
 125
 126     let listener = or_panic!(UnixListener::bind(&socket_path));
 127     let thread = thread::spawn(move || {
 128         for stream in listener.incoming().take(2) {
 129             let mut stream = or_panic!(stream);
 130             let mut buf = [0];
 131             or_panic!(stream.read(&mut buf));
 132         }
 133     });
 134
 135     for _ in 0..2 {
 136         let mut stream = or_panic!(UnixStream::connect(&socket_path));
 137         or_panic!(stream.write_all(&[0]));
 138     }
 139
 140     thread.join().unwrap();
 141 }
 142
 143 #[test]
 144 fn long_path() {
 145     let dir = tmpdir();
 146     let socket_path = dir.path().join(
 147         "asdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfa\
 148                                 sasdfasdfasdasdfasdfasdfadfasdfasdfasdfasdfasdf",
 149     );
 150     match UnixStream::connect(&socket_path) {
 151         Err(ref e) if e.kind() == io::ErrorKind::InvalidInput => {}
 152         Err(e) => panic!("unexpected error {e}"),
 153         Ok(_) => panic!("unexpected success"),
 154     }
 155
 156     match UnixListener::bind(&socket_path) {
 157         Err(ref e) if e.kind() == io::ErrorKind::InvalidInput => {}
 158         Err(e) => panic!("unexpected error {e}"),
 159         Ok(_) => panic!("unexpected success"),
 160     }
 161
 162     match UnixDatagram::bind(&socket_path) {
 163         Err(ref e) if e.kind() == io::ErrorKind::InvalidInput => {}
 164         Err(e) => panic!("unexpected error {e}"),
 165         Ok(_) => panic!("unexpected success"),
 166     }
 167 }
 168
 169 #[test]
 170 fn timeouts() {
 171     let dir = tmpdir();
 172     let socket_path = dir.path().join("sock");
 173
 174     let _listener = or_panic!(UnixListener::bind(&socket_path));
 175
 176     let stream = or_panic!(UnixStream::connect(&socket_path));
 177     let dur = Duration::new(15410, 0);
 178
 179     assert_eq!(None, or_panic!(stream.read_timeout()));
 180
 181     or_panic!(stream.set_read_timeout(Some(dur)));
 182     assert_eq!(Some(dur), or_panic!(stream.read_timeout()));
 183
 184     assert_eq!(None, or_panic!(stream.write_timeout()));
 185
 186     or_panic!(stream.set_write_timeout(Some(dur)));
 187     assert_eq!(Some(dur), or_panic!(stream.write_timeout()));
 188
 189     or_panic!(stream.set_read_timeout(None));
 190     assert_eq!(None, or_panic!(stream.read_timeout()));
 191
 192     or_panic!(stream.set_write_timeout(None));
 193     assert_eq!(None, or_panic!(stream.write_timeout()));
 194 }
 195
 196 #[test]
 197 fn test_read_timeout() {
 198     let dir = tmpdir();
 199     let socket_path = dir.path().join("sock");
 200
 201     let _listener = or_panic!(UnixListener::bind(&socket_path));
 202
 203     let mut stream = or_panic!(UnixStream::connect(&socket_path));
 204     or_panic!(stream.set_read_timeout(Some(Duration::from_millis(1000))));
 205
 206     let mut buf = [0; 10];
 207     let kind = stream.read_exact(&mut buf).err().expect("expected error").kind();
 208     assert!(
 209         kind == ErrorKind::WouldBlock || kind == ErrorKind::TimedOut,
 210         "unexpected_error: {:?}",
 211         kind
 212     );
 213 }
 214
 215 #[test]
 216 fn test_read_with_timeout() {
 217     let dir = tmpdir();
 218     let socket_path = dir.path().join("sock");
 219
 220     let listener = or_panic!(UnixListener::bind(&socket_path));
 221
 222     let mut stream = or_panic!(UnixStream::connect(&socket_path));
 223     or_panic!(stream.set_read_timeout(Some(Duration::from_millis(1000))));
 224
 225     let mut other_end = or_panic!(listener.accept()).0;
 226     or_panic!(other_end.write_all(b"hello world"));
 227
 228     let mut buf = [0; 11];
 229     or_panic!(stream.read(&mut buf));
 230     assert_eq!(b"hello world", &buf[..]);
 231
 232     let kind = stream.read_exact(&mut buf).err().expect("expected error").kind();
 233     assert!(
 234         kind == ErrorKind::WouldBlock || kind == ErrorKind::TimedOut,
 235         "unexpected_error: {:?}",
 236         kind
 237     );
 238 }
 239
 240 // Ensure the `set_read_timeout` and `set_write_timeout` calls return errors
 241 // when passed zero Durations
 242 #[test]
 243 fn test_unix_stream_timeout_zero_duration() {
 244     let dir = tmpdir();
 245     let socket_path = dir.path().join("sock");
 246
 247     let listener = or_panic!(UnixListener::bind(&socket_path));
 248     let stream = or_panic!(UnixStream::connect(&socket_path));
 249
 250     let result = stream.set_write_timeout(Some(Duration::new(0, 0)));
 251     let err = result.unwrap_err();
 252     assert_eq!(err.kind(), ErrorKind::InvalidInput);
 253
 254     let result = stream.set_read_timeout(Some(Duration::new(0, 0)));
 255     let err = result.unwrap_err();
 256     assert_eq!(err.kind(), ErrorKind::InvalidInput);
 257
 258     drop(listener);
 259 }
 260
 261 #[test]
 262 fn test_unix_datagram() {
 263     let dir = tmpdir();
 264     let path1 = dir.path().join("sock1");
 265     let path2 = dir.path().join("sock2");
 266
 267     let sock1 = or_panic!(UnixDatagram::bind(&path1));
 268     let sock2 = or_panic!(UnixDatagram::bind(&path2));
 269
 270     let msg = b"hello world";
 271     or_panic!(sock1.send_to(msg, &path2));
 272     let mut buf = [0; 11];
 273     or_panic!(sock2.recv_from(&mut buf));
 274     assert_eq!(msg, &buf[..]);
 275 }
 276
 277 #[test]
 278 fn test_unnamed_unix_datagram() {
 279     let dir = tmpdir();
 280     let path1 = dir.path().join("sock1");
 281
 282     let sock1 = or_panic!(UnixDatagram::bind(&path1));
 283     let sock2 = or_panic!(UnixDatagram::unbound());
 284
 285     let msg = b"hello world";
 286     or_panic!(sock2.send_to(msg, &path1));
 287     let mut buf = [0; 11];
 288     let (usize, addr) = or_panic!(sock1.recv_from(&mut buf));
 289     assert_eq!(usize, 11);
 290     assert!(addr.is_unnamed());
 291     assert_eq!(msg, &buf[..]);
 292 }
 293
 294 #[test]
 295 fn test_unix_datagram_connect_to_recv_addr() {
 296     let dir = tmpdir();
 297     let path1 = dir.path().join("sock1");
 298     let path2 = dir.path().join("sock2");
 299
 300     let sock1 = or_panic!(UnixDatagram::bind(&path1));
 301     let sock2 = or_panic!(UnixDatagram::bind(&path2));
 302
 303     let msg = b"hello world";
 304     let sock1_addr = or_panic!(sock1.local_addr());
 305     or_panic!(sock2.send_to_addr(msg, &sock1_addr));
 306     let mut buf = [0; 11];
 307     let (_, addr) = or_panic!(sock1.recv_from(&mut buf));
 308
 309     let new_msg = b"hello back";
 310     let mut new_buf = [0; 10];
 311     or_panic!(sock2.connect_addr(&addr));
 312     or_panic!(sock2.send(new_msg)); // set by connect_addr
 313     let usize = or_panic!(sock2.recv(&mut new_buf));
 314     assert_eq!(usize, 10);
 315     assert_eq!(new_msg, &new_buf[..]);
 316 }
 317
 318 #[test]
 319 fn test_connect_unix_datagram() {
 320     let dir = tmpdir();
 321     let path1 = dir.path().join("sock1");
 322     let path2 = dir.path().join("sock2");
 323
 324     let bsock1 = or_panic!(UnixDatagram::bind(&path1));
 325     let bsock2 = or_panic!(UnixDatagram::bind(&path2));
 326     let sock = or_panic!(UnixDatagram::unbound());
 327     or_panic!(sock.connect(&path1));
 328
 329     // Check send()
 330     let msg = b"hello there";
 331     or_panic!(sock.send(msg));
 332     let mut buf = [0; 11];
 333     let (usize, addr) = or_panic!(bsock1.recv_from(&mut buf));
 334     assert_eq!(usize, 11);
 335     assert!(addr.is_unnamed());
 336     assert_eq!(msg, &buf[..]);
 337
 338     // Changing default socket works too
 339     or_panic!(sock.connect(&path2));
 340     or_panic!(sock.send(msg));
 341     or_panic!(bsock2.recv_from(&mut buf));
 342 }
 343
 344 #[test]
 345 fn test_unix_datagram_recv() {
 346     let dir = tmpdir();
 347     let path1 = dir.path().join("sock1");
 348
 349     let sock1 = or_panic!(UnixDatagram::bind(&path1));
 350     let sock2 = or_panic!(UnixDatagram::unbound());
 351     or_panic!(sock2.connect(&path1));
 352
 353     let msg = b"hello world";
 354     or_panic!(sock2.send(msg));
 355     let mut buf = [0; 11];
 356     let size = or_panic!(sock1.recv(&mut buf));
 357     assert_eq!(size, 11);
 358     assert_eq!(msg, &buf[..]);
 359 }
 360
 361 #[test]
 362 fn datagram_pair() {
 363     let msg1 = b"hello";
 364     let msg2 = b"world!";
 365
 366     let (s1, s2) = or_panic!(UnixDatagram::pair());
 367     let thread = thread::spawn(move || {
 368         // s1 must be moved in or the test will hang!
 369         let mut buf = [0; 5];
 370         or_panic!(s1.recv(&mut buf));
 371         assert_eq!(&msg1[..], &buf[..]);
 372         or_panic!(s1.send(msg2));
 373     });
 374
 375     or_panic!(s2.send(msg1));
 376     let mut buf = [0; 6];
 377     or_panic!(s2.recv(&mut buf));
 378     assert_eq!(&msg2[..], &buf[..]);
 379     drop(s2);
 380
 381     thread.join().unwrap();
 382 }
 383
 384 // Ensure the `set_read_timeout` and `set_write_timeout` calls return errors
 385 // when passed zero Durations
 386 #[test]
 387 fn test_unix_datagram_timeout_zero_duration() {
 388     let dir = tmpdir();
 389     let path = dir.path().join("sock");
 390
 391     let datagram = or_panic!(UnixDatagram::bind(&path));
 392
 393     let result = datagram.set_write_timeout(Some(Duration::new(0, 0)));
 394     let err = result.unwrap_err();
 395     assert_eq!(err.kind(), ErrorKind::InvalidInput);
 396
 397     let result = datagram.set_read_timeout(Some(Duration::new(0, 0)));
 398     let err = result.unwrap_err();
 399     assert_eq!(err.kind(), ErrorKind::InvalidInput);
 400 }
 401
 402 #[test]
 403 fn abstract_namespace_not_allowed_connect() {
 404     assert!(UnixStream::connect("\0asdf").is_err());
 405 }
 406
 407 #[cfg(any(target_os = "android", target_os = "linux"))]
 408 #[test]
 409 fn test_abstract_stream_connect() {
 410     let msg1 = b"hello";
 411     let msg2 = b"world";
 412
 413     let socket_addr = or_panic!(SocketAddr::from_abstract_name(b"name"));
 414     let listener = or_panic!(UnixListener::bind_addr(&socket_addr));
 415
 416     let thread = thread::spawn(move || {
 417         let mut stream = or_panic!(listener.accept()).0;
 418         let mut buf = [0; 5];
 419         or_panic!(stream.read(&mut buf));
 420         assert_eq!(&msg1[..], &buf[..]);
 421         or_panic!(stream.write_all(msg2));
 422     });
 423
 424     let mut stream = or_panic!(UnixStream::connect_addr(&socket_addr));
 425
 426     let peer = or_panic!(stream.peer_addr());
 427     assert_eq!(peer.as_abstract_name().unwrap(), b"name");
 428
 429     or_panic!(stream.write_all(msg1));
 430     let mut buf = vec![];
 431     or_panic!(stream.read_to_end(&mut buf));
 432     assert_eq!(&msg2[..], &buf[..]);
 433     drop(stream);
 434
 435     thread.join().unwrap();
 436 }
 437
 438 #[cfg(any(target_os = "android", target_os = "linux"))]
 439 #[test]
 440 fn test_abstract_stream_iter() {
 441     let addr = or_panic!(SocketAddr::from_abstract_name(b"hidden"));
 442     let listener = or_panic!(UnixListener::bind_addr(&addr));
 443
 444     let thread = thread::spawn(move || {
 445         for stream in listener.incoming().take(2) {
 446             let mut stream = or_panic!(stream);
 447             let mut buf = [0];
 448             or_panic!(stream.read(&mut buf));
 449         }
 450     });
 451
 452     for _ in 0..2 {
 453         let mut stream = or_panic!(UnixStream::connect_addr(&addr));
 454         or_panic!(stream.write_all(&[0]));
 455     }
 456
 457     thread.join().unwrap();
 458 }
 459
 460 #[cfg(any(target_os = "android", target_os = "linux"))]
 461 #[test]
 462 fn test_abstract_datagram_bind_send_to_addr() {
 463     let addr1 = or_panic!(SocketAddr::from_abstract_name(b"ns1"));
 464     let sock1 = or_panic!(UnixDatagram::bind_addr(&addr1));
 465
 466     let local = or_panic!(sock1.local_addr());
 467     assert_eq!(local.as_abstract_name().unwrap(), b"ns1");
 468
 469     let addr2 = or_panic!(SocketAddr::from_abstract_name(b"ns2"));
 470     let sock2 = or_panic!(UnixDatagram::bind_addr(&addr2));
 471
 472     let msg = b"hello world";
 473     or_panic!(sock1.send_to_addr(msg, &addr2));
 474     let mut buf = [0; 11];
 475     let (len, addr) = or_panic!(sock2.recv_from(&mut buf));
 476     assert_eq!(msg, &buf[..]);
 477     assert_eq!(len, 11);
 478     assert_eq!(addr.as_abstract_name().unwrap(), b"ns1");
 479 }
 480
 481 #[cfg(any(target_os = "android", target_os = "linux"))]
 482 #[test]
 483 fn test_abstract_datagram_connect_addr() {
 484     let addr1 = or_panic!(SocketAddr::from_abstract_name(b"ns3"));
 485     let bsock1 = or_panic!(UnixDatagram::bind_addr(&addr1));
 486
 487     let sock = or_panic!(UnixDatagram::unbound());
 488     or_panic!(sock.connect_addr(&addr1));
 489
 490     let msg = b"hello world";
 491     or_panic!(sock.send(msg));
 492     let mut buf = [0; 11];
 493     let (len, addr) = or_panic!(bsock1.recv_from(&mut buf));
 494     assert_eq!(len, 11);
 495     assert_eq!(addr.is_unnamed(), true);
 496     assert_eq!(msg, &buf[..]);
 497
 498     let addr2 = or_panic!(SocketAddr::from_abstract_name(b"ns4"));
 499     let bsock2 = or_panic!(UnixDatagram::bind_addr(&addr2));
 500
 501     or_panic!(sock.connect_addr(&addr2));
 502     or_panic!(sock.send(msg));
 503     or_panic!(bsock2.recv_from(&mut buf));
 504 }
 505
 506 #[cfg(any(target_os = "android", target_os = "linux"))]
 507 #[test]
 508 fn test_abstract_name_too_long() {
 509     match SocketAddr::from_abstract_name(
 510         b"abcdefghijklmnopqrstuvwxyzabcdefghijklmn\
 511         opqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghi\
 512         jklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz",
 513     ) {
 514         Err(ref e) if e.kind() == io::ErrorKind::InvalidInput => {}
 515         Err(e) => panic!("unexpected error {e}"),
 516         Ok(_) => panic!("unexpected success"),
 517     }
 518 }
 519
 520 #[cfg(any(target_os = "android", target_os = "linux"))]
 521 #[test]
 522 fn test_abstract_no_pathname_and_not_unnamed() {
 523     let name = b"local";
 524     let addr = or_panic!(SocketAddr::from_abstract_name(name));
 525     assert_eq!(addr.as_pathname(), None);
 526     assert_eq!(addr.as_abstract_name(), Some(&name[..]));
 527     assert_eq!(addr.is_unnamed(), false);
 528 }
 529
 530 #[test]
 531 fn test_unix_stream_peek() {
 532     let (txdone, rxdone) = crate::sync::mpsc::channel();
 533
 534     let dir = tmpdir();
 535     let path = dir.path().join("sock");
 536
 537     let listener = or_panic!(UnixListener::bind(&path));
 538     let thread = thread::spawn(move || {
 539         let mut stream = or_panic!(listener.accept()).0;
 540         or_panic!(stream.write_all(&[1, 3, 3, 7]));
 541         or_panic!(rxdone.recv());
 542     });
 543
 544     let mut stream = or_panic!(UnixStream::connect(&path));
 545     let mut buf = [0; 10];
 546     for _ in 0..2 {
 547         assert_eq!(or_panic!(stream.peek(&mut buf)), 4);
 548     }
 549     assert_eq!(or_panic!(stream.read(&mut buf)), 4);
 550
 551     or_panic!(stream.set_nonblocking(true));
 552     match stream.peek(&mut buf) {
 553         Ok(_) => panic!("expected error"),
 554         Err(ref e) if e.kind() == ErrorKind::WouldBlock => {}
 555         Err(e) => panic!("unexpected error: {e}"),
 556     }
 557
 558     or_panic!(txdone.send(()));
 559     thread.join().unwrap();
 560 }
 561
 562 #[test]
 563 fn test_unix_datagram_peek() {
 564     let dir = tmpdir();
 565     let path1 = dir.path().join("sock");
 566
 567     let sock1 = or_panic!(UnixDatagram::bind(&path1));
 568     let sock2 = or_panic!(UnixDatagram::unbound());
 569     or_panic!(sock2.connect(&path1));
 570
 571     let msg = b"hello world";
 572     or_panic!(sock2.send(msg));
 573     for _ in 0..2 {
 574         let mut buf = [0; 11];
 575         let size = or_panic!(sock1.peek(&mut buf));
 576         assert_eq!(size, 11);
 577         assert_eq!(msg, &buf[..]);
 578     }
 579
 580     let mut buf = [0; 11];
 581     let size = or_panic!(sock1.recv(&mut buf));
 582     assert_eq!(size, 11);
 583     assert_eq!(msg, &buf[..]);
 584 }
 585
 586 #[test]
 587 fn test_unix_datagram_peek_from() {
 588     let dir = tmpdir();
 589     let path1 = dir.path().join("sock");
 590
 591     let sock1 = or_panic!(UnixDatagram::bind(&path1));
 592     let sock2 = or_panic!(UnixDatagram::unbound());
 593     or_panic!(sock2.connect(&path1));
 594
 595     let msg = b"hello world";
 596     or_panic!(sock2.send(msg));
 597     for _ in 0..2 {
 598         let mut buf = [0; 11];
 599         let (size, _) = or_panic!(sock1.peek_from(&mut buf));
 600         assert_eq!(size, 11);
 601         assert_eq!(msg, &buf[..]);
 602     }
 603
 604     let mut buf = [0; 11];
 605     let size = or_panic!(sock1.recv(&mut buf));
 606     assert_eq!(size, 11);
 607     assert_eq!(msg, &buf[..]);
 608 }
 609
 610 #[cfg(any(target_os = "android", target_os = "linux"))]
 611 #[test]
 612 fn test_send_vectored_fds_unix_stream() {
 613     let (s1, s2) = or_panic!(UnixStream::pair());
 614
 615     let buf1 = [1; 8];
 616     let bufs_send = &[IoSlice::new(&buf1[..])][..];
 617
 618     let mut ancillary1_buffer = [0; 128];
 619     let mut ancillary1 = SocketAncillary::new(&mut ancillary1_buffer[..]);
 620     assert!(ancillary1.add_fds(&[s1.as_raw_fd()][..]));
 621
 622     let usize = or_panic!(s1.send_vectored_with_ancillary(&bufs_send, &mut ancillary1));
 623     assert_eq!(usize, 8);
 624
 625     let mut buf2 = [0; 8];
 626     let mut bufs_recv = &mut [IoSliceMut::new(&mut buf2[..])][..];
 627
 628     let mut ancillary2_buffer = [0; 128];
 629     let mut ancillary2 = SocketAncillary::new(&mut ancillary2_buffer[..]);
 630
 631     let usize = or_panic!(s2.recv_vectored_with_ancillary(&mut bufs_recv, &mut ancillary2));
 632     assert_eq!(usize, 8);
 633     assert_eq!(buf1, buf2);
 634
 635     let mut ancillary_data_vec = Vec::from_iter(ancillary2.messages());
 636     assert_eq!(ancillary_data_vec.len(), 1);
 637     if let AncillaryData::ScmRights(scm_rights) = ancillary_data_vec.pop().unwrap().unwrap() {
 638         let fd_vec = Vec::from_iter(scm_rights);
 639         assert_eq!(fd_vec.len(), 1);
 640         unsafe {
 641             libc::close(fd_vec[0]);
 642         }
 643     } else {
 644         unreachable!("must be ScmRights");
 645     }
 646 }
 647
 648 #[cfg(any(target_os = "android", target_os = "linux",))]
 649 #[test]
 650 fn test_send_vectored_with_ancillary_to_unix_datagram() {
 651     fn getpid() -> libc::pid_t {
 652         unsafe { libc::getpid() }
 653     }
 654
 655     fn getuid() -> libc::uid_t {
 656         unsafe { libc::getuid() }
 657     }
 658
 659     fn getgid() -> libc::gid_t {
 660         unsafe { libc::getgid() }
 661     }
 662
 663     let dir = tmpdir();
 664     let path1 = dir.path().join("sock1");
 665     let path2 = dir.path().join("sock2");
 666
 667     let bsock1 = or_panic!(UnixDatagram::bind(&path1));
 668     let bsock2 = or_panic!(UnixDatagram::bind(&path2));
 669
 670     or_panic!(bsock2.set_passcred(true));
 671
 672     let buf1 = [1; 8];
 673     let bufs_send = &[IoSlice::new(&buf1[..])][..];
 674
 675     let mut ancillary1_buffer = [0; 128];
 676     let mut ancillary1 = SocketAncillary::new(&mut ancillary1_buffer[..]);
 677     let mut cred1 = SocketCred::new();
 678     cred1.set_pid(getpid());
 679     cred1.set_uid(getuid());
 680     cred1.set_gid(getgid());
 681     assert!(ancillary1.add_creds(&[cred1.clone()][..]));
 682
 683     let usize =
 684         or_panic!(bsock1.send_vectored_with_ancillary_to(&bufs_send, &mut ancillary1, &path2));
 685     assert_eq!(usize, 8);
 686
 687     let mut buf2 = [0; 8];
 688     let mut bufs_recv = &mut [IoSliceMut::new(&mut buf2[..])][..];
 689
 690     let mut ancillary2_buffer = [0; 128];
 691     let mut ancillary2 = SocketAncillary::new(&mut ancillary2_buffer[..]);
 692
 693     let (usize, truncated, _addr) =
 694         or_panic!(bsock2.recv_vectored_with_ancillary_from(&mut bufs_recv, &mut ancillary2));
 695     assert_eq!(ancillary2.truncated(), false);
 696     assert_eq!(usize, 8);
 697     assert_eq!(truncated, false);
 698     assert_eq!(buf1, buf2);
 699
 700     let mut ancillary_data_vec = Vec::from_iter(ancillary2.messages());
 701     assert_eq!(ancillary_data_vec.len(), 1);
 702     if let AncillaryData::ScmCredentials(scm_credentials) =
 703         ancillary_data_vec.pop().unwrap().unwrap()
 704     {
 705         let cred_vec = Vec::from_iter(scm_credentials);
 706         assert_eq!(cred_vec.len(), 1);
 707         assert_eq!(cred1.get_pid(), cred_vec[0].get_pid());
 708         assert_eq!(cred1.get_uid(), cred_vec[0].get_uid());
 709         assert_eq!(cred1.get_gid(), cred_vec[0].get_gid());
 710     } else {
 711         unreachable!("must be ScmCredentials");
 712     }
 713 }
 714
 715 #[cfg(any(target_os = "android", target_os = "linux"))]
 716 #[test]
 717 fn test_send_vectored_with_ancillary_unix_datagram() {
 718     let dir = tmpdir();
 719     let path1 = dir.path().join("sock1");
 720     let path2 = dir.path().join("sock2");
 721
 722     let bsock1 = or_panic!(UnixDatagram::bind(&path1));
 723     let bsock2 = or_panic!(UnixDatagram::bind(&path2));
 724
 725     let buf1 = [1; 8];
 726     let bufs_send = &[IoSlice::new(&buf1[..])][..];
 727
 728     let mut ancillary1_buffer = [0; 128];
 729     let mut ancillary1 = SocketAncillary::new(&mut ancillary1_buffer[..]);
 730     assert!(ancillary1.add_fds(&[bsock1.as_raw_fd()][..]));
 731
 732     or_panic!(bsock1.connect(&path2));
 733     let usize = or_panic!(bsock1.send_vectored_with_ancillary(&bufs_send, &mut ancillary1));
 734     assert_eq!(usize, 8);
 735
 736     let mut buf2 = [0; 8];
 737     let mut bufs_recv = &mut [IoSliceMut::new(&mut buf2[..])][..];
 738
 739     let mut ancillary2_buffer = [0; 128];
 740     let mut ancillary2 = SocketAncillary::new(&mut ancillary2_buffer[..]);
 741
 742     let (usize, truncated) =
 743         or_panic!(bsock2.recv_vectored_with_ancillary(&mut bufs_recv, &mut ancillary2));
 744     assert_eq!(usize, 8);
 745     assert_eq!(truncated, false);
 746     assert_eq!(buf1, buf2);
 747
 748     let mut ancillary_data_vec = Vec::from_iter(ancillary2.messages());
 749     assert_eq!(ancillary_data_vec.len(), 1);
 750     if let AncillaryData::ScmRights(scm_rights) = ancillary_data_vec.pop().unwrap().unwrap() {
 751         let fd_vec = Vec::from_iter(scm_rights);
 752         assert_eq!(fd_vec.len(), 1);
 753         unsafe {
 754             libc::close(fd_vec[0]);
 755         }
 756     } else {
 757         unreachable!("must be ScmRights");
 758     }
 759 }