huge refactor

.github/workflows/build-test.yml

@@ -29,6 +29,6 @@ jobs:
 
       - name: Build Packages
         run: |
-          for f in fw-extract elf-verify ipk-verify; do
-            cargo deb -p "$f" || exit 1
+          for f in packages/*; do
+            cargo deb -p $(basename "$f") || exit 1
           done

.github/workflows/release.yml

@@ -32,8 +32,8 @@ jobs:
 
       - name: Build Packages
         run: |
-          for f in fw-extract elf-verify ipk-verify; do
-            cargo deb -p "$f" || exit 1
+          for f in packages/*; do
+            cargo deb -p $(basename "$f") || exit 1
           done
 
       - name: Create Release (Ubuntu)

Cargo.toml

@@ -1,7 +1,11 @@
 [workspace]
 members = [
-    "common",
-    "elf-verify",
-    "ipk-verify",
-    "fw-extract"
+    "common/fw",
+    "common/bin",
+    "common/ipk",
+    "common/verify",
+    "packages/elf-verify",
+    "packages/ipk-verify",
+    "packages/fw-extract",
+    "packages/gen-manifest",
 ]

common/Cargo.toml → common/bin/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "common"
+name = "bin-lib"
 version = "0.1.0"
 edition = "2021"
 

common/src/binary.rs → common/bin/src/binary.rs

@@ -1,13 +1,13 @@
+use std::fs::File;
+use std::io::{Error, ErrorKind};
+use std::path::Path;
+
 use elf::dynamic::Dyn;
 use elf::endian::AnyEndian;
 use elf::symbol::Symbol;
 use elf::{abi, ElfStream};
-use std::collections::HashSet;
-use std::fs::File;
-use std::io::{Error, ErrorKind};
-use std::path::Path;
 
-use crate::{BinVerifyResult, BinaryInfo, Firmware, LibraryInfo, VerifyResult, VerifyWithFirmware};
+use crate::{BinaryInfo, LibraryInfo};
 
 impl BinaryInfo {
     pub fn find_library(&self, name: &str) -> Option<LibraryInfo> {
@@ -96,70 +96,6 @@ impl BinaryInfo {
     }
 }
 
-impl VerifyWithFirmware<BinVerifyResult> for BinaryInfo {
-    fn verify(&self, firmware: &Firmware) -> BinVerifyResult {
-        let mut result = BinVerifyResult::new(self.name.clone());
-        result.undefined_sym.extend(self.undefined.clone());
-        let mut visited_libs: HashSet<String> = Default::default();
-
-        let find_library = |name: &str| -> Option<LibraryInfo> {
-            return firmware
-                .find_library(name)
-                .or_else(|| self.find_library(name));
-        };
-
-        fn resolve_symbols<F>(
-            lib: &LibraryInfo,
-            undefined: &mut Vec<String>,
-            visited: &mut HashSet<String>,
-            lib_resolver: &F,
-        ) where
-            F: Fn(&str) -> Option<LibraryInfo>,
-        {
-            undefined.retain(|symbol| !lib.has_symbol(symbol));
-            for needed in &lib.needed {
-                if visited.contains(needed) {
-                    continue;
-                }
-                visited.insert(needed.clone());
-                if let Some(needed) = lib_resolver(needed) {
-                    resolve_symbols(&needed, undefined, visited, lib_resolver);
-                }
-            }
-        }
-
-        for needed in &self.needed {
-            if let Some(lib) = find_library(needed) {
-                resolve_symbols(
-                    &lib,
-                    &mut result.undefined_sym,
-                    &mut visited_libs,
-                    &find_library,
-                );
-            } else {
-                result.missing_lib.push(needed.clone());
-            }
-        }
-        return result;
-    }
-}
-
-impl BinVerifyResult {
-    pub fn new(name: String) -> Self {
-        return Self {
-            name,
-            missing_lib: Default::default(),
-            undefined_sym: Default::default(),
-        };
-    }
-}
-
-impl VerifyResult for BinVerifyResult {
-    fn is_good(&self) -> bool {
-        return self.missing_lib.is_empty() && self.undefined_sym.is_empty();
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use std::io::Cursor;

common/bin/src/lib.rs

@@ -0,0 +1,23 @@
+use serde::{Deserialize, Serialize};
+
+pub mod binary;
+pub mod library;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct BinaryInfo {
+    pub name: String,
+    pub rpath: Vec<String>,
+    pub needed: Vec<String>,
+    pub undefined: Vec<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct LibraryInfo {
+    pub name: String,
+    pub needed: Vec<String>,
+    pub symbols: Vec<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub names: Vec<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub undefined: Vec<String>,
+}