Throw on invalid file

CHANGELOG.md

@@ -1,7 +1,8 @@
 # NEXT RELEASE
 
 ### Enhancements
-* None.
+* Instead of asserting, an `InvalidDatabase` exception is thrown when a realm file is opened 
+  with an invalid top ref.
 
 ### Fixed
 * <How to hit and notice issue? what was the impact?> ([#????](https://github.com/realm/realm-core/issues/????), since v?.?.?)

src/realm/group.cpp

@@ -285,6 +285,42 @@ void Group::remap_and_update_refs(ref_type new_top_ref, size_t new_file_size)
     update_refs(new_top_ref, old_baseline);
 }
 
+void Group::validate_top_array(const Array& arr, const SlabAlloc& alloc)
+{
+    size_t top_size = arr.size();
+    ref_type top_ref = arr.get_ref();
+
+    switch (top_size) {
+        // These are the valid sizes
+        case 3:
+        case 5:
+        case 7:
+        case 9:
+        case 10: {
+            ref_type table_names_ref = arr.get_as_ref_or_tagged(0).get_as_ref();
+            ref_type tables_ref = arr.get_as_ref_or_tagged(1).get_as_ref();
+            auto logical_file_size = arr.get_as_ref_or_tagged(2).get_as_int();
+
+            // Logical file size must never exceed actual file size.
+            // First two entries must be valid refs pointing inside the file
+            auto file_size = alloc.get_baseline();
+            if (logical_file_size > file_size || table_names_ref == 0 || table_names_ref > logical_file_size ||
+                (table_names_ref & 7) || tables_ref == 0 || tables_ref > logical_file_size || (tables_ref & 7)) {
+                std::string err = "Invalid top array (ref, [0], [1], [2]): " + util::to_string(top_ref) + ", " +
+                                  util::to_string(table_names_ref) + ", " + util::to_string(tables_ref) + ", " +
+                                  util::to_string(logical_file_size);
+                throw InvalidDatabase(err, "");
+            }
+            break;
+        }
+        default: {
+            std::string err =
+                "Invalid top array (ref: " + util::to_string(top_ref) + ", size: " + util::to_string(top_size) + ")";
+            throw InvalidDatabase(err, "");
+            break;
+        }
+    }
+}
 
 void Group::attach(ref_type top_ref, bool create_group_when_missing)
 {
@@ -298,37 +334,9 @@ void Group::attach(ref_type top_ref, bool create_group_when_missing)
 
     if (top_ref != 0) {
         m_top.init_from_ref(top_ref);
-        size_t top_size = m_top.size();
-
-        switch (top_size) {
-            // These are the valid sizes
-            case 3:
-            case 5:
-            case 7:
-            case 9:
-            case 10: {
-                ref_type table_names_ref = m_top.get_as_ref_or_tagged(0).get_as_ref();
-                ref_type tables_ref = m_top.get_as_ref_or_tagged(1).get_as_ref();
-                auto logical_file_size = m_top.get_as_ref_or_tagged(2).get_as_int();
-
-                // Logical file size must never exceed actual file size.
-                REALM_ASSERT_RELEASE_EX(logical_file_size <= m_alloc.get_baseline(), top_ref, logical_file_size);
-                // First two entries must be valid refs pointing inside the file
-                REALM_ASSERT_RELEASE_EX(table_names_ref > 0 && table_names_ref < logical_file_size &&
-                                            (table_names_ref & 7) == 0,
-                                        top_ref, table_names_ref);
-                REALM_ASSERT_RELEASE_EX(tables_ref > 0 && tables_ref < logical_file_size && (tables_ref & 7) == 0,
-                                        top_ref, tables_ref);
-                break;
-            }
-            default:
-                REALM_ASSERT_RELEASE_EX(!"Invalid top array size", top_ref, top_size);
-                break;
-        }
+        validate_top_array(m_top, m_alloc);
         m_table_names.init_from_parent();
         m_tables.init_from_parent();
-        REALM_ASSERT_RELEASE_EX(m_table_names.size() == m_tables.size(), top_ref, m_table_names.size(),
-                                m_tables.size());
     }
     else if (create_group_when_missing) {
         create_empty_group(); // Throws

src/realm/group.hpp

@@ -796,6 +796,7 @@ class Group : private Table::Parent {
     void set_history_schema_version(int version);
     void set_history_parent(Array& history_root) noexcept;
     void prepare_history_parent(Array& history_root, int history_type, int history_schema_version);
+    static void validate_top_array(const Array& arr, const SlabAlloc& alloc);
 
     friend class Table;
     friend class GroupWriter;

src/realm/group_shared.cpp

@@ -1031,10 +1031,24 @@ void SharedGroup::do_open(const std::string& path, bool no_create_file, bool is_
             ref_type top_ref;
             try {
                 top_ref = alloc.attach_file(path, cfg); // Throws
+                if (top_ref) {
+                    Array top{alloc};
+                    top.init_from_ref(top_ref);
+                    Group::validate_top_array(top, alloc);
+                }
             }
-            catch (SlabAlloc::Retry&) {
+            catch (const SlabAlloc::Retry&) {
                 continue;
             }
+            catch (const InvalidDatabase& e) {
+                if (e.get_path().size() == 0) {
+                    std::string msg = e.what();
+                    throw InvalidDatabase(msg, path);
+                }
+                else {
+                    throw e;
+                }
+            }
             // If we fail in any way, we must detach the allocator. Failure to do so
             // will retain memory mappings in the mmap cache shared between allocators.
             // This would allow other SharedGroups to reuse the mappings even in
@@ -1118,8 +1132,7 @@ void SharedGroup::do_open(const std::string& path, bool no_create_file, bool is_
                         break;
                 }
 
-                REALM_ASSERT(stored_hist_schema_version >= 0 &&
-                             stored_hist_schema_version <= openers_hist_schema_version);
+                REALM_ASSERT(stored_hist_schema_version >= 0);
                 if (stored_hist_schema_version > openers_hist_schema_version)
                     throw IncompatibleHistories("Unexpected future history schema version", path);
                 bool need_hist_schema_upgrade =

src/realm/util/file.hpp

@@ -26,6 +26,7 @@
 #include <stdexcept>
 #include <string>
 #include <streambuf>
+#include <iostream>
 
 #ifndef _WIN32
 #include <dirent.h> // POSIX.1-2001
@@ -874,7 +875,6 @@ class File::Streambuf : public std::streambuf {
     void flush();
 };
 
-
 /// Used for any I/O related exception. Note the derived exception
 /// types that are used for various specific types of errors.
 class File::AccessError : public std::runtime_error {
@@ -885,8 +885,17 @@ class File::AccessError : public std::runtime_error {
     /// no associated file system path, or if the file system path is unknown.
     std::string get_path() const;
 
+    const char* what() const noexcept
+    {
+        m_buffer = std::runtime_error::what();
+        if (m_path.size() > 0)
+            m_buffer += (std::string(" Path: ") + m_path);
+        return m_buffer.c_str();
+    }
+
 private:
     std::string m_path;
+    mutable std::string m_buffer;
 };