starry-kernel 0.10.1

//! Wrapper for [`sockaddr`]. Using trait to convert between [`SocketAddr`] and
//! [`sockaddr`] types.

use alloc::vec::Vec;
use core::{
    mem::size_of,
    net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6},
};

#[cfg(feature = "vsock")]
use ax_net::vsock::VsockAddr;
use ax_net::{SocketAddrEx, unix::UnixSocketAddr};
#[cfg(feature = "vsock")]
use bytemuck::AnyBitPattern;
use linux_raw_sys::{net::*, netlink::sockaddr_nl};

use crate::{
    Errno, StarryError, StarryResult,
    mm::{UserConstPtr, UserPtr},
};

pub fn normalize_socket_addr_ex_for_ip_stack(
    addr: SocketAddrEx,
    is_bind: bool,
) -> StarryResult<SocketAddrEx> {
    match addr {
        SocketAddrEx::Ip(SocketAddr::V4(_)) => Ok(addr),
        SocketAddrEx::Ip(SocketAddr::V6(v6)) => {
            let ip = *v6.ip();
            let v4 = if let Some(v4) = ip.to_ipv4_mapped() {
                v4
            } else if ip.is_unspecified() {
                if !is_bind {
                    return Err(StarryError::from(Errno::EINVAL));
                }
                Ipv4Addr::UNSPECIFIED
            } else if ip == Ipv6Addr::LOCALHOST {
                Ipv4Addr::LOCALHOST
            } else if is_bind {
                return Err(StarryError::from(Errno::EADDRNOTAVAIL));
            } else {
                return Err(StarryError::from(Errno::ENETUNREACH));
            };
            Ok(SocketAddrEx::Ip(SocketAddr::V4(SocketAddrV4::new(
                v4,
                v6.port(),
            ))))
        }
        SocketAddrEx::Unix(_) => Ok(addr),
        #[cfg(feature = "vsock")]
        SocketAddrEx::Vsock(_) => Ok(addr),
    }
}

pub fn socket_addr_ex_for_user_name(domain: u32, addr: SocketAddrEx) -> SocketAddrEx {
    if domain != AF_INET6 {
        return addr;
    }
    match addr {
        SocketAddrEx::Ip(SocketAddr::V4(v4)) => {
            SocketAddrEx::Ip(SocketAddr::V6(socket_addr_v4_to_mapped_v6(&v4)))
        }
        _ => addr,
    }
}

pub fn socket_addr_v4_to_mapped_v6(v4: &SocketAddrV4) -> SocketAddrV6 {
    SocketAddrV6::new(v4.ip().to_ipv6_mapped(), v4.port(), 0, 0)
}

/// Trait to extend [`SocketAddr`] and its variants with methods for reading
/// from and writing to user space.
pub trait SocketAddrExt: Sized {
    /// This method attempts to interpret the data pointed to by `addr` with the
    /// given `addrlen` as a valid socket address of the implementing type.
    fn read_from_user(
        current: &crate::task::UserTaskRef,
        addr: UserConstPtr<sockaddr>,
        addrlen: socklen_t,
    ) -> crate::StarryResult<Self>;

    /// This method serializes the current socket address instance into the
    /// [`sockaddr`] structure pointed to by `addr` in user space.
    fn write_to_user(
        &self,
        current: &crate::task::UserTaskRef,
        addr: UserPtr<sockaddr>,
        addrlen: &mut socklen_t,
    ) -> crate::StarryResult<()>;

    /// Gets the address family of the socket address.
    #[allow(dead_code)]
    fn family(&self) -> u16;
}

fn read_family(
    current: &crate::task::UserTaskRef,
    addr: UserConstPtr<sockaddr>,
    addrlen: socklen_t,
) -> crate::StarryResult<u16> {
    if size_of::<__kernel_sa_family_t>() > addrlen as usize {
        return Err(StarryError::InvalidInput);
    }
    addr.cast::<__kernel_sa_family_t>().read(current)
}
unsafe fn cast_to_slice<T>(value: &T) -> &[u8] {
    unsafe { core::slice::from_raw_parts(value as *const T as *const u8, size_of::<T>()) }
}
fn fill_addr(
    current: &crate::task::UserTaskRef,
    addr: UserPtr<sockaddr>,
    addrlen: &mut socklen_t,
    data: &[u8],
) -> crate::StarryResult<()> {
    let len = (*addrlen as usize).min(data.len());
    addr.cast::<u8>().write_slice(current, &data[..len])?;
    *addrlen = data.len() as _;
    Ok(())
}

