Use Box<str> instead of String to promote immutability

Author: oherrala

luomu-libpcap/src/error.rs

@@ -8,37 +8,37 @@ pub enum Error {
     /// Loop terminated by pcap_breakloop (PCAP_ERROR_BREAK).
     Break,
     /// The capture needs to be activated (PCAP_ERROR_NOT_ACTIVATED).
-    NotActivated(String),
+    NotActivated(Box<str>),
     /// Capture handle already activated (PCAP_ERROR_ACTIVATED).
-    AlreadyActivated(String),
+    AlreadyActivated(Box<str>),
     /// The capture source specified when the handle was created doesn't exist
     /// (PCAP_ERROR_NO_SUCH_DEVICE).
-    NoSuchDevice(String),
+    NoSuchDevice(Box<str>),
     /// Monitor mode was specified but the capture source doesn't support
     /// monitor mode (PCAP_ERROR_RFMON_NOTSUP).
-    MonitorModeNotSupported(String),
+    MonitorModeNotSupported(Box<str>),
     /// The operation is supported only in monitor mode (PCAP_ERROR_NOT_RFMON).
     OnlySupportedInMonitorMode,
     /// The process doesn't have permission to open the capture source
     /// (PCAP_ERROR_PERM_DENIED).
-    PermissionDenied(String),
+    PermissionDenied(Box<str>),
     /// The capture source device is not up (PCAP_ERROR_IFACE_NOT_UP).
-    InterfaceNotUp(String),
+    InterfaceNotUp(Box<str>),
     /// This device doesn't support setting the time stamp type
     /// (PCAP_ERROR_CANTSET_TSTAMP_TYPE).
-    TimestampTypeNotSupported(String),
+    TimestampTypeNotSupported(Box<str>),
     /// The process has permission to open the capture source but doesn't have
     /// permission to put it into promiscuous mode
     /// (PCAP_ERROR_PROMISC_PERM_DENIED).
-    PromiscuousPermissionDenied(String),
+    PromiscuousPermissionDenied(Box<str>),
     /// The requested time stamp precision is not supported
     /// (PCAP_ERROR_TSTAMP_PRECISION_NOTSUP).
     TimestampPrecisionNotSupported,
 
     /// Error from `libpcap`
-    PcapError(String),
+    PcapError(Box<str>),
     /// Warning from `libpcap`
-    PcapWarning(String),
+    PcapWarning(Box<str>),
     /// Unknown error code from `libpcap`.
     PcapErrorCode(i32),
 

luomu-libpcap/src/functions.rs

@@ -219,7 +219,7 @@ pub fn pcap_activate(pcap_t: &PcapT) -> Result<()> {
     // positive value on success with warnings, and a negative value on error. A
     // non-zero return value indicates what warning or error condition occurred.
     if ret > 0 {
-        return Err(Error::PcapWarning(status_to_str(ret)?));
+        return Err(Error::PcapWarning(status_to_str(ret)?.into()));
     }
 
     Ok(())
@@ -238,7 +238,7 @@ pub fn get_error(pcap_t: &PcapT) -> Result<Error> {
     tracing::trace!("get_error({:p})", pcap_t.pcap_t);
     let ptr = unsafe { libpcap::pcap_geterr(pcap_t.pcap_t) };
     let cstr = unsafe { CStr::from_ptr(ptr) };
-    let err = cstr.to_str()?.to_owned();
+    let err = cstr.to_str()?.into();
     Ok(Error::PcapError(err))
 }
 
@@ -657,22 +657,21 @@ fn get_interface_flags(val: u32) -> BTreeSet<InterfaceFlag> {
     flags
 }
 
-fn status_to_str(error: libc::c_int) -> Result<String> {
+fn status_to_str<'a>(error: libc::c_int) -> Result<&'a str> {
     tracing::trace!("status_to_str({error})");
     let ptr = unsafe { libpcap::pcap_statustostr(error) };
     let cstr = unsafe { CStr::from_ptr(ptr) };
-    let status = cstr.to_str()?.to_owned();
-    Ok(status)
+    Ok(cstr.to_str()?)
 }
 
 /// Check for `libpcap` error.
 fn check_pcap_error(pcap_t: &PcapT, ret: i32) -> Result<()> {
     if tracing::event_enabled!(tracing::Level::TRACE) {
         let status = match ret {
-            0 => "ok".to_string(),
-            n => status_to_str(n).unwrap_or_default(),
+            0 => "ok",
+            n => status_to_str(n)?,
         };
-        tracing::trace!("check_pcap_error({:p}, {ret}) = {status}", pcap_t.pcap_t,);
+        tracing::trace!("check_pcap_error({:p}, {ret}) = {status}", pcap_t.pcap_t);
     }
 
     match ret {

luomu-libpcap/src/lib.rs

@@ -46,12 +46,12 @@ unsafe impl Send for PcapT {}
 impl PcapT {
     /// get interface name
     ///
-    /// `get_interface` returns the interface name if known or "<unknown>".
-    pub fn get_inteface(&self) -> String {
+    /// `get_interface` returns the interface name if known or "\<unknown\>".
+    pub fn get_inteface(&self) -> Box<str> {
         if let Some(name) = &self.interface {
-            name.to_string()
+            name.clone()
         } else {
-            String::from("<unknown>")
+            "<unknown>".into()
         }
     }
 
@@ -203,9 +203,9 @@ impl Errbuf {
         Ok(cstr.to_str()?)
     }
 
-    /// Return libpcap's error message as String.
-    fn as_string(&self) -> Result<String> {
-        Ok(self.as_str()?.to_string())
+    /// Return libpcap's error message as string.
+    fn as_string(&self) -> Result<Box<str>> {
+        Ok(self.as_str()?.into())
     }
 
     /// Return libcap's error as [Error] type.
@@ -523,11 +523,11 @@ impl PcapIfT {
     }
 
     /// Find capture device which have IP address `ip`.
-    pub fn find_interface_with_ip(&self, ip: &IpAddr) -> Option<String> {
+    pub fn find_interface_with_ip(&self, ip: &IpAddr) -> Option<Box<str>> {
         for interface in self.get_interfaces() {
             if interface.has_address(ip) {
                 tracing::trace!("find_interface_with_ip({ip}) = {interface:?}");
-                return Some(interface.name.into_string());
+                return Some(interface.name.clone());
             }
         }
         None