implement browser detection for Windows OS

It's a bit ugly, because we have to go to the Windows registry
for that and the WinAPI stuff is more C than C++.

Author: striezel

code/browser_detection.cpp

@@ -19,12 +19,160 @@
 */
 
 #include "browser_detection.hpp"
+#ifdef _WIN32
+#include <algorithm>
+#include <windows.h>
+#endif
+
+#ifdef _WIN32
+std::vector<std::string> listSubKeyNames()
+{
+  std::vector<std::string> result;
+  HKEY startMenuInternet;
+  LONG res = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Clients\\StartMenuInternet", 0, KEY_READ, &startMenuInternet);
+  if (res != ERROR_SUCCESS)
+  {
+    // Failed to open key, maybe due to permissions.
+    return {};
+  }
+  for (DWORD idx = 0; ; ++idx)
+  {
+    constexpr DWORD buffer_size = 256;
+    char buffer[buffer_size];
+    DWORD name_length = buffer_size;
+    res = RegEnumKeyExA(startMenuInternet, idx, &buffer[0], &name_length, nullptr, nullptr, nullptr, nullptr);
+    if (res == ERROR_NO_MORE_ITEMS)
+    {
+      // reached last sub key
+      RegCloseKey(startMenuInternet);
+      break;
+    }
+    if (res != ERROR_SUCCESS)
+    {
+      // Failed to query key, maybe due to permissions?
+      RegCloseKey(startMenuInternet);
+      return {};
+    }
+    const DWORD nul_pos = name_length >= buffer_size ? buffer_size - 1 : name_length;
+    buffer[nul_pos] = '\0';
+    result.emplace_back(std::string(buffer));
+  }
+  return result;
+}
+
+std::vector<std::filesystem::path> getBrowserPaths()
+{
+  std::vector<std::filesystem::path> result;
+
+  const auto subKeyNames = listSubKeyNames();
+  for (const auto& subKeyName: subKeyNames)
+  {
+    const auto keyName = "SOFTWARE\\Clients\\StartMenuInternet\\" + subKeyName + "\\shell\\open\\command";
+    HKEY commandKey;
+    LONG res = RegOpenKeyExA(HKEY_LOCAL_MACHINE, keyName.c_str(), 0, KEY_READ, &commandKey);
+    if (res != ERROR_SUCCESS)
+    {
+      // Failed to open command key, maybe due to permissions.
+      continue;
+    }
+    constexpr DWORD value_buffer_size = 1024;
+    unsigned char value_buffer[value_buffer_size];
+    DWORD valueType = 0;
+    DWORD valueSize = value_buffer_size - 1;
+    res = RegQueryValueExA(commandKey, "", nullptr, &valueType, value_buffer, &valueSize);
+    if (res != ERROR_SUCCESS)
+    {
+      // Failed to query key, maybe due to permissions?
+      RegCloseKey(commandKey);
+      continue;
+    }
+    if (valueType != REG_SZ)
+    {
+      // Wrong value type, only strings allowed.
+      RegCloseKey(commandKey);
+      continue;
+    }
+    if ((valueSize == 0) || (valueSize >= value_buffer_size))
+    {
+      // Invalid size.
+      RegCloseKey(commandKey);
+      continue;
+    }
+    // Value may or may not be NUL-terminated, so ensure the NUL byte is there.
+    if (value_buffer[valueSize - 1] != 0)
+    {
+      value_buffer[valueSize] = 0;
+    }
+    auto potential_path = std::string(reinterpret_cast<char*>(value_buffer));
+    RegCloseKey(commandKey);
+    const auto size = potential_path.size();
+    if ((potential_path[0] == '"') && (potential_path[size-1] == '"'))
+    {
+      potential_path.erase(size - 1, 1).erase(0, 1);
+    }
+    std::error_code error;
+    std::filesystem::path path(potential_path);
+    if (std::filesystem::is_regular_file(path, error) && !error)
+    {
+      result.push_back(path);
+    }
+  } // for
+
+  return result;
+}
+
+std::optional<Browser> getBrowserType(const std::filesystem::path& path)
+{
+  const auto basename = path.filename().string();
+  if ((basename == "firefox.exe") || (basename == "librewolf.exe"))
+  {
+    return Browser::Firefox;
+  }
+  if (basename == "chrome.exe")
+  {
+    return Browser::Chromium;
+  }
+  if (basename == "seamonkey.exe")
+  {
+    return Browser::SeaMonkey;
+  }
+  if (basename == "msedge.exe")
+  {
+    return Browser::Edge;
+  }
+
+  // Unknown browser type.
+  return std::nullopt;
+}
+#endif // _WIN32
 
 std::optional<BrowserInformation> detect_browser()
 {
   #ifdef _WIN32
-  // TODO: Not implemented yet.
-  return std::optional<BrowserInformation>();
+  const auto paths = getBrowserPaths();
+  std::vector <BrowserInformation> browsers;
+  for (const auto& path: paths)
+  {
+    const auto type = getBrowserType(path);
+    if (!type.has_value())
+    {
+      continue;
+    }
+    browsers.push_back({path, type.value()});
+  } // for
+
+  if (browsers.empty())
+  {
+    return std::nullopt;
+  }
+
+  // Sort to make sure we have stuff like Edge only as last resort.
+  std::stable_sort(browsers.begin(), browsers.end(),
+                   [](const BrowserInformation& left, const BrowserInformation& right) {
+                        return left.type < right.type;
+                   });
+
+  return browsers.at(0);
   #else
   // On Linux systems the paths are usually similar, depending on how the
   // browser was packaged. So it's easiest to just test some known paths.
@@ -58,6 +206,10 @@ std::vector<std::string> additional_parameters(const Browser type)
          return { "--private-window" };
     case Browser::Chromium:
          return { "--incognito" };
+    case Browser::SeaMonkey:
+         return { "-private" };
+    case Browser::Edge:
+         return { "--inprivate" };
     default:
          return {};
   }

