Rework methods

Author: arctic-alpaca

src/backend/libc/net/mod.rs

@@ -8,7 +8,7 @@ pub(crate) mod ext;
     target_os = "wasi"
 )))]
 pub(crate) mod msghdr;
-#[cfg(all(target_os = "linux", feature = "alloc"))]
+#[cfg(target_os = "linux")]
 pub(crate) mod netdevice;
 pub(crate) mod read_sockaddr;
 pub(crate) mod send_recv;

src/backend/libc/net/netdevice.rs

@@ -1,65 +1,55 @@
 #![allow(unsafe_code)]
 
+#[cfg(feature = "alloc")]
 use crate::alloc::string::String;
-use crate::alloc::string::ToString;
 use crate::backend::io::syscalls::ioctl;
 use crate::fd::AsFd;
-use crate::ffi::CStr;
-use crate::ffi::CString;
 use crate::io;
 use crate::net::netdevice::open_socket;
-use core::mem::MaybeUninit;
-use core::ptr::{addr_of, addr_of_mut};
-use libc::{c_char, ifreq, IFNAMSIZ, SIOCGIFINDEX, SIOCGIFNAME};
-
-#[cfg(all(target_os = "linux", feature = "alloc"))]
-pub(crate) fn index_to_name(if_name: &str) -> io::Result<u32> {
-    if if_name.len() >= IFNAMSIZ as usize {
+#[cfg(feature = "alloc")]
+use libc::SIOCGIFNAME;
+use libc::{__c_anonymous_ifr_ifru, ifreq, IFNAMSIZ, SIOCGIFINDEX};
+
+#[cfg(target_os = "linux")]
+pub(crate) fn name_to_index(if_name: &str) -> io::Result<u32> {
+    let if_name_bytes = if_name.as_bytes();
+    if if_name_bytes.len() >= IFNAMSIZ as usize {
         return Err(io::Errno::NODEV);
     }
-    let mut ifrn_name = [0; IFNAMSIZ as usize];
-    let c_string_name = CString::new(if_name).map_err(|_cstr_err| io::Errno::INVAL)?;
-    // Convert from CString to c_char array.
-    c_string_name
-        .as_bytes_with_nul()
-        .iter()
-        .map(|byte| *byte as c_char)
-        .enumerate()
-        .for_each(|(i, c_char_byte)| ifrn_name[i] = c_char_byte);
 
-    let mut uninit_ifreq = MaybeUninit::<ifreq>::uninit();
-    let uninit_ifreq_ptr = uninit_ifreq.as_mut_ptr();
-    unsafe {
-        addr_of_mut!((*uninit_ifreq_ptr).ifr_name).write(ifrn_name);
-    }
+    let mut ifreq = ifreq {
+        ifr_name: [0; 16],
+        ifr_ifru: __c_anonymous_ifr_ifru { ifru_ifindex: 0 },
+    };
+
+    let mut if_name_i8_iter = if_name_bytes.iter().map(|byte| *byte as i8);
+    ifreq.ifr_name[..if_name_bytes.len()].fill_with(|| if_name_i8_iter.next().unwrap());
 
     let fd = open_socket()?;
-    unsafe { ioctl(fd.as_fd(), SIOCGIFINDEX as _, uninit_ifreq_ptr as _) }?;
-    let index = unsafe { *addr_of!((*uninit_ifreq_ptr).ifr_ifru.ifru_ifindex) };
+    unsafe { ioctl(fd.as_fd(), SIOCGIFINDEX, &mut ifreq as *mut ifreq as _) }?;
+    let index = unsafe { ifreq.ifr_ifru.ifru_ifindex };
     Ok(index as u32)
 }
 
 #[cfg(all(target_os = "linux", feature = "alloc"))]
-pub(crate) fn name_to_index(index: u32) -> io::Result<String> {
-    let mut uninit_ifreq = MaybeUninit::<ifreq>::uninit();
-    let uninit_ifreq_ptr = uninit_ifreq.as_mut_ptr();
-    unsafe {
-        addr_of_mut!((*uninit_ifreq_ptr).ifr_ifru.ifru_ifindex).write(index as _);
-    }
+pub(crate) fn index_to_name(index: u32) -> io::Result<String> {
+    let mut ifreq = ifreq {
+        ifr_name: [0; 16],
+        ifr_ifru: __c_anonymous_ifr_ifru {
+            ifru_ifindex: index as _,
+        },
+    };
 
     let fd = open_socket()?;
-    unsafe { ioctl(fd.as_fd(), SIOCGIFNAME as _, uninit_ifreq_ptr as _) }?;
+    unsafe { ioctl(fd.as_fd(), SIOCGIFNAME as _, &mut ifreq as *mut ifreq as _) }?;
 
-    let ifr_name = unsafe { *addr_of!((*uninit_ifreq_ptr).ifr_name) };
-    let mut result_name = [0; IFNAMSIZ as usize];
-    // Convert from c_char array to u8 array.
-    ifr_name
+    let Some(nul_byte) = ifreq.ifr_name.iter().position(|char| *char == 0) else {
+        return Err(io::Errno::INVAL);
+    };
+    let name = ifreq.ifr_name[..nul_byte]
         .iter()
-        .map(|v| *v as u8)
-        .enumerate()
-        .for_each(|(i, u8_byte)| result_name[i] = u8_byte);
-
-    let name = CStr::from_bytes_until_nul(&result_name).map_err(|_cstr_err| io::Errno::INVAL)?;
+        .map(|v| *v as u8 as char)
+        .collect();
 
-    Ok(name.to_string_lossy().to_string())
+    Ok(name)
 }

src/backend/linux_raw/net/mod.rs

@@ -1,6 +1,6 @@
 pub(crate) mod addr;
 pub(crate) mod msghdr;
-#[cfg(all(target_os = "linux", feature = "alloc"))]
+#[cfg(target_os = "linux")]
 pub(crate) mod netdevice;
 pub(crate) mod read_sockaddr;
 pub(crate) mod send_recv;

src/backend/linux_raw/net/netdevice.rs

@@ -1,66 +1,58 @@
 #![allow(unsafe_code)]
 
+#[cfg(feature = "alloc")]
 use crate::alloc::string::String;
-use crate::alloc::string::ToString;
 use crate::backend::io::syscalls::ioctl;
 use crate::fd::AsFd;
-use crate::ffi::CStr;
-use crate::ffi::CString;
 use crate::io;
 use crate::net::netdevice::open_socket;
-use core::mem::MaybeUninit;
-use core::ptr::{addr_of, addr_of_mut};
-use linux_raw_sys::ctypes::c_char;
-use linux_raw_sys::ioctl::{SIOCGIFINDEX, SIOCGIFNAME};
-use linux_raw_sys::net::{ifreq, IFNAMSIZ};
-
-#[cfg(all(target_os = "linux", feature = "alloc"))]
-pub(crate) fn index_to_name(if_name: &str) -> io::Result<u32> {
-    if if_name.len() >= IFNAMSIZ as usize {
+use linux_raw_sys::ioctl::SIOCGIFINDEX;
+#[cfg(feature = "alloc")]
+use linux_raw_sys::ioctl::SIOCGIFNAME;
+use linux_raw_sys::net::{ifreq, ifreq__bindgen_ty_1, ifreq__bindgen_ty_2, IFNAMSIZ};
+
+#[cfg(target_os = "linux")]
+pub(crate) fn name_to_index(if_name: &str) -> io::Result<u32> {
+    let if_name_bytes = if_name.as_bytes();
+    if if_name_bytes.len() >= IFNAMSIZ as usize {
         return Err(io::Errno::NODEV);
     }
-    let mut ifrn_name = [0; IFNAMSIZ as usize];
-    let c_string_name = CString::new(if_name).map_err(|_cstr_err| io::Errno::INVAL)?;
-    // Convert from CString to c_char array.
-    c_string_name
-        .as_bytes_with_nul()
-        .iter()
-        .map(|byte| *byte as c_char)
-        .enumerate()
-        .for_each(|(i, c_char_byte)| ifrn_name[i] = c_char_byte);
 
-    let mut uninit_ifreq = MaybeUninit::<ifreq>::uninit();
-    let uninit_ifreq_ptr = uninit_ifreq.as_mut_ptr();
-    unsafe {
-        addr_of_mut!((*uninit_ifreq_ptr).ifr_ifrn.ifrn_name).write(ifrn_name);
-    }
+    let mut ifreq = ifreq {
+        ifr_ifrn: ifreq__bindgen_ty_1 { ifrn_name: [0; 16] },
+        ifr_ifru: ifreq__bindgen_ty_2 { ifru_ivalue: 0 },
+    };
+    unsafe { ifreq.ifr_ifrn.ifrn_name[..if_name_bytes.len()].copy_from_slice(if_name_bytes) };
 
     let fd = open_socket()?;
-    unsafe { ioctl(fd.as_fd(), SIOCGIFINDEX, uninit_ifreq_ptr as _) }?;
-    let index = unsafe { *addr_of!((*uninit_ifreq_ptr).ifr_ifru.ifru_ivalue) };
+    unsafe { ioctl(fd.as_fd(), SIOCGIFINDEX, &mut ifreq as *mut ifreq as _) }?;
+    let index = unsafe { ifreq.ifr_ifru.ifru_ivalue };
     Ok(index as u32)
 }
 
 #[cfg(all(target_os = "linux", feature = "alloc"))]
-pub(crate) fn name_to_index(index: u32) -> io::Result<String> {
-    let mut uninit_ifreq = MaybeUninit::<ifreq>::uninit();
-    let uninit_ifreq_ptr = uninit_ifreq.as_mut_ptr();
-    unsafe {
-        addr_of_mut!((*uninit_ifreq_ptr).ifr_ifru.ifru_ivalue).write(index as _);
-    }
+pub(crate) fn index_to_name(index: u32) -> io::Result<String> {
+    let mut ifreq = ifreq {
+        ifr_ifrn: ifreq__bindgen_ty_1 { ifrn_name: [0; 16] },
+        ifr_ifru: ifreq__bindgen_ty_2 {
+            ifru_ivalue: index as _,
+        },
+    };
 
     let fd = open_socket()?;
-    unsafe { ioctl(fd.as_fd(), SIOCGIFNAME, uninit_ifreq_ptr as _) }?;
+    unsafe { ioctl(fd.as_fd(), SIOCGIFNAME, &mut ifreq as *mut ifreq as _) }?;
+
+    let Some(nul_byte) = unsafe { ifreq.ifr_ifrn.ifrn_name }
+        .iter()
+        .position(|char| *char == 0)
+    else {
+        return Err(io::Errno::INVAL);
+    };
 
-    let ifrn_name = unsafe { *addr_of!((*uninit_ifreq_ptr).ifr_ifrn.ifrn_name) };
-    let mut result_name = [0; IFNAMSIZ as usize];
-    // Convert from c_char array to u8 array.
-    ifrn_name
+    let name = unsafe { ifreq.ifr_ifrn.ifrn_name }[..nul_byte]
         .iter()
-        .map(|v| *v as u8)
-        .enumerate()
-        .for_each(|(i, u8_byte)| result_name[i] = u8_byte);
+        .map(|v| *v as char)
+        .collect();
 
-    let name = CStr::from_bytes_until_nul(&result_name).map_err(|_cstr_err| io::Errno::INVAL)?;
-    Ok(name.to_string_lossy().to_string())
+    Ok(name)
 }

src/net/mod.rs

@@ -16,8 +16,7 @@ mod types;
 #[cfg(windows)]
 mod wsa;
 
-// Currently limited to feature = "alloc" as it only contains methods requiring alloc at this time.
-#[cfg(all(target_os = "linux", feature = "alloc"))]
+#[cfg(target_os = "linux")]
 pub mod netdevice;
 pub mod sockopt;
 

src/net/netdevice.rs

@@ -5,16 +5,15 @@
 //!
 //! [Linux]: https://man7.org/linux/man-pages/man7/netdevice.7.html
 
+#[cfg(feature = "alloc")]
 use crate::alloc::string::String;
 use crate::fd::OwnedFd;
 use crate::io;
 use crate::io::Errno;
 use crate::net::{socket, AddressFamily, SocketType};
 
 /// Creates a socket used to communicate with the kernel in the ioctl calls.
-// Currently limited to feature = "alloc" as it is only used by methods
-// requiring alloc at this time.
-#[cfg(all(target_os = "linux", feature = "alloc"))]
+#[cfg(target_os = "linux")]
 pub(crate) fn open_socket() -> io::Result<OwnedFd> {
     if let Ok(fd) = socket(AddressFamily::UNIX, SocketType::DGRAM, None) {
         Ok(fd)
@@ -35,9 +34,9 @@ pub(crate) fn open_socket() -> io::Result<OwnedFd> {
 /// [Linux]: https://man7.org/linux/man-pages/man7/netdevice.7.html
 #[inline]
 #[doc(alias = "SIOCGIFINDEX")]
-#[cfg(all(target_os = "linux", feature = "alloc"))]
-pub fn index_to_name(if_name: &str) -> io::Result<u32> {
-    crate::backend::net::netdevice::index_to_name(if_name)
+#[cfg(target_os = "linux")]
+pub fn name_to_index(if_name: &str) -> io::Result<u32> {
+    crate::backend::net::netdevice::name_to_index(if_name)
 }
 
 /// `ioctl(fd, SIOCGIFNAME, ifreq)`—Returns the interface name for a given index.
@@ -49,37 +48,37 @@ pub fn index_to_name(if_name: &str) -> io::Result<u32> {
 #[inline]
 #[doc(alias = "SIOCGIFNAME")]
 #[cfg(all(target_os = "linux", feature = "alloc"))]
-pub fn name_to_index(index: u32) -> io::Result<String> {
-    crate::backend::net::netdevice::name_to_index(index)
+pub fn index_to_name(index: u32) -> io::Result<String> {
+    crate::backend::net::netdevice::index_to_name(index)
 }
 
 #[cfg(test)]
 mod tests {
     use crate::backend::net::netdevice::{index_to_name, name_to_index};
 
     #[test]
-    #[cfg(all(target_os = "linux", feature = "alloc"))]
-    fn test_index_to_name() {
+    #[cfg(target_os = "linux")]
+    fn test_name_to_index() {
         let loopback_index = std::fs::read_to_string("/sys/class/net/lo/ifindex")
             .unwrap()
             .as_str()
             .split_at(1)
             .0
             .parse::<u32>()
             .unwrap();
-        assert_eq!(Ok(loopback_index), index_to_name("lo"));
+        assert_eq!(Ok(loopback_index), name_to_index("lo"));
     }
 
     #[test]
     #[cfg(all(target_os = "linux", feature = "alloc"))]
-    fn test_name_to_index() {
+    fn test_index_to_name() {
         let loopback_index = std::fs::read_to_string("/sys/class/net/lo/ifindex")
             .unwrap()
             .as_str()
             .split_at(1)
             .0
             .parse::<u32>()
             .unwrap();
-        assert_eq!(Ok("lo".to_owned()), name_to_index(loopback_index));
+        assert_eq!(Ok("lo".to_owned()), index_to_name(loopback_index));
     }
 }