let mut first_local = None;

for address in addresses {

if address == [0; 6] {

continue;

}

if address[0] & 0x02 == 0 {

return Some(address);

}

first_local.get_or_insert(address);

}

first_local

use super::select_mac_address;

#[test]

fn prefers_universally_administered_address() {

let local = [0x02, 0, 0, 0, 0, 1];

let universal = [0x00, 0, 0, 0, 0, 2];

assert_eq!(select_mac_address([local, universal]), Some(universal));

}

#[test]

fn falls_back_to_first_locally_administered_address() {

let first = [0x02, 0, 0, 0, 0, 1];

let second = [0x06, 0, 0, 0, 0, 2];

assert_eq!(select_mac_address([first, second]), Some(first));

}

#[test]

fn ignores_zero_address() {

let universal = [0x00, 0, 0, 0, 0, 1];

assert_eq!(select_mac_address([[0; 6], universal]), Some(universal));

assert_eq!(select_mac_address([[0; 6]]), None);

}

let ret = unsafe { libc::close(socket) };

if ret < 0 {

let err = io::Error::last_os_error();

if err.raw_os_error() != Some(libc::ECONNRESET) {

return Err(err);

}

}

Ok(())

let mut flag: libc::c_int = 0;

let mut flagsize = core::mem::size_of::<libc::c_int>() as libc::socklen_t;

unsafe {

libc::getsockopt(

fd,

level,

name,

&mut flag as *mut libc::c_int as *mut _,

&mut flagsize,

)

}

.check_libc_neg()?;

Ok(flag)

fd: libc::c_int,

level: i32,

name: i32,

buflen: usize,

) -> io::Result<Vec<u8>> {

let mut buf = vec![0u8; buflen];

let mut optlen = buflen as libc::socklen_t;

unsafe { libc::getsockopt(fd, level, name, buf.as_mut_ptr() as *mut _, &mut optlen) }

.check_libc_neg()?;

buf.truncate(optlen as usize);

Ok(buf)

unsafe {

libc::setsockopt(

fd,

level,

name,

value.as_ptr() as *const _,

value.len() as libc::socklen_t,

)

}

.check_libc_neg()?;

Ok(())

unsafe {

libc::setsockopt(

fd,

level,

name,

&value as *const i32 as *const _,

core::mem::size_of::<i32>() as libc::socklen_t,

)

}

.check_libc_neg()?;

Ok(())

unsafe {

libc::setsockopt(

fd,

level,

name,

core::ptr::null(),

optlen as libc::socklen_t,

)

}

.check_libc_neg()?;

Ok(())

let list = nix::net::if_::if_nameindex().map_err(io::Error::from)?;

Ok(list

.to_slice()

.iter()

.map(|iface| (iface.index(), iface.name().to_string_lossy().into_owned()))

.collect())

let ret = unsafe { libc::if_nametoindex(name.as_ptr()) };

if ret == 0 {

Err(io::Error::last_os_error())

} else {

Ok(ret)

}

let mut buf = [0u8; libc::IF_NAMESIZE];

let ret = unsafe {

libc::if_indextoname(index as libc::c_uint, buf.as_mut_ptr() as *mut libc::c_char)

};

if ret.is_null() {

Err(io::Error::last_os_error())

} else {

let buf = unsafe { CStr::from_ptr(buf.as_ptr() as *const libc::c_char) };

Ok(buf.to_string_lossy().into_owned())

}

unsafe { CStr::from_ptr(libc::gai_strerror(err)) }

.to_string_lossy()

.into_owned()

unsafe { CStr::from_ptr(libc::hstrerror(err)) }

.to_string_lossy()

.into_owned()

pub level: i32,

pub kind: i32,

pub data: Vec<u8>,