remove codeconv usage

PAM/ssh/include/rublon/check_application.hpp

@@ -182,7 +182,7 @@ class CheckApplication {
         status.updateAppVersion(RUBLON_VERSION_STRING);
         status.updateSystemVersion(details::osName(&mr));
         status.updateSSHDConfig();
-        status.updateRublonConfig();
+        // status.updateRublonConfig();
 
         if(status.updated()) {
             auto & alloc = status.data().GetAllocator();

PAM/ssh/include/rublon/configuration.hpp

@@ -33,7 +33,7 @@ class Configuration {
     std::pmr::string apiServer{memoryResource};
 
     int prompt{};
-    bool enablePasswdEmail{};
+    bool enablePasswdEmail{}; // obsolete
     bool logging{};
     bool autopushPrompt{};
     FailMode failMode{};
@@ -86,6 +86,8 @@ class ConfigurationReader {
     tl::expected< bool, ConfigurationError > applyTo(Configuration & config) const {
         using string = std::pmr::string;
 
+        auto logRequiredFieldNotAvailable = [](auto fieldname) { log(LogLevel::Error, "%s field is not set", fieldname); };
+
         // Helper lambdas for conversion
         auto getStringOpt = [&](const string & key) -> std::optional< std::pmr::string > {
             auto it = keyValues.find(key);
@@ -215,20 +217,26 @@ class ConfigurationReader {
         //      * configuration value is empty -> RequiredValueEmpty
 
         // Reading required fields
-        if(auto val = getStringReq("systemToken"); not val.has_value())
+        if(auto val = getStringReq("systemToken"); not val.has_value()) {
+            logRequiredFieldNotAvailable("systemToken");
             return tl::unexpected{val.error()};
-        else
+        } else {
             config.systemToken = std::move(val.value());
+        }
 
-        if(auto val = getStringReq("secretKey"); not val.has_value())
+        if(auto val = getStringReq("secretKey"); not val.has_value()) {
+            logRequiredFieldNotAvailable("secretKey");
             return tl::unexpected{val.error()};
-        else
+        } else {
             config.secretKey = std::move(val.value());
+        }
 
-        if(auto val = getStringReq("rublonApiServer"); not val.has_value())
+        if(auto val = getStringReq("rublonApiServer"); not val.has_value()) {
+            logRequiredFieldNotAvailable("rublonApiServer");
             return tl::unexpected{val.error()};
-        else
+        } else {
             config.apiServer = std::move(val.value());
+        }
 
         // optional configuration options
         config.prompt             = getInt("prompt").value_or(1);
@@ -243,9 +251,9 @@ class ConfigurationReader {
         config.proxyType    = getStringOpt("proxyType");
         config.proxyServer  = getStringOpt("proxyServer");
 
-        
         // Apply fallback if no config is set
-        if (config.proxyEnabled && (!config.proxyType || config.proxyType->empty()) && (!config.proxyServer || config.proxyServer->empty())) {
+        if(config.proxyEnabled && (!config.proxyType || config.proxyType->empty()) &&
+          (!config.proxyServer || config.proxyServer->empty())) {
             log(LogLevel::Info, "Proxy is enabled but no configuration for it is provided, trying to read from env");
             if(const char * https_proxy = std::getenv("https_proxy"); https_proxy && *https_proxy) {
                 if(parseProxyURL(https_proxy)) {

PAM/ssh/include/rublon/utils.hpp

@@ -1,17 +1,20 @@
 #pragma once
 
-#include <charconv>
+#include <tl/expected.hpp>
+#include <cstdint>
+#include <limits>
 #include <optional>
+#include <string>
+#include <utility>
+
 #include <rublon/memory.hpp>
 #include <rublon/static_string.hpp>
 #include <rublon/stdlib.hpp>
 
 #include <fcntl.h>
-#include <string>
 #include <sys/stat.h>
 #include <syslog.h>
 #include <unistd.h>
-#include <utility>
 
 #include <security/pam_appl.h>
 #include <security/pam_modules.h>
@@ -152,21 +155,31 @@ namespace conv {
     }
 
     inline std::optional< std::uint32_t > to_uint32opt(std::string_view userinput) noexcept {
-        int out;
-        const std::from_chars_result result = std::from_chars(userinput.data(), userinput.data() + userinput.size(), out);
-        if(result.ec == std::errc::invalid_argument || result.ec == std::errc::result_out_of_range) {
+        constexpr auto max = std::numeric_limits< uint32_t >::digits10 + 1;
+        if(userinput.empty() || userinput.size() >= max)
+            return std::nullopt; // Avoid large or empty inputs
+        
+        char buffer[max]={0};
+        std::memcpy(buffer, userinput.data(), userinput.size());
+        buffer[userinput.size()] = '\0'; // Ensure null termination
+
+        char * endptr = nullptr;
+        errno         = 0;
+
+        long result = std::strtol(buffer, &endptr, 10);
+
+        if(errno == ERANGE || endptr != buffer + userinput.size() || result < 0 || result > std::numeric_limits<uint32_t>::max()) {
             return std::nullopt;
         }
-        return out;
+
+        return static_cast< std::uint32_t >(result);
     }
 
     inline tl::expected< std::uint32_t, Error > to_uint32(std::string_view userinput) noexcept {
-        int out;
-        const std::from_chars_result result = std::from_chars(userinput.data(), userinput.data() + userinput.size(), out);
-        if(result.ec == std::errc::invalid_argument || result.ec == std::errc::result_out_of_range) {
-            return tl::make_unexpected(Error::NotANumber);
-        }
-        return out;
+        auto val = to_uint32opt(userinput);
+        if(val)
+            return *val;
+        return tl::unexpected{Error::NotANumber};
     }
 } // namespace conv
 
@@ -252,7 +265,6 @@ namespace details {
         line.reserve(100);
 
         while(std::getline(file, line)) {
-
             if(!line.length())
                 continue;
 
@@ -299,7 +311,8 @@ constexpr std::array< Out, sizeof...(Types) > make_array(Types... names) {
     return {std::forward< Types >(names)...};
 }
 
-template <typename T> std::size_t size_buffer(const T &item) {
+template < typename T >
+std::size_t size_buffer(const T & item) {
     using U = std::decay_t< T >;
     if constexpr(std::is_same_v< U, const char * >) {
         return strlen(item);
@@ -311,7 +324,8 @@ template <typename T> std::size_t size_buffer(const T &item) {
     return 0;
 }
 
-template <typename T> std::size_t size_buffer(const std::optional<T> &item) {
+template < typename T >
+std::size_t size_buffer(const std::optional< T > & item) {
     if(item.has_value())
         return size_buffer(*item);
     return 0;