Proper handling of memory maps

Author: gershnik

src/command_line.cpp

@@ -559,15 +559,14 @@ void CommandLine::mergeConfigFile(const std::filesystem::path & path) {
         return;
     }
 
-    void * content = mmap(nullptr, st.st_size, PROT_READ, MAP_PRIVATE, c_fd(file), 0);
-    if (content == MAP_FAILED) {
-        ec = std::error_code(errno, std::system_category());
+    ptl::MemoryMap content(nullptr, st.st_size, PROT_READ, MAP_PRIVATE, file, 0, ec);
+    if (ec) {
         WSDLOG_WARN("Cannot map config file {}, error: {}", path.c_str(), ec.message());
         return;
     }
 
     try {
-        auto cfg = toml::parse(std::string_view((const char *)content, st.st_size), path.string());
+        auto cfg = toml::parse(std::string_view((const char *)content.data(), content.size()), path.string());
 
         for (auto && [key, value] : cfg) {
 

src/config_samba.cpp

@@ -82,14 +82,14 @@ static auto paramsFromSmbConf(const std::filesystem::path & path) -> std::option
     if (ec)
         return {};
 
-    void * bytes = mmap(nullptr, st.st_size, PROT_READ, MAP_PRIVATE, c_fd(file), 0);
-    if (bytes == MAP_FAILED)
+    ptl::MemoryMap bytes(nullptr, st.st_size, PROT_READ, MAP_PRIVATE, c_fd(file), 0, ec);
+    if (ec)
         return {};
 
 
     WSDLOG_TRACE("reading smb.conf");
 
-    std::string_view content((const char *)bytes, st.st_size);
+    std::string_view content((const char *)bytes.data(), bytes.size());
 
     std::regex sectionRe(R"##(\s*\[([^\]]*)\].*)##", std::regex_constants::ECMAScript);
     std::regex entryRe(R"##(\s*([^ \t#;=][^=#;]*)\s*=\s*((?:[^ \t#;][^#;]*)?).*)##", std::regex_constants::ECMAScript);

src/sys_util.h

@@ -204,5 +204,61 @@ class LineReader {
 
 void shell(const ptl::StringRefArray & args, bool suppressStdErr, std::function<void (const ptl::FileDescriptor & fd)> reader);
 
+namespace ptl {
+    class MemoryMap {
+    public:
+        MemoryMap() noexcept = default;
+
+        MemoryMap(void * addr, size_t length, 
+                int prot, int flags,
+                ptl::FileDescriptorLike auto && desc,
+                off_t offset,
+                PTL_ERROR_REF_ARG(err)) requires(PTL_ERROR_REQ(err)) :
+            m_ptr(::mmap(addr, length, prot, flags, c_fd(std::forward<decltype(desc)>(desc)), offset)) 
+        {
+
+            if (m_ptr == MAP_FAILED) {
+                handleError(PTL_ERROR_REF(err), errno, "mmap({}, {}, {}, {}, {}, {}) failed", 
+                            addr, length, prot, flags, c_fd(std::forward<decltype(desc)>(desc)), offset);
+            } else {
+                m_size = length;
+                clearError(PTL_ERROR_REF(err));
+            }
+        }
+        ~MemoryMap() {
+            if (m_ptr != MAP_FAILED)
+                munmap(m_ptr, m_size);
+        }
+        MemoryMap(const MemoryMap &) = delete;
+        
+        MemoryMap(MemoryMap && src) :
+            m_ptr(std::exchange(src.m_ptr, MAP_FAILED)),
+            m_size(std::exchange(src.m_size, 0))
+        {}
+
+        MemoryMap & operator=(MemoryMap src) noexcept {
+            swap(src, *this);
+            return *this;
+        }
+
+        void close() noexcept {
+            *this = MemoryMap();
+        }
+
+        friend void swap(MemoryMap & lhs, MemoryMap & rhs) noexcept {
+            std::swap(lhs.m_ptr, rhs.m_ptr);
+            std::swap(lhs.m_size, rhs.m_size);
+        }
+
+        auto data() const -> void *
+            { return m_ptr; }
+        auto size() const -> size_t
+            { return m_size; }
+    private:
+        void * m_ptr = MAP_FAILED;
+        size_t m_size = 0;
+    };
+
+}
 
 #endif