ksud: add managed_feature

userspace/ksud/src/module.rs

@@ -434,6 +434,24 @@ fn mark_all_modules(flag_file: &str) -> Result<()> {
     Ok(())
 }
 
+/// Read module.prop from the given module path and return as a HashMap
+pub fn read_module_prop(module_path: &Path) -> Result<HashMap<String, String>> {
+    let module_prop = module_path.join("module.prop");
+    ensure!(module_prop.exists(), "module.prop not found in {}", module_path.display());
+
+    let content = std::fs::read(&module_prop)
+        .with_context(|| format!("Failed to read module.prop: {}", module_prop.display()))?;
+
+    let mut prop_map: HashMap<String, String> = HashMap::new();
+    PropertiesIter::new_with_encoding(Cursor::new(content), encoding_rs::UTF_8)
+        .read_into(|k, v| {
+            prop_map.insert(k, v);
+        })
+        .with_context(|| format!("Failed to parse module.prop: {}", module_prop.display()))?;
+
+    Ok(prop_map)
+}
+
 fn _list_modules(path: &str) -> Vec<HashMap<String, String>> {
     // first check enabled modules
     let dir = std::fs::read_dir(path);
@@ -446,22 +464,19 @@ fn _list_modules(path: &str) -> Vec<HashMap<String, String>> {
     for entry in dir.flatten() {
         let path = entry.path();
         info!("path: {}", path.display());
-        let module_prop = path.join("module.prop");
-        if !module_prop.exists() {
+
+        if !path.join("module.prop").exists() {
             continue;
         }
-        let content = std::fs::read(&module_prop);
-        let Ok(content) = content else {
-            warn!("Failed to read file: {}", module_prop.display());
-            continue;
+        let mut module_prop_map = match read_module_prop(&path) {
+            Ok(prop) => prop,
+            Err(e) => {
+                warn!("Failed to read module.prop for {}: {}", path.display(), e);
+                continue;
+            }
         };
-        let mut module_prop_map: HashMap<String, String> = HashMap::new();
-        let encoding = encoding_rs::UTF_8;
-        let result =
-            PropertiesIter::new_with_encoding(Cursor::new(content), encoding).read_into(|k, v| {
-                module_prop_map.insert(k, v);
-            });
 
+        // If id is missing or empty, use directory name as fallback
         let dir_id = entry.file_name().to_string_lossy().to_string();
         module_prop_map.insert("dir_id".to_owned(), dir_id.clone());
 
@@ -483,10 +498,6 @@ fn _list_modules(path: &str) -> Vec<HashMap<String, String>> {
         module_prop_map.insert("web".to_owned(), web.to_string());
         module_prop_map.insert("action".to_owned(), action.to_string());
 
-        if result.is_err() {
-            warn!("Failed to parse module.prop: {}", module_prop.display());
-            continue;
-        }
         modules.push(module_prop_map);
     }
 
@@ -498,3 +509,47 @@ pub fn list_modules() -> Result<()> {
     println!("{}", serde_json::to_string_pretty(&modules)?);
     Ok(())
 }
+
+/// Get all managed features from active modules
+/// Modules can specify ksu_managed_features in their module.prop
+/// Format: ksu_managed_features=feature1,feature2,feature3
+/// Returns: HashMap<ModuleId, Vec<ManagedFeature>>
+pub fn get_managed_features() -> Result<HashMap<String, Vec<String>>> {
+    let mut managed_features_map: HashMap<String, Vec<String>> = HashMap::new();
+
+    foreach_active_module(|module_path| {
+        let prop_map = match read_module_prop(module_path) {
+            Ok(prop) => prop,
+            Err(e) => {
+                warn!("Failed to read module.prop for {}: {}", module_path.display(), e);
+                return Ok(());
+            }
+        };
+
+        if let Some(features_str) = prop_map.get("ksu_managed_features") {
+            let module_id = prop_map
+                .get("id")
+                .map(|s| s.to_string())
+                .unwrap_or_else(|| "unknown".to_string());
+
+            info!("Module {} manages features: {}", module_id, features_str);
+
+            let mut feature_list = Vec::new();
+            for feature in features_str.split(',') {
+                let feature = feature.trim();
+                if !feature.is_empty() {
+                    info!("  - Adding managed feature: {}", feature);
+                    feature_list.push(feature.to_string());
+                }
+            }
+
+            if !feature_list.is_empty() {
+                managed_features_map.insert(module_id, feature_list);
+            }
+        }
+
+        Ok(())
+    })?;
+
+    Ok(managed_features_map)
+}