disable openhd ?

Author: raphaelscholle

inc/sysutil_config.h

@@ -81,6 +81,8 @@ struct SysutilConfig {
   // Generic configuration.
   std::optional<bool> gen_enable_last_known_position;
   std::optional<int> gen_rf_metrics_level;
+  // Service control.
+  std::optional<bool> disable_openhd_service;
 };
 
 // Result of attempting to load the config file.

inc/sysutil_debug.h

@@ -24,6 +24,7 @@
 #ifndef SYSUTIL_DEBUG_H
 #define SYSUTIL_DEBUG_H
 
+#include <optional>
 #include <string>
 
 namespace sysutil {
@@ -40,6 +41,9 @@ std::string build_debug_response();
 bool is_debug_update(const std::string& line);
 // Applies a debug update request and returns a response payload.
 std::string handle_debug_update(const std::string& line);
+// Syncs the OpenHD debug marker and optionally restarts OpenHD services.
+bool apply_openhd_debug_marker(const std::optional<bool>& enabled,
+                               bool restart_services);
 
 }  // namespace sysutil
 

src/openhd_sys_utils.cpp

@@ -392,6 +392,7 @@ int main(int argc, char* argv[]) {
 
     sysutil::init_platform_info();
     sysutil::init_debug_info();
+    gDebug = gDebug || sysutil::debug_enabled();
     sysutil::apply_hostname_if_enabled();
     sysutil::init_wifi_info();
     bool wifi_retry_active = !sysutil::has_openhd_wifibroadcast_cards();

src/sysutil_config.cpp

@@ -138,6 +138,8 @@ ConfigLoadResult load_sysutil_config(SysutilConfig& config) {
       extract_bool_field(content, "gen_enable_last_known_position");
   config.gen_rf_metrics_level =
       extract_int_field(content, "gen_rf_metrics_level");
+  config.disable_openhd_service =
+      extract_bool_field(content, "disable_openhd_service");
   return ConfigLoadResult::Loaded;
 }
 
@@ -237,6 +239,7 @@ bool write_sysutil_config(const SysutilConfig& config) {
   write_bool("gen_enable_last_known_position",
              config.gen_enable_last_known_position);
   write_int("gen_rf_metrics_level", config.gen_rf_metrics_level);
+  write_bool("disable_openhd_service", config.disable_openhd_service);
 
   file << "\n}\n";
   return static_cast<bool>(file);

src/sysutil_debug.cpp

@@ -24,8 +24,10 @@
 #include "sysutil_debug.h"
 
 #include <filesystem>
+#include <fstream>
 #include <optional>
 #include <sstream>
+#include <cstdlib>
 
 #include "sysutil_config.h"
 #include "sysutil_protocol.h"
@@ -36,8 +38,9 @@ namespace {
 // Legacy debug.txt locations that enable debug mode once.
 constexpr const char* kDebugFilePaths[] = {
     "/boot/openhd/debug.txt",
-    "/usr/local/share/openhd/debug.txt",
 };
+// Persistent OpenHD debug marker for log verbosity.
+constexpr const char* kOpenhdDebugMarker = "/usr/local/share/openhd/debug.txt";
 
 // Cached debug state for this process.
 std::optional<bool> g_debug_enabled;
@@ -57,6 +60,39 @@ bool remove_file(const std::string& path) {
   return std::filesystem::remove(path, ec);
 }
 
+bool has_systemctl() {
+  return std::filesystem::exists("/bin/systemctl") ||
+         std::filesystem::exists("/usr/bin/systemctl");
+}
+
+bool run_cmd(const std::string& cmd) {
+  return std::system(cmd.c_str()) == 0;
+}
+
+bool touch_file(const std::string& path) {
+  std::error_code ec;
+  auto parent = std::filesystem::path(path).parent_path();
+  if (!parent.empty()) {
+    std::filesystem::create_directories(parent, ec);
+  }
+  if (ec) {
+    return false;
+  }
+  if (std::filesystem::exists(path, ec)) {
+    return true;
+  }
+  std::ofstream file(path);
+  return static_cast<bool>(file);
+}
+
+void restart_openhd_services_if_needed() {
+  if (!has_systemctl()) {
+    return;
+  }
+  (void)run_cmd("systemctl try-restart openhd.service openhd_rpi.service "
+                "openhd_mod.service openhd-x20.service");
+}
+
 }  // namespace
 
 // Initializes debug state from config and debug.txt triggers.
@@ -73,12 +109,19 @@ void init_debug_info() {
     g_debug_enabled = false;
   }
 
+  bool debug_marker_seen = false;
   for (const auto* path : kDebugFilePaths) {
     if (!file_exists(path)) {
       continue;
     }
-    g_debug_enabled = true;
+    debug_marker_seen = true;
     (void)remove_file(path);
+  }
+  if (file_exists(kOpenhdDebugMarker)) {
+    debug_marker_seen = true;
+  }
+  if (debug_marker_seen) {
+    g_debug_enabled = true;
     SysutilConfig updated_config;
     const auto load_result = load_sysutil_config(updated_config);
     if (load_result != ConfigLoadResult::Error) {
@@ -140,6 +183,8 @@ std::string handle_debug_update(const std::string& line) {
   const bool ok = write_sysutil_config(config);
   if (ok) {
     g_debug_enabled = *requested;
+    (void)apply_openhd_debug_marker(requested,
+                                    !config.disable_openhd_service.value_or(false));
   }
 
   std::ostringstream out;
@@ -149,4 +194,23 @@ std::string handle_debug_update(const std::string& line) {
   return out.str();
 }
 
+bool apply_openhd_debug_marker(const std::optional<bool>& enabled,
+                               bool restart_services) {
+  if (!enabled.has_value()) {
+    return true;
+  }
+  const bool want_debug = *enabled;
+  bool ok = true;
+  if (want_debug) {
+    ok = touch_file(kOpenhdDebugMarker);
+  } else {
+    ok = remove_file(kOpenhdDebugMarker);
+  }
+  g_debug_enabled = want_debug;
+  if (restart_services) {
+    restart_openhd_services_if_needed();
+  }
+  return ok;
+}
+
 }  // namespace sysutil

src/sysutil_settings.cpp

@@ -34,6 +34,7 @@
 
 #include "sysutil_camera.h"
 #include "sysutil_config.h"
+#include "sysutil_debug.h"
 #include "sysutil_hostname.h"
 #include "sysutil_protocol.h"
 #include "sysutil_status.h"
@@ -175,6 +176,23 @@ void sync_settings_from_files() {
         }
       }
 
+      if (auto disable_openhd =
+              extract_bool_field(content, "disable_openhd_service");
+          disable_openhd.has_value()) {
+        config.disable_openhd_service = *disable_openhd;
+        changed = true;
+      }
+      if (auto debug = extract_bool_field(content, "debug");
+          debug.has_value()) {
+        config.debug_enabled = *debug;
+        changed = true;
+      } else if (auto debug_enabled =
+                     extract_bool_field(content, "debug_enabled");
+                 debug_enabled.has_value()) {
+        config.debug_enabled = *debug_enabled;
+        changed = true;
+      }
+
       // sbc field is currently ignored as platform detection handles it.
     }
     remove_file_if_exists(json_path.c_str());
@@ -283,6 +301,8 @@ std::string build_settings_response() {
   const bool gen_enable_last_known_position =
       config.gen_enable_last_known_position.value_or(false);
   const int gen_rf_metrics_level = config.gen_rf_metrics_level.value_or(0);
+  const bool disable_openhd_service =
+      config.disable_openhd_service.value_or(false);
 
   std::ostringstream out;
   out << "{\"type\":\"sysutil.settings.response\",\"ok\":true"
@@ -328,7 +348,9 @@ std::string build_settings_response() {
       << ",\"microhard_telemetry_port\":" << microhard_telemetry_port
       << ",\"gen_enable_last_known_position\":"
       << (gen_enable_last_known_position ? "true" : "false")
-      << ",\"gen_rf_metrics_level\":" << gen_rf_metrics_level << "}\n";
+      << ",\"gen_rf_metrics_level\":" << gen_rf_metrics_level
+      << ",\"disable_openhd_service\":"
+      << (disable_openhd_service ? "true" : "false") << "}\n";
   return out.str();
 }
 
@@ -341,6 +363,7 @@ std::string handle_settings_update(const std::string& line) {
 
   bool changed = false;
   bool hostname_related_change = false;
+  bool debug_changed = false;
   if (auto reset_requested = extract_bool_field(line, "reset_requested");
       reset_requested.has_value()) {
     config.reset_requested = *reset_requested;
@@ -513,11 +536,33 @@ std::string handle_settings_update(const std::string& line) {
     config.gen_rf_metrics_level = *gen_rf_metrics_level;
     changed = true;
   }
+  if (auto disable_openhd_service =
+          extract_bool_field(line, "disable_openhd_service");
+      disable_openhd_service.has_value()) {
+    config.disable_openhd_service = *disable_openhd_service;
+    changed = true;
+  }
+  if (auto debug = extract_bool_field(line, "debug"); debug.has_value()) {
+    config.debug_enabled = *debug;
+    changed = true;
+    debug_changed = true;
+  } else if (auto debug_enabled =
+                 extract_bool_field(line, "debug_enabled");
+             debug_enabled.has_value()) {
+    config.debug_enabled = *debug_enabled;
+    changed = true;
+    debug_changed = true;
+  }
 
   bool ok = true;
   if (changed) {
     ok = write_sysutil_config(config);
   }
+  if (ok && debug_changed) {
+    const bool restart_openhd =
+        !config.disable_openhd_service.value_or(false);
+    (void)apply_openhd_debug_marker(config.debug_enabled, restart_openhd);
+  }
   if (ok && hostname_related_change) {
     apply_hostname_if_enabled();
   }

src/sysutil_video.cpp

@@ -23,6 +23,7 @@
 
 #include "sysutil_video.h"
 #include "sysutil_config.h"
+#include "sysutil_debug.h"
 #include "sysutil_platform.h"
 #include "sysutil_protocol.h"
 #include "sysutil_status.h"
@@ -137,6 +138,18 @@ bool has_systemctl() {
            std::filesystem::exists("/usr/bin/systemctl");
 }
 
+void apply_openhd_service_disable() {
+    if (!has_systemctl()) {
+        set_status("sysutils.services", "Service status",
+                   "systemctl missing; cannot disable OpenHD service", 2);
+        return;
+    }
+    run_cmd("systemctl stop openhd.service openhd_rpi.service openhd_mod.service");
+    run_cmd("systemctl disable openhd.service openhd_rpi.service openhd_mod.service");
+    set_status("sysutils.services", "Service status",
+               "OpenHD service disabled via sysutils config", 1);
+}
+
 bool ensure_qopenhd_getty_dropin() {
     std::error_code ec;
     const std::string dropin_dir = "/etc/systemd/system/qopenhd.service.d";
@@ -391,6 +404,15 @@ void start_openhd_services_if_needed() {
     const bool ground = is_ground_mode();
     const bool rockchip = is_rockchip_platform();
 
+    SysutilConfig config;
+    if (load_sysutil_config(config) == ConfigLoadResult::Loaded) {
+        (void)apply_openhd_debug_marker(config.debug_enabled, false);
+        if (config.disable_openhd_service.value_or(false)) {
+            apply_openhd_service_disable();
+            return;
+        }
+    }
+
     if (!systemd_ok) {
         set_status("sysutils.services", "Service status",
                    "systemctl missing; cannot manage services", 2);