refactor(certgen): drop dead native logging code

Remove orphaned native logging that nothing reached:

- The /sdcard/Download zip dump (NativeCertGen.dump and the dumpLogs
  JNI, dump_logs_inner, dump.rs, pub mod dump), superseded by the
  diag.sh export.
- The verbose-marker helpers (sysfs.rs, pub mod sysfs); the manual
  .verbose toggle still works via mod.rs::init's inline check.

Drop the now-unused direct deps zip and libc and the orphaned jstring
import. cargo ndk build is warning-clean.

native-certgen/src/lib.rs

@@ -9,7 +9,7 @@ pub mod certbuilder;
 pub mod logging;
 
 use jni::objects::{JByteArray, JClass, JIntArray, JObject, JString};
-use jni::sys::{jboolean, jbyteArray, jstring};
+use jni::sys::{jboolean, jbyteArray};
 use jni::JNIEnv;
 
 use crate::error::{CertGenError, Result};
@@ -140,44 +140,6 @@ fn init_logging_inner(env: &mut JNIEnv, verbose: jboolean, log_dir: &JString) ->
     Ok(())
 }
 
-// ---------------------------------------------------------------------------
-// JNI entry: dumpLogs
-// ---------------------------------------------------------------------------
-
-#[no_mangle]
-pub extern "system" fn Java_org_matrix_TEESimulator_pki_NativeCertGen_dumpLogs(
-    mut env: JNIEnv,
-    _class: JClass,
-) -> jstring {
-    let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-        dump_logs_inner(&mut env)
-    }));
-
-    match result {
-        Ok(Ok(raw)) => raw,
-        Ok(Err(e)) => {
-            tracing::error!(%e, "dumpLogs failed");
-            std::ptr::null_mut()
-        }
-        Err(_) => {
-            tracing::error!("dumpLogs panicked");
-            std::ptr::null_mut()
-        }
-    }
-}
-
-fn dump_logs_inner(env: &mut JNIEnv) -> Result<jstring> {
-    logging::dump::execute_dump()
-        .map_err(|e| CertGenError::Jni(format!("dump failed: {e}")))?;
-
-    // Read the dump path written by execute_dump
-    let path = std::fs::read_to_string("/data/adb/tricky_store/.dump_path")
-        .map_err(|e| CertGenError::Jni(format!("read dump path: {e}")))?;
-
-    let jpath = env.new_string(&path)?;
-    Ok(jpath.into_raw())
-}
-
 // ---------------------------------------------------------------------------
 // Config extraction from Java CertGenConfig object
 // ---------------------------------------------------------------------------

native-certgen/src/logging/dump.rs

@@ -1,208 +0,0 @@
-use std::fs::{self, File};
-use std::io::{Read, Write};
-use std::path::Path;
-use std::process::Command;
-use std::time::{SystemTime, UNIX_EPOCH};
-
-const DUMP_DIR: &str = "/sdcard/Download";
-const LOCK_PATH: &str = "/data/adb/tricky_store/.dump_lock";
-const DUMP_PATH_FILE: &str = "/data/adb/tricky_store/.dump_path";
-const LOG_DIR: &str = "/data/adb/tricky_store/logs";
-const BASE_DIR: &str = "/data/adb/tricky_store";
-const LOGCAT_SIZE_LIMIT: usize = 2 * 1024 * 1024;
-
-struct FlockGuard {
-    _file: File,
-}
-
-impl FlockGuard {
-    fn acquire() -> Result<Self, Box<dyn std::error::Error>> {
-        if let Some(parent) = Path::new(LOCK_PATH).parent() {
-            fs::create_dir_all(parent)?;
-        }
-        let file = File::create(LOCK_PATH)?;
-        let fd = {
-            use std::os::unix::io::AsRawFd;
-            file.as_raw_fd()
-        };
-        let ret = unsafe { libc::flock(fd, libc::LOCK_EX | libc::LOCK_NB) };
-        if ret != 0 {
-            return Err("dump already in progress".into());
-        }
-        Ok(Self { _file: file })
-    }
-}
-
-impl Drop for FlockGuard {
-    fn drop(&mut self) {
-        // flock released automatically when file descriptor closes
-    }
-}
-
-fn random_name(len: usize) -> String {
-    use rand::Rng;
-    let mut rng = rand::thread_rng();
-    (0..len)
-        .map(|_| {
-            let idx = rng.gen_range(0..36u8);
-            if idx < 10 {
-                (b'0' + idx) as char
-            } else {
-                (b'a' + idx - 10) as char
-            }
-        })
-        .collect()
-}
-
-fn collect_logcat(tag: &str) -> Vec<u8> {
-    let output = Command::new("logcat")
-        .args(["-d", "-s", tag])
-        .output();
-
-    match output {
-        Ok(o) => {
-            let mut data = o.stdout;
-            data.truncate(LOGCAT_SIZE_LIMIT);
-            data
-        }
-        Err(_) => Vec::new(),
-    }
-}
-
-fn collect_device_info() -> String {
-    let mut info = String::new();
-
-    if let Ok(output) = Command::new("uname").arg("-a").output() {
-        info.push_str(&format!(
-            "uname={}\n",
-            String::from_utf8_lossy(&output.stdout).trim()
-        ));
-    }
-
-    for (key, prop) in [
-        ("device", "ro.product.device"),
-        ("build", "ro.build.display.id"),
-        ("android", "ro.build.version.release"),
-    ] {
-        if let Ok(output) = Command::new("getprop").arg(prop).output() {
-            info.push_str(&format!(
-                "{}={}\n",
-                key,
-                String::from_utf8_lossy(&output.stdout).trim()
-            ));
-        }
-    }
-
-    // KSU version
-    if let Ok(ver) = fs::read_to_string("/data/adb/ksu/version") {
-        info.push_str(&format!("ksu={}\n", ver.trim()));
-    }
-
-    // Module version from module.prop
-    if let Ok(prop) = fs::read_to_string("/data/adb/modules/tricky_store/module.prop") {
-        for line in prop.lines() {
-            if let Some(ver) = line.strip_prefix("version=") {
-                info.push_str(&format!("module={}\n", ver.trim()));
-                break;
-            }
-        }
-    }
-
-    info
-}
-
-fn read_file_bytes(path: &str) -> Option<Vec<u8>> {
-    let mut buf = Vec::new();
-    File::open(path).ok()?.read_to_end(&mut buf).ok()?;
-    Some(buf)
-}
-
-fn epoch_millis() -> u64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map(|d| d.as_millis() as u64)
-        .unwrap_or(0)
-}
-
-pub fn execute_dump() -> Result<(), Box<dyn std::error::Error>> {
-    let _lock = FlockGuard::acquire()?;
-
-    let _ = fs::create_dir_all(DUMP_DIR);
-    let zip_name = format!("{}.zip", random_name(8));
-    let zip_path = format!("{}/{}", DUMP_DIR, zip_name);
-
-    let zip_file = File::create(&zip_path)?;
-    let mut zip = zip::ZipWriter::new(zip_file);
-    let options =
-        zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Deflated);
-
-    let mut file_count = 0u32;
-
-    // Log files
-    let log_files = [
-        "certgen.log",
-        "certgen.log.1",
-        "certgen.log.2",
-        "certgen.log.3",
-        "certgen.log.4",
-    ];
-    for name in &log_files {
-        let path = format!("{}/{}", LOG_DIR, name);
-        if let Some(data) = read_file_bytes(&path) {
-            zip.start_file(*name, options)?;
-            zip.write_all(&data)?;
-            file_count += 1;
-        }
-    }
-
-    // Logcat
-    let logcat = collect_logcat("TEESimulator");
-    if !logcat.is_empty() {
-        zip.start_file("logcat-teesimulator.log", options)?;
-        zip.write_all(&logcat)?;
-        file_count += 1;
-    }
-
-    // Config files
-    for name in ["tee_status.txt", "security_patch.txt"] {
-        let path = format!("{}/{}", BASE_DIR, name);
-        if let Some(data) = read_file_bytes(&path) {
-            zip.start_file(name, options)?;
-            zip.write_all(&data)?;
-            file_count += 1;
-        }
-    }
-
-    // Device info
-    let device_info = collect_device_info();
-    if !device_info.is_empty() {
-        zip.start_file("device-info.txt", options)?;
-        zip.write_all(device_info.as_bytes())?;
-        file_count += 1;
-    }
-
-    // Manifest
-    let manifest = serde_json::json!({
-        "timestamp": epoch_millis(),
-        "version": env!("CARGO_PKG_VERSION"),
-        "files": file_count,
-    });
-    zip.start_file("manifest.json", options)?;
-    zip.write_all(manifest.to_string().as_bytes())?;
-
-    zip.finish()?;
-
-    let zip_size = fs::metadata(&zip_path).map(|m| m.len()).unwrap_or(0);
-    fs::write(DUMP_PATH_FILE, &zip_path)?;
-
-    let result = serde_json::json!({
-        "zip": zip_path,
-        "size": zip_size,
-        "files": file_count + 1, // +1 for manifest
-    });
-    println!("{}", result);
-
-    tracing::info!(path = %zip_path, size = zip_size, "diagnostic dump created");
-
-    Ok(())
-}

native-certgen/src/logging/mod.rs

@@ -1,7 +1,5 @@
 mod kmsg;
 mod rotating;
-pub mod sysfs;
-pub mod dump;
 
 use std::path::Path;
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};

native-certgen/src/logging/sysfs.rs

@@ -1,38 +0,0 @@
-use std::fs;
-use std::path::Path;
-
-const VERBOSE_MARKER: &str = "/data/adb/tricky_store/.verbose";
-
-pub fn is_verbose() -> bool {
-    Path::new(VERBOSE_MARKER).exists()
-}
-
-pub fn set_verbose_marker(enabled: bool) -> Result<(), Box<dyn std::error::Error>> {
-    if enabled {
-        if let Some(parent) = Path::new(VERBOSE_MARKER).parent() {
-            fs::create_dir_all(parent)?;
-        }
-        fs::write(VERBOSE_MARKER, "")?;
-    } else if Path::new(VERBOSE_MARKER).exists() {
-        fs::remove_file(VERBOSE_MARKER)?;
-    }
-    Ok(())
-}
-
-pub fn enable() -> Result<(), Box<dyn std::error::Error>> {
-    set_verbose_marker(true)?;
-    tracing::info!("verbose logging enabled via marker file");
-    Ok(())
-}
-
-pub fn disable() -> Result<(), Box<dyn std::error::Error>> {
-    set_verbose_marker(false)?;
-    tracing::info!("verbose logging disabled, marker file removed");
-    Ok(())
-}
-
-pub fn status() -> Result<(), Box<dyn std::error::Error>> {
-    let state = if is_verbose() { "enabled" } else { "disabled" };
-    tracing::info!(verbose = state, "verbose marker status");
-    Ok(())
-}