fix(lib/util): use better names for runtime metadata

- document RuntimeMetadata fields
- rename RayhunterMetadata to RuntimeMetadata
- rename RuntimeMetadata.os to RuntimeMetadata.system_os
- remove unpopulated hardware field
- remove unnecessary duplication of datastructure in analyzer harness

lib/src/analysis/analyzer.rs

@@ -3,6 +3,7 @@ use chrono::{DateTime, FixedOffset};
 use serde::Serialize;
 
 use crate::{diag::MessagesContainer, gsmtap_parser};
+use crate::util::RuntimeMetadata;
 
 use super::{
     imsi_requested::ImsiRequestedAnalyzer,
@@ -70,18 +71,10 @@ pub struct AnalyzerMetadata {
     pub description: String,
 }
 
-#[derive(Serialize, Debug)]
-pub struct RayhunterMetadata {
-    pub version: String,
-    pub os: String,
-    pub arch: String,
-    pub hardware: String,
-}
-
 #[derive(Serialize, Debug)]
 pub struct ReportMetadata {
     pub analyzers: Vec<AnalyzerMetadata>,
-    pub rayhunter: RayhunterMetadata,
+    pub rayhunter: RuntimeMetadata,
 }
 
 #[derive(Serialize, Debug, Clone)]
@@ -214,14 +207,7 @@ impl Harness {
             });
         }
 
-        let metadata = crate::util::RayhunterMetadata::new();
-
-        let rayhunter = RayhunterMetadata {
-            version: metadata.version,
-            os: metadata.os,
-            arch: metadata.arch,
-            hardware: metadata.hardware,
-        };
+        let rayhunter = RuntimeMetadata::new();
 
         ReportMetadata {
             analyzers,

lib/src/pcap.rs

@@ -61,8 +61,8 @@ struct UdpHeader {
 
 impl<T> GsmtapPcapWriter<T> where T: AsyncWrite + Unpin + Send {
     pub async fn new(writer: T) -> Result<Self, GsmtapPcapError> {
-        let metadata = crate::util::RayhunterMetadata::new();
-        let package = format!("{} {}", metadata.name, metadata.version);
+        let metadata = crate::util::RuntimeMetadata::new();
+        let package = format!("{} {}", env!("CARGO_PKG_NAME").to_owned(), metadata.rayhunter_version);
         let section = SectionHeaderBlock {
             endianness: Endianness::Big,
             major_version: 1,
@@ -70,7 +70,7 @@ impl<T> GsmtapPcapWriter<T> where T: AsyncWrite + Unpin + Send {
             section_length: -1,
             options: vec![
                 SectionHeaderOption::Hardware(Cow::from(metadata.arch)),
-                SectionHeaderOption::OS(Cow::from(metadata.os)),
+                SectionHeaderOption::OS(Cow::from(metadata.system_os)),
                 SectionHeaderOption::UserApplication(Cow::from(package)),
             ],
         };

lib/src/util.rs

@@ -1,34 +1,36 @@
 use nix::sys::utsname::uname;
+use serde::Serialize;
 
 /// Expose binary and system information.
-pub struct RayhunterMetadata {
-    pub name: String,
-    pub version: String,
-    pub os: String,
+#[derive(Serialize, Debug)]
+pub struct RuntimeMetadata {
+    /// The cargo package version from this library's cargo.toml, e.g., "1.2.3".
+    pub rayhunter_version: String,
+    /// The operating system `sysname` and optionally `release`. e.g., "Linux 3.18.48" or "linux".
+    pub system_os: String,
+    /// The CPU architecture in use. e.g., "armv7l" or "arm".
     pub arch: String,
-    pub hardware: String,
 }
 
-impl RayhunterMetadata {
+impl RuntimeMetadata {
+    /// Return the binary and system information, attempting to retrieve
+    /// attributes from `uname(2)` and falling back to values from
+    /// `std::env::consts`.
     pub fn new() -> Self {
         match uname() {
-            Ok(utsname) => RayhunterMetadata {
-                name: env!("CARGO_PKG_NAME").to_owned(),
-                version: env!("CARGO_PKG_VERSION").to_owned(),
+            Ok(utsname) => RuntimeMetadata {
+                rayhunter_version: env!("CARGO_PKG_VERSION").to_owned(),
                 arch: format!("{}", utsname.machine().to_string_lossy()),
-                os: format!(
+                system_os: format!(
                     "{} {}",
                     utsname.sysname().to_string_lossy(),
                     utsname.release().to_string_lossy(),
                 ),
-                hardware: String::from("unknown"),
             },
-            Err(_) => RayhunterMetadata {
-                name: env!("CARGO_PKG_NAME").to_owned(),
-                version: env!("CARGO_PKG_VERSION").to_owned(),
+            Err(_) => RuntimeMetadata {
+                rayhunter_version: env!("CARGO_PKG_VERSION").to_owned(),
                 arch: std::env::consts::ARCH.to_string(),
-                os: std::env::consts::OS.to_string(),
-                hardware: String::from("unknown"),
+                system_os: std::env::consts::OS.to_string(),
             },
         }
     }