pub fn read_netlink_addr(
    current: &crate::task::UserTaskRef,
    addr: UserConstPtr<sockaddr>,
    addrlen: socklen_t,
) -> StarryResult<sockaddr_nl> {
    // Linux `netlink_bind`/`netlink_connect` reject only `addrlen < sizeof(sockaddr_nl)`;
    // a larger length is accepted and the trailing bytes ignored. Callers commonly zero a
    // `sockaddr_storage` and pass its full size, so requiring an exact match wrongly
    // returned EINVAL for legitimate binds/connects. Read just the leading sockaddr_nl.
    if (addrlen as usize) < size_of::<sockaddr_nl>() {
        return Err(StarryError::InvalidInput);
    }
    // SAFETY: sockaddr_nl is an integer-only C ABI record. Every copied bit
    // pattern is valid; the family and semantic fields are checked below.
    let addr_nl = unsafe { addr.cast::<sockaddr_nl>().read_abi(current)? };
    if addr_nl.nl_family as u32 != AF_NETLINK {
        return Err(StarryError::from(Errno::EAFNOSUPPORT));
    }
    Ok(addr_nl)
}

pub fn write_netlink_addr(
    current: &crate::task::UserTaskRef,
    addr_nl: &sockaddr_nl,
    addr: UserPtr<sockaddr>,
    addrlen: &mut socklen_t,
) -> crate::StarryResult<()> {
    fill_addr(current, addr, addrlen, unsafe { cast_to_slice(addr_nl) })
}

impl SocketAddrExt for SocketAddr {
    fn read_from_user(
        current: &crate::task::UserTaskRef,
        addr: UserConstPtr<sockaddr>,
        addrlen: socklen_t,
    ) -> crate::StarryResult<Self> {
        match read_family(current, addr, addrlen)? as u32 {
            AF_INET => SocketAddrV4::read_from_user(current, addr, addrlen).map(Self::V4),
            AF_INET6 => SocketAddrV6::read_from_user(current, addr, addrlen).map(Self::V6),
            _ => Err(crate::StarryError::from(crate::Errno::EAFNOSUPPORT)),
        }
    }

    fn write_to_user(
        &self,
        current: &crate::task::UserTaskRef,
        addr: UserPtr<sockaddr>,
        addrlen: &mut socklen_t,
    ) -> crate::StarryResult<()> {
        match self {
            SocketAddr::V4(v4) => v4.write_to_user(current, addr, addrlen),
            SocketAddr::V6(v6) => v6.write_to_user(current, addr, addrlen),
        }
    }

    fn family(&self) -> u16 {
        match self {
            SocketAddr::V4(v4) => v4.family(),
            SocketAddr::V6(v6) => v6.family(),
        }
    }
}

impl SocketAddrExt for SocketAddrV4 {
    fn read_from_user(
        current: &crate::task::UserTaskRef,
        addr: UserConstPtr<sockaddr>,
        addrlen: socklen_t,
    ) -> crate::StarryResult<Self> {
        if addrlen < size_of::<sockaddr_in>() as socklen_t {
            return Err(StarryError::InvalidInput);
        }
        // SAFETY: sockaddr_in contains only integer and byte-array fields.
        // Family and address semantics are validated after the copy.
        let addr_in = unsafe { addr.cast::<sockaddr_in>().read_abi(current)? };
        if addr_in.sin_family as u32 != AF_INET {
            return Err(StarryError::from(Errno::EAFNOSUPPORT));
        }

        Ok(SocketAddrV4::new(
            Ipv4Addr::from_bits(u32::from_be(addr_in.sin_addr.s_addr)),
            u16::from_be(addr_in.sin_port),
        ))
    }

    fn write_to_user(
        &self,
        current: &crate::task::UserTaskRef,
        addr: UserPtr<sockaddr>,
        addrlen: &mut socklen_t,
    ) -> crate::StarryResult<()> {
        let sockin_addr = sockaddr_in {
            sin_family: AF_INET as _,
            sin_port: self.port().to_be(),
            sin_addr: in_addr {
                s_addr: u32::from_ne_bytes(self.ip().octets()),
            },
            __pad: [0_u8; 8],
        };
        fill_addr(current, addr, addrlen, unsafe {
            cast_to_slice(&sockin_addr)
        })
    }

    fn family(&self) -> u16 {
        AF_INET as u16
    }
}

impl SocketAddrExt for SocketAddrV6 {
    fn read_from_user(
        current: &crate::task::UserTaskRef,
        addr: UserConstPtr<sockaddr>,
        addrlen: socklen_t,
    ) -> crate::StarryResult<Self> {
        if addrlen < size_of::<sockaddr_in6>() as socklen_t {
            return Err(StarryError::InvalidInput);
        }
        // SAFETY: sockaddr_in6 contains only integer and byte-array fields.
        // Family and address semantics are validated after the copy.
        let addr_in6 = unsafe { addr.cast::<sockaddr_in6>().read_abi(current)? };
        if addr_in6.sin6_family as u32 != AF_INET6 {
            return Err(StarryError::from(Errno::EAFNOSUPPORT));
        }

        Ok(SocketAddrV6::new(
            Ipv6Addr::from(unsafe { addr_in6.sin6_addr.in6_u.u6_addr8 }),
            u16::from_be(addr_in6.sin6_port),
            u32::from_be(addr_in6.sin6_flowinfo),
            addr_in6.sin6_scope_id,
        ))
    }

    fn write_to_user(
        &self,
        current: &crate::task::UserTaskRef,
        addr: UserPtr<sockaddr>,
        addrlen: &mut socklen_t,
    ) -> crate::StarryResult<()> {
        let sockin_addr = sockaddr_in6 {
            sin6_family: AF_INET6 as _,
            sin6_port: self.port().to_be(),
            sin6_flowinfo: self.flowinfo().to_be(),
            sin6_addr: in6_addr {
                in6_u: linux_raw_sys::net::in6_addr__bindgen_ty_1 {
                    u6_addr8: self.ip().octets(),
                },
            },
            sin6_scope_id: self.scope_id(),
        };
        fill_addr(current, addr, addrlen, unsafe {
            cast_to_slice(&sockin_addr)
        })
    }

    fn family(&self) -> u16 {
        AF_INET6 as u16
    }
}

impl SocketAddrExt for UnixSocketAddr {
    fn read_from_user(
        current: &crate::task::UserTaskRef,
        addr: UserConstPtr<sockaddr>,
        addrlen: socklen_t,
    ) -> crate::StarryResult<Self> {
        if read_family(current, addr, addrlen)? as u32 != AF_UNIX {
            return Err(crate::StarryError::from(crate::Errno::EAFNOSUPPORT));
        }
        let offset = size_of::<__kernel_sa_family_t>();
        let ptr = UserConstPtr::<u8>::from(addr.address().as_usize() + offset);
        let data = ptr.read_slice(current, addrlen as usize - offset)?;
        Ok(if data.is_empty() {
            Self::Unnamed
        } else if data[0] == 0 {
            Self::Abstract(data[1..].into())
        } else {
            let end = data.iter().position(|&c| c == 0).unwrap_or(data.len());
            Self::Path(
                str::from_utf8(&data[..end])
                    .map_err(|_| StarryError::InvalidInput)?
                    .into(),
            )
        })
    }

    fn write_to_user(
        &self,
        current: &crate::task::UserTaskRef,
        addr: UserPtr<sockaddr>,
        addrlen: &mut socklen_t,
    ) -> crate::StarryResult<()> {
        let data_len = match self {
            UnixSocketAddr::Unnamed => 0,
            UnixSocketAddr::Abstract(name) => name.len() + 1,
            UnixSocketAddr::Path(path) => 1 + path.len(),
        };
        let mut buf = Vec::with_capacity(size_of::<__kernel_sa_family_t>() + data_len);
        // sun_family is sa_family_t (2 bytes). `AF_UNIX` from linux_raw_sys is a
        // u32; writing it raw would emit a 4-byte family, over-reporting addrlen
        // by 2 and shifting sun_path against the 2-byte offset the read path uses.
        buf.extend_from_slice(&(AF_UNIX as __kernel_sa_family_t).to_ne_bytes());
        match self {
            UnixSocketAddr::Unnamed => {}
            UnixSocketAddr::Abstract(name) => {
                buf.push(0);
                buf.extend_from_slice(name);
            }
            UnixSocketAddr::Path(path) => {
                buf.extend_from_slice(path.as_bytes());
                buf.push(0);
            }
        }

        fill_addr(current, addr, addrlen, &buf)
    }

    fn family(&self) -> u16 {
        AF_UNIX as u16
    }
}

// This type should be provided by linux_raw_sys but it's missing.
// See https://github.com/sunfishcode/linux-raw-sys/issues/169
#[cfg(feature = "vsock")]
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone, AnyBitPattern)]
pub struct sockaddr_vm {
    pub svm_family: __kernel_sa_family_t,
    pub svm_reserved1: u16,
    pub svm_port: u32,
    pub svm_cid: u32,
    pub svm_zero: [u8; 4],
}

#[cfg(feature = "vsock")]
impl SocketAddrExt for VsockAddr {
    fn read_from_user(
        current: &crate::task::UserTaskRef,
        addr: UserConstPtr<sockaddr>,
        addrlen: socklen_t,
    ) -> crate::StarryResult<Self> {
        if addrlen != size_of::<sockaddr_vm>() as socklen_t {
            return Err(StarryError::InvalidInput);
        }

        let addr_vsock = addr.cast::<sockaddr_vm>().read(current)?;
        if addr_vsock.svm_family as u32 != AF_VSOCK {
            return Err(StarryError::from(Errno::EAFNOSUPPORT));
        }
        Ok(VsockAddr {
            cid: addr_vsock.svm_cid as _,
            port: addr_vsock.svm_port,
        })
    }

    fn write_to_user(
        &self,
        current: &crate::task::UserTaskRef,
        addr: UserPtr<sockaddr>,
        addrlen: &mut socklen_t,
    ) -> crate::StarryResult<()> {
        let sockvm_addr = sockaddr_vm {
            svm_family: AF_VSOCK as _,
            svm_reserved1: 0,
            svm_port: self.port,
            svm_cid: self.cid as _,
            svm_zero: [0_u8; 4],
        };
        fill_addr(current, addr, addrlen, unsafe {
            cast_to_slice(&sockvm_addr)
        })
    }

    fn family(&self) -> u16 {
        AF_VSOCK as u16
    }
}

impl SocketAddrExt for SocketAddrEx {
    fn read_from_user(
        current: &crate::task::UserTaskRef,
        addr: UserConstPtr<sockaddr>,
        addrlen: socklen_t,
    ) -> crate::StarryResult<Self> {
        match read_family(current, addr, addrlen)? as u32 {
            AF_INET | AF_INET6 => SocketAddr::read_from_user(current, addr, addrlen).map(Self::Ip),
            AF_UNIX => UnixSocketAddr::read_from_user(current, addr, addrlen).map(Self::Unix),
            #[cfg(feature = "vsock")]
            AF_VSOCK => VsockAddr::read_from_user(current, addr, addrlen).map(Self::Vsock),
            _ => Err(crate::StarryError::from(crate::Errno::EAFNOSUPPORT)),
        }
    }

    fn write_to_user(
        &self,
        current: &crate::task::UserTaskRef,
        addr: UserPtr<sockaddr>,
        addrlen: &mut socklen_t,
    ) -> crate::StarryResult<()> {
        match self {
            SocketAddrEx::Ip(ip_addr) => ip_addr.write_to_user(current, addr, addrlen),
            SocketAddrEx::Unix(unix_addr) => unix_addr.write_to_user(current, addr, addrlen),
            #[cfg(feature = "vsock")]
            SocketAddrEx::Vsock(vsock_addr) => vsock_addr.write_to_user(current, addr, addrlen),
        }
    }

    fn family(&self) -> u16 {
        match self {
            SocketAddrEx::Ip(ip) => ip.family(),
            SocketAddrEx::Unix(unix) => unix.family(),
            #[cfg(feature = "vsock")]
            SocketAddrEx::Vsock(vsock) => vsock.family(),
        }
    }
}

#[cfg(all(test, not(axtest)))]
fn net_addr_conversion_rules_hold_for_test() -> bool {
    use core::net::{Ipv4Addr, SocketAddrV4};

    // Test socket_addr_v4_to_mapped_v6 conversion
    let v4 = SocketAddrV4::new(Ipv4Addr::new(192, 168, 1, 1), 8080);
    let v6 = socket_addr_v4_to_mapped_v6(&v4);

    // Check port preservation
    assert!(v6.port() == 8080);

    // Test localhost mapping
    let localhost_v4 = SocketAddrV4::new(Ipv4Addr::LOCALHOST, 80);
    let localhost_v6 = socket_addr_v4_to_mapped_v6(&localhost_v4);
    assert!(localhost_v6.port() == 80);

    true
}

#[cfg(all(test, not(axtest)))]
mod tests {
    #[test]
    fn net_addr_conversion_rules_hold() {
        assert!(super::net_addr_conversion_rules_hold_for_test());
    }
}