`SockaddrStorage::as_sockaddr_in` incorrectly returns None sometime

[poliorcetics]

On nix 0.24.x the following is necessary to always manage to extract the IP address (and maybe something similar is needed for IPv6, but I have not encountered the problem

/// Converts a socket addr into an IP address when possible
fn try_into_ip_addr(s: &SockaddrStorage) -> Option<std::net::IpAddr> {
    // Normal method
    let or_else = s
        .as_sockaddr_in()
        .map(|sa| sa.ip().to_be_bytes().into())
        .or_else(|| s.as_sockaddr_in6().map(|sa| sa.ip().into()));

    // Start of the fallback
    match initial_method {
        im @ Some(_) => return im,
        None => (),
    }

    let sock_addr = unsafe { s.as_ptr().as_ref()? };
    if i32::from(sock_addr.sa_family) == nix::libc::AF_INET {
        dbg!(&s);
        let sock_addr = unsafe { *s.as_ptr().cast::<nix::libc::sockaddr_in>() };
        Some(Ipv4Addr::from(sock_addr.sin_addr.s_addr).into())
    } else {
        None
    }
}

Maybe something about the size ?

I'm on macOS 12 but CI also fails for every type of Linux we have, both GNU and MUSL

[asomers]

What code did you try first, and what error did you get?

[asomers]

Also, is that IpAddr a std::net::IpAddr or a nix::sys::socket::IpAddr?

[poliorcetics]

We have an InterfaceAddress we originally got from getifaddrs(). We try to get the IP of its netmask member using try_into_ip_addr.

I modified the original code to add a dgb! call, I get this in the branch:

&s = SockaddrStorage {
    ss: sockaddr_storage {
        ss_len: 7,
        ss_family: 2,
        __ss_pad1: [
            0,
            0,
            255,
            255,
            255,
            0,
        ],
        __ss_align: 2882523706792346128,
    },
}

ss_family: 2 is AF_INET, which should be caught by as_sockaddr_in earlier but is not. Going down in SockaddrIn::from_raw, I think this is a size problem, but I have no idea why

[asomers]

You said that the original version of try_into_ip_addr didn't work. What was that original version, and what error did you get?

[poliorcetics]

Original version, for 0.23 (modulo types that did not exist then), which returns None for the Debug output in my previous message

/// Converts a socket addr into an IP address when possible
fn try_into_ip_addr(s: &SockaddrStorage) -> Option<std::net::IpAddr> {
    s
        .as_sockaddr_in()
        .map(|sa| sa.ip().to_be_bytes().into())
        .or_else(|| s.as_sockaddr_in6().map(|sa| sa.ip().into()))
}

[asomers]

Since you're narrowed it down fairly far, would you be able to combine all of these things into an executable test case?

[asomers]

@poliorcetics would you be able to come up with an executable example of the problem? If so we'll make a patch release to fix it.

[poliorcetics]

Sorry for the month-long wait

Edit: see my next comment for test code

[asomers]

I think you're making this too complicated. All I need for a test case is something like the following:

fn tc() {
    let raw = libc::sockaddr_storage { ... };
    let ss = nix::sys::socket::SockaddrStorage::from_raw(raw);
    assert!(ss.as_sockaddr_in().is_some());
}

And you should be able to get the initializer for the libc::sockaddr_storage just by adding a dbg!(&s) to the top of your into_ip_addr function above.

[poliorcetics]

Several test cases, I also put the function into_ip_addr to show it manages to find data (on my machine, all the failures happen on the as_sockaddr_in(raw) call).

#[cfg(test)]
mod tests {
    use nix::sys::socket::SockaddrLike;

    #[repr(C)]
    #[derive(Debug, Clone, Copy)]
    #[allow(non_camel_case_types)]
    // Some members are private but we need them initialized for the tests
    struct sockaddr_storage {
        ss_len: u8,
        ss_family: nix::libc::sa_family_t,
        __ss_pad1: [u8; 6],
        __ss_align: i64,
        // __ss_pad2: [u8; 112],
    }

    #[track_caller]
    fn as_sockaddr_in(raw: sockaddr_storage) {
        let ss = unsafe {
            nix::sys::socket::SockaddrStorage::from_raw(
                &raw as *const sockaddr_storage as *const _,
                None,
            )
        }
        .unwrap();
        assert!(ss.as_sockaddr_in().is_some());
    }

    #[track_caller]
    fn into_ip_addr(raw: sockaddr_storage) -> Option<std::net::IpAddr> {
        let s = unsafe {
            nix::sys::socket::SockaddrStorage::from_raw(
                &raw as *const sockaddr_storage as *const _,
                None,
            )
        }
        .unwrap();
        let initial_method = s
            .as_sockaddr_in()
            .map(|sa| sa.ip().to_be_bytes().into())
            .or_else(|| s.as_sockaddr_in6().map(|sa| sa.ip().into()));

        match initial_method {
            im @ Some(_) => return im,
            None => (),
        }

        // Sometimes `as_sockaddr_in` fails despite the inner data being present and
        // seemingly correct. Investigations point towards a size issue for the padding
        // at the end of the structure, which does not affect us.
        //
        // Safety: the pointer is valid (notably, aligned) and not accessed mutably
        let sock_addr = unsafe { s.as_ptr().as_ref()? };
        if i32::from(sock_addr.sa_family) == nix::libc::AF_INET {
            // Safety: if AF_INET is set for `family`, casting
            // to `sockaddr_in` is safe, as is dereferencing
            let sock_addr = unsafe { *s.as_ptr().cast::<nix::libc::sockaddr_in>() };
            Some(std::net::Ipv4Addr::from(sock_addr.sin_addr.s_addr).into())
        } else {
            None
        }
    }

    #[test]
    fn t1() {
        let raw = sockaddr_storage {
            ss_len: 5,
            ss_family: 2,
            __ss_pad1: [0, 0, 255, 0, 0, 0],
            __ss_align: 72058139498775056,
        };
        into_ip_addr(raw).unwrap();
        as_sockaddr_in(raw);
    }

    #[test]
    fn t2() {
        let raw = sockaddr_storage {
            ss_len: 7,
            ss_family: 2,
            __ss_pad1: [0, 0, 255, 255, 255, 0],
            __ss_align: 2306310026777592336,
        };
        into_ip_addr(raw).unwrap();
        as_sockaddr_in(raw);
    }

    #[test]
    fn t3() {
        let raw = sockaddr_storage {
            ss_len: 7,
            ss_family: 2,
            __ss_pad1: [0, 0, 255, 255, 255, 0],
            __ss_align: -5043564565091057136,
        };
        into_ip_addr(raw).unwrap();
        as_sockaddr_in(raw);
    }

    #[test]
    fn t4() {
        let raw = sockaddr_storage {
            ss_len: 7,
            ss_family: 2,
            __ss_pad1: [0, 0, 255, 255, 255, 0],
            __ss_align: 2882523706792346128,
        };
        into_ip_addr(raw).unwrap();
        as_sockaddr_in(raw);
    }
}

[rtzoeller]

@asomers do you have a Mac that you can try the reproducing example on? I tried following the logic by hand (the Linux libc definitions differ enough to make it unusable) but nothing jumped out.

[asomers]

Ok, these test cases show the problem: your value for the ss_len field is wrong. That field should contain the size of the valid parts of the structure. For IPv4 it should be 16 bytes and for IPv6 28. You should take a look at the code that's creating those structures.

Note that Linux does not have any ss_len field. So if somebody tried to create a sockaddr_storage by hand, rather than getting it from the OS, then that could result in a function that works on Linux but fails everywhere else.

[poliorcetics]

You should take a look at the code that's creating those structures.

I use nix's getifaddrs function, see the previous edit on this comment

Previous comment

Output of `cargo run`, the last line shows `None` when it should show the same data as the previous call

[src/main.rs:9] list_nics(false).unwrap().count() = 18
[src/main.rs:10] list_nics(true).unwrap().count() = 18
[src/main.rs:14] find_netmask(host, port, true).unwrap() = Some(
    0.255.255.255,
)
[src/main.rs:15] find_netmask(host, port, false).unwrap() = None

use std::collections::HashMap;
use std::error::Error;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, ToSocketAddrs, UdpSocket};

use nix::ifaddrs::{getifaddrs, InterfaceAddress};
use nix::sys::socket::{SockaddrLike, SockaddrStorage};

fn main() {
    let _ = dbg!(list_nics(false).unwrap().count());
    let _ = dbg!(list_nics(true).unwrap().count());

    let host = "example.com";
    let port = 80;
    dbg!(find_netmask(host, port, true).unwrap());
    dbg!(find_netmask(host, port, false).unwrap());
}

#[derive(Clone, Debug)]
pub struct Nic(InterfaceAddress, IpAddr);

impl Nic {
    pub fn name(&self) -> &str {
        self.0.interface_name.as_str()
    }

    pub fn address(&self) -> IpAddr {
        self.1
    }

    pub fn netmask(&self, with_fix: bool) -> Option<IpAddr> {
        self.0
            .netmask
            .as_ref()
            .and_then(|s| into_ip_addr(s, with_fix))
    }
}

#[derive(Default, Clone, Debug)]
pub struct InterfaceInfo(Vec<ProtoInterfaceAddress>);

#[derive(Default, Clone, Debug)]
pub struct ProtoInterfaceAddress {
    pub address: Option<IpAddr>,
    pub netmask: Option<IpAddr>,
}

fn find_netmask(host: &str, port: u8, with_fix: bool) -> Result<Option<IpAddr>, Box<dyn Error>> {
    let mut new_host = host.to_string();
    if host.parse::<Ipv6Addr>().is_ok() {
        new_host = format!("[{}]", host);
    }
    let destination = format!("{}:{}", new_host, port);
    // Passing 0.0.0.0:0 (or [::]:0) will let the OS choose for us depending on the destination
    let ip = get_ip("0.0.0.0:0", &destination)
        .or_else(|_e| get_ip("[::]:0", &destination))
        .unwrap();

    let mut infos: HashMap<String, InterfaceInfo> = HashMap::new();
    for iface in list_nics(with_fix)? {
        let iface_info = infos
            .entry(iface.name().to_string())
            .or_insert_with(InterfaceInfo::default);
        iface_info.0.push(ProtoInterfaceAddress {
            address: Some(iface.address()),
            netmask: iface.netmask(with_fix),
            netmask: iface.netmask(with_fix).map(Into::into),
        });
    }

    Ok(infos
        .values()
        .flat_map(|v| v.0.iter())
        .find(|v| v.address.as_ref() == Some(&ip))
        .and_then(|v| v.netmask))
}

fn get_ip<A: ToSocketAddrs + ?Sized, B: ToSocketAddrs + ?Sized>(
    bind_addr: &A,
    destination: &B,
) -> std::io::Result<IpAddr> {
    let socket = UdpSocket::bind(bind_addr)?;
    socket.connect(destination)?;
    socket.local_addr().map(|sa| sa.ip())
}

pub fn list_nics(with_fix: bool) -> std::io::Result<impl Iterator<Item = Nic>> {
    Ok(getifaddrs()?.filter_map(move |addr| match &addr.address {
        Some(address) => into_ip_addr(address, with_fix).map(|ip| Nic(addr, ip)),
        _ => None,
    }))
}

fn into_ip_addr(s: &SockaddrStorage, with_fix: bool) -> Option<IpAddr> {
    let initial_method = s
        .as_sockaddr_in()
        .map(|sa| sa.ip().to_be_bytes().into())
        .or_else(|| s.as_sockaddr_in6().map(|sa| sa.ip().into()));

    match initial_method {
        im @ Some(_) => return im,
        None => (),
    }

    if !with_fix {
        return None;
    }

    // Sometimes `as_sockaddr_in` fails despite the inner data being present and
    // seemingly correct. Investigations point towards a size issue for the padding
    // at the end of the structure, which does not affect us.
    //
    // Safety: the pointer is valid (notably, aligned) and not accessed mutably
    let sock_addr = unsafe { s.as_ptr().as_ref()? };
    if i32::from(sock_addr.sa_family) == nix::libc::AF_INET {
        // Safety: if AF_INET is set for `family`, casting
        // to `sockaddr_in` is safe, as is dereferencing
        let sock_addr = unsafe { *s.as_ptr().cast::<nix::libc::sockaddr_in>() };
        Some(Ipv4Addr::from(sock_addr.sin_addr.s_addr).into())
    } else {
        None
    }
}