feat: add pcap

__network/pcap/build.rs

@@ -0,0 +1,122 @@
+use std::env;
+use std::ffi::CStr;
+use std::os::raw::c_char;
+
+#[derive(PartialEq, Eq, PartialOrd, Ord)]
+struct Version {
+    major: usize,
+    minor: usize,
+    micro: usize,
+}
+
+impl Version {
+    fn new(major: usize, minor: usize, micro: usize) -> Version {
+        Version {
+            major,
+            minor,
+            micro,
+        }
+    }
+
+    fn parse(s: &str) -> Result<Version, Box<dyn std::error::Error>> {
+        let err = format!("invalid pcap lib version: {}", s);
+
+        let re = regex::Regex::new(r"([[:digit:]]+)\.([[:digit:]]+)\.([[:digit:]]+)")?;
+        let captures = re.captures(s).ok_or_else(|| err.clone())?;
+
+        let major_str = captures.get(1).ok_or_else(|| err.clone())?.as_str();
+        let minor_str = captures.get(2).ok_or_else(|| err.clone())?.as_str();
+        let micro_str = captures.get(3).ok_or_else(|| err.clone())?.as_str();
+
+        Ok(Version::new(
+            major_str.parse::<usize>()?,
+            minor_str.parse::<usize>()?,
+            micro_str.parse::<usize>()?,
+        ))
+    }
+}
+
+fn get_pcap_lib_version() -> Result<Version, Box<dyn std::error::Error>> {
+    if let Ok(libver) = env::var("LIBPCAP_VER") {
+        return Version::parse(&libver);
+    }
+
+    #[cfg(all(unix, not(target_os = "macos")))]
+    let libfile = "libpcap.so";
+    #[cfg(target_os = "macos")]
+    let libfile = "libpcap.dylib";
+    #[cfg(windows)]
+    let libfile = "wpcap.dll";
+
+    let lib = libloading::Library::new(libfile)?;
+
+    type PcapLibVersion = unsafe extern "C" fn() -> *mut c_char;
+    let pcap_lib_version = unsafe { lib.get::<PcapLibVersion>(b"pcap_lib_version")? };
+
+    let c_buf: *const c_char = unsafe { pcap_lib_version() };
+    let c_str: &CStr = unsafe { CStr::from_ptr(c_buf) };
+    let v_str: &str = c_str.to_str()?;
+
+    let err = format!("cannot infer pcap lib version from: {}", v_str);
+
+    #[cfg(not(windows))]
+    {
+        let re = regex::Regex::new(r"libpcap version ([[:digit:]]+)\.([[:digit:]]+)\.([[:digit:]]+)")?;
+        let captures = re.captures(v_str).ok_or_else(|| err.clone())?;
+
+        let major_str = captures.get(1).ok_or_else(|| err.clone())?.as_str();
+        let minor_str = captures.get(2).ok_or_else(|| err.clone())?.as_str();
+        let micro_str = captures.get(3).ok_or_else(|| err.clone())?.as_str();
+
+        Ok(Version::new(
+            major_str.parse::<usize>()?,
+            minor_str.parse::<usize>()?,
+            micro_str.parse::<usize>()?,
+        ))
+    }
+
+    #[cfg(windows)]
+    {
+        let re = regex::Regex::new(r"based on libpcap version ([[:digit:]]+)\.([[:digit:]]+)")?;
+        let captures = re.captures(v_str).ok_or(err.clone())?;
+
+        let major_str = captures.get(1).ok_or(err.clone())?.as_str();
+        let minor_str = captures.get(2).ok_or(err.clone())?.as_str();
+
+        Ok(Version::new(
+            major_str.parse::<usize>()?,
+            minor_str.parse::<usize>()?,
+            0,
+        ))
+    }
+}
+
+fn emit_cfg_flags(version: Version) {
+    assert!(
+        version >= Version::new(1, 0, 0),
+        "required pcap lib version: >=1.0.0"
+    );
+    let api_vers: Vec<Version> = vec![
+        Version::new(1, 2, 1),
+        Version::new(1, 5, 0),
+        Version::new(1, 7, 2),
+        Version::new(1, 9, 0),
+        Version::new(1, 9, 1),
+    ];
+
+    for v in api_vers.iter().filter(|&v| v <= &version) {
+        println!("cargo:rustc-cfg=libpcap_{}_{}_{}", v.major, v.minor, v.micro);
+    }
+}
+
+fn main() {
+    println!("cargo:rerun-if-env-changed=LIBPCAP_LIBDIR");
+    println!("cargo:rerun-if-env-changed=LIBPCAP_VER");
+
+    if let Ok(libdir) = env::var("LIBPCAP_LIBDIR") {
+        println!("cargo:rustc-link-search=native={}", libdir);
+    }
+
+    let version = get_pcap_lib_version().unwrap();
+    emit_cfg_flags(version);
+}