code/browser_detection.hpp

@@ -33,7 +33,13 @@ enum class Browser
   Firefox,
 
   /// Chromium browser
-  Chromium
+  Chromium,
+
+  /// SeaMonkey browser
+  SeaMonkey,
+
+  /// Microsoft Edge
+  Edge
 };
 
 struct BrowserInformation

code/html_generation.cpp

@@ -65,6 +65,14 @@ void openFirstIndexFile(const FolderMap& fm, const std::string& html_dir)
     return;
   }
   // TODO: Open file via Boost Process.
+  std::cout << "Run\n\n\t" << browser.value().path.string();
+  const auto params = additional_parameters(browser.value().type);
+  for (const auto& param: params)
+  {
+    std::cout << " " << param;
+  }
+  std::cout << " " << fullFileName << "\n\n"
+            << "to show the generated HTML output.\n";
 }
 
 int generateHtmlFiles(const MessageDatabase& mdb, const FolderMap& fm, const HTMLOptions htmlOptions)

tests/components/browser_detection.cpp

@@ -26,13 +26,8 @@ TEST_CASE("browser detection")
   SECTION("detect_browser")
   {
     const auto info = detect_browser();
-    #if _WIN32
-    // TODO: Change this as soon as detect_browser() works on Windows, too.
-    REQUIRE_FALSE( info.has_value() );
-    #else
     REQUIRE( info.has_value() );
     REQUIRE_FALSE( info.value().path.empty() );
-    #endif
   }
 
   SECTION("additional parameters")
@@ -50,5 +45,19 @@ TEST_CASE("browser detection")
       REQUIRE( params.size() == 1 );
       REQUIRE( params[0] == "--private-window" );
     }
+
+    SECTION("SeaMonkey")
+    {
+      const auto params = additional_parameters(Browser::SeaMonkey);
+      REQUIRE( params.size() == 1 );
+      REQUIRE( params[0] == "-private" );
+    }
+
+    SECTION("Edge")
+    {
+      const auto params = additional_parameters(Browser::Edge);
+      REQUIRE( params.size() == 1 );
+      REQUIRE( params[0] == "--inprivate" );
+    }
   }
 }