refactor(linux): Move environment variable access to wrapper functions

Author: Kishi85

src/platform/common.h

@@ -632,6 +632,14 @@ namespace platf {
 
   void restart();
 
+  /**
+   * @brief Get an environment variable.
+   * @param name The name of the environment variable.
+   * @param value Reference to write the env variable value into.
+   * @return true if parameter value was updated to the environment variable, false if the value didn't exist
+   */
+  bool get_env(const std::string &name, std::string &value);
+
   /**
    * @brief Set an environment variable.
    * @param name The name of the environment variable.
@@ -640,6 +648,29 @@ namespace platf {
    */
   int set_env(const std::string &name, const std::string &value);
 
+  /**
+   * @brief Append string to an environment variable if it does not already contain it.
+   * @param name The name of the environment variable.
+   * @param value The value to set the environment variable to.
+   * @param separator Optional separator for the new value if it is not the first one (default: "")
+   * @return 0 on success, non-zero on failure.
+   */
+  inline int append_env(const std::string &name, const std::string &value, const std::string &separator = "") {
+    // This function is platform-independent and just uses other plaf:: functions so we can implement it inline
+    std::string old_value;
+    get_env(name, old_value);
+    if (old_value.contains(value)) {
+      // Value is already part of the string. Return success.
+      return 0;
+    }
+    if (old_value.empty()) {
+      // Environment variable does not exist or is empty. Just set it.
+      return set_env(name, value);
+    }
+    // Append to previous non-empty value with separator
+    return set_env(name, old_value + separator + value);
+  }
+
   /**
    * @brief Unset an environment variable.
    * @param name The name of the environment variable.

src/platform/linux/input/inputtino_seat.cpp

@@ -7,16 +7,14 @@
 
 // local includes
 #include "inputtino_seat.h"
+#include "src/platform/common.h"
 
 namespace platf::inputtino_seat {
 
   std::string get_target_seat() {
-    if (const char *seat = std::getenv("XDG_SEAT")) {
-      if (seat[0] != '\0') {
-        return seat;
-      }
+    if (std::string seat; platf::get_env("XDG_SEAT", seat) && !seat.empty()) {
+      return seat;
     }
-
     return {};
   }
 

src/platform/linux/kwingrab.cpp

@@ -50,7 +50,8 @@ namespace kwin {
   class screencast_permission_helper_t {
   public:
     static bool is_permission_system_deactivated() {
-      return getenvstr("KWIN_WAYLAND_NO_PERMISSION_CHECKS") == "1";
+      std::string v;
+      return platf::get_env("KWIN_WAYLAND_NO_PERMISSION_CHECKS", v) && v == "1";
     }
 
     static void setup() {
@@ -147,17 +148,9 @@ namespace kwin {
     static inline bool initialized = false;
     static inline bool create_file = true;
 
-    static std::string getenvstr(std::string const &key) {
-      char const *val = std::getenv(key.c_str());
-      if (!val) {
-        return "";
-      }
-      return val;
-    }
-
     static std::filesystem::path get_home_dir() {
       // Check HOME environment variable
-      if (std::string homedir = getenvstr("HOME"); !homedir.empty()) {
+      if (std::string homedir; platf::get_env("HOME", homedir) && !homedir.empty()) {
         return homedir;
       }
       // Fall back to home directory from NSS passwd
@@ -169,7 +162,7 @@ namespace kwin {
       // Follow the XDG base directory specification for user data home:
       // https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
       std::filesystem::path xdg_data_home;
-      if (std::string dir = getenvstr("XDG_DATA_HOME"); !dir.empty()) {
+      if (std::string dir; platf::get_env("XDG_DATA_HOME", dir) && !dir.empty()) {
         xdg_data_home = std::filesystem::path(dir);
       } else {
         const auto homedir = get_home_dir();
@@ -209,7 +202,7 @@ namespace kwin {
     static bool check_kwin_system_permissions(const std::string_view &filenameprefix, const std::string_view &executablepath) {
       // Find data dirs to check from XDG_DATA_DIRS
       std::vector<std::string> xdg_data_dirs;
-      if (const std::string e = getenvstr("XDG_DATA_DIRS"); !e.empty()) {
+      if (std::string e; platf::get_env("XDG_DATA_DIRS", e) && !e.empty()) {
         std::stringstream ss(e);
         std::string item;
 
@@ -303,13 +296,13 @@ namespace kwin {
         screencast_permission_helper_t::setup();
       }
 
-      const char *wl_name = std::getenv("WAYLAND_DISPLAY");
-      if (!wl_name) {
+      std::string wl_name;
+      if (!platf::get_env("WAYLAND_DISPLAY", wl_name)) {
         BOOST_LOG(error) << "[kwingrab] WAYLAND_DISPLAY not set"sv;
         return -1;
       }
 
-      wl_display = wl_display_connect(wl_name);
+      wl_display = wl_display_connect(wl_name.c_str());
       if (!wl_display) {
         BOOST_LOG(error) << "[kwingrab] cannot connect to Wayland display: "sv << wl_name;
         return -1;

src/platform/linux/misc.cpp

@@ -145,24 +145,22 @@ namespace platf {
     std::call_once(migration_flag, []() {
       bool found = false;
       bool migrate_config = true;
-      const char *dir;
-      const char *homedir;
-      const char *migrate_envvar;
+      std::string homedir;  // NOSONAR(cpp:S6010) - For get_env this needs to be a std::string reference
 
       // Get the home directory
-      if ((homedir = getenv("HOME")) == nullptr || strlen(homedir) == 0) {
+      if (!get_env("HOME", homedir) || homedir.empty()) {
         // If HOME is empty or not set, use the current user's home directory
         homedir = getpwuid(geteuid())->pw_dir;
       }
 
       // May be set if running under a systemd service with the ConfigurationDirectory= option set.
-      if ((dir = getenv("CONFIGURATION_DIRECTORY")) != nullptr && strlen(dir) > 0) {
+      if (std::string dir; get_env("CONFIGURATION_DIRECTORY", dir) && !dir.empty()) {
         found = true;
         config_path = fs::path(dir) / "sunshine"sv;
       }
       // Otherwise, follow the XDG base directory specification:
       // https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
-      if (!found && (dir = getenv("XDG_CONFIG_HOME")) != nullptr && strlen(dir) > 0) {
+      if (std::string dir; !found && get_env("XDG_CONFIG_HOME", dir) && !dir.empty()) {
         found = true;
         config_path = fs::path(dir) / "sunshine"sv;
       }
@@ -173,8 +171,7 @@ namespace platf {
       }
 
       // migrate from the old config location if necessary
-      migrate_envvar = getenv("SUNSHINE_MIGRATE_CONFIG");
-      if (migrate_config && found && migrate_envvar && strcmp(migrate_envvar, "1") == 0) {
+      if (std::string migrate_envvar; migrate_config && found && get_env("SUNSHINE_MIGRATE_CONFIG", migrate_envvar) && (migrate_envvar == "1")) {
         std::error_code ec;
         fs::path old_config_path = fs::path(homedir) / ".config/sunshine"sv;
         if (old_config_path != config_path && fs::exists(old_config_path, ec)) {
@@ -322,7 +319,9 @@ namespace platf {
    */
   void open_url(const std::string &url) {
     // set working dir to user home directory
-    auto working_dir = boost::filesystem::path(std::getenv("HOME"));
+    std::string homedir;
+    get_env("HOME", homedir);
+    auto working_dir = boost::filesystem::path(homedir);
     std::string cmd = R"(xdg-open ")" + url + R"(")";
 
     boost::process::v1::environment _env = boost::this_process::environment();
@@ -445,24 +444,19 @@ namespace platf {
     lifetime::exit_sunshine(0, true);
   }
 
-  std::string get_env(const std::string &name) {
-    if (const auto value = getenv(name.c_str()); value != nullptr) {
-      return value;
+  bool get_env(const std::string &name, std::string &value) {
+    const auto value_ = getenv(name.c_str());  // NOSONAR(cpp:S1874) - _dupenv_s is only available on WIN32
+    if (value_ == nullptr) {
+      return false;
     }
-    return "";
+    value = std::string(value_);
+    return true;
   }
 
   int set_env(const std::string &name, const std::string &value) {
     return setenv(name.c_str(), value.c_str(), 1);
   }
 
-  int append_env(const std::string &name, const std::string &value, const std::string &separator) {
-    if (const std::string old_value = get_env(name); !old_value.contains(value)) {
-      return set_env(name, old_value.empty() ? value : old_value + separator + value);
-    }
-    return 0;
-  }
-
   int unset_env(const std::string &name) {
     return unsetenv(name.c_str());
   }
@@ -1152,13 +1146,13 @@ namespace platf {
 
     window_system = window_system_e::NONE;
 #ifdef SUNSHINE_BUILD_WAYLAND
-    if (std::getenv("WAYLAND_DISPLAY")) {
+    if (std::string v; get_env("WAYLAND_DISPLAY", v)) {
       window_system = window_system_e::WAYLAND;
     }
 #endif
 #if defined(SUNSHINE_BUILD_X11) || defined(SUNSHINE_BUILD_CUDA)
-    if (std::getenv("DISPLAY") && window_system != window_system_e::WAYLAND) {
-      if (std::getenv("WAYLAND_DISPLAY")) {
+    if (std::string v; get_env("DISPLAY", v) && window_system != window_system_e::WAYLAND) {
+      if (get_env("WAYLAND_DISPLAY", v)) {
         BOOST_LOG(warning) << "Wayland detected, yet sunshine will use X11 for screencasting, screencasting will only work on XWayland applications"sv;
       }
 

src/platform/linux/wayland.cpp

@@ -50,7 +50,9 @@ namespace wl {
 
   int display_t::init(const char *display_name) {
     if (!display_name) {
-      display_name = std::getenv("WAYLAND_DISPLAY");
+      if (std::string v; platf::get_env("WAYLAND_DISPLAY", v)) {
+        display_name = v.c_str();
+      }
     }
 
     if (!display_name) {

src/platform/linux/wayland.h

@@ -175,7 +175,7 @@ namespace wl {
   public:
     /**
      * @brief Initialize display.
-     * If display_name == nullptr -> display_name = std::getenv("WAYLAND_DISPLAY")
+     * If display_name == nullptr -> Set display_name to value of environment variable "WAYLAND_DISPLAY"
      * @param display_name The name of the display.
      * @return 0 on success, -1 on failure.
      */