mitigate corrupted caches (#129)

Author: thelink2012

src/plugins/gta3/std.data/cache.hpp

@@ -381,25 +381,30 @@ class data_cache : public modloader::basic_cache
             using stream_type  = typename std::conditional<Output, std::ofstream, std::ifstream>::type;
             using archive_type = typename std::conditional<Output, cereal::BinaryOutputArchive, cereal::BinaryInputArchive>::type;
 
-            stream_type ss;
+            try {
+                stream_type ss;
 
-            std::unique_ptr<char[]> buffer(new char[buffer_size]);
-            ss.rdbuf()->pubsetbuf(buffer.get(), buffer_size);
+                std::unique_ptr<char[]> buffer(new char[buffer_size]);
+                ss.rdbuf()->pubsetbuf(buffer.get(), buffer_size);
 
-            ss.open(filepath, std::ios::binary);
-            if(ss.is_open())
-            {
-                uint32_t version = build_identifier(); // This variable won't change in the case of a output stream,
-                                                                // but will in the case of a input stream, in any case default initialize for the output case
-                archive_type archive(ss);
-                archive(version);
-                if(version == build_identifier())      // Make sure serialization version matches
+                ss.open(filepath, std::ios::binary);
+                if(ss.is_open())
                 {
-                    func(ss, archive);
-                    return true;
+                    uint32_t version = build_identifier(); // This variable won't change in the case of a output stream,
+                                                                    // but will in the case of a input stream, in any case default initialize for the output case
+                    archive_type archive(ss);
+                    archive(version);
+                    if(version == build_identifier())      // Make sure serialization version matches
+                    {
+                        func(ss, archive);
+                        return true;
+                    }
+                    else
+                        plugin_ptr->Log("Warning: Incompatible cache version, a new cache will be generated.");
                 }
-                else
-                    plugin_ptr->Log("Warning: Incompatible cache version, a new cache will be generated.");
+            } catch (const std::exception &e) {
+                // TODO(#131): fix root cause of these exceptions
+                plugin_ptr->Log("Error: Failed to perform cache operation: %s on %s", e.what(), filepath.c_str());
             }
             return false;
         }

src/plugins/gta3/std.data/main.cpp

@@ -638,15 +638,21 @@ auto DataPlugin::ReadCachedReadmeListing() -> readme_listing_type
 {
     readme_listing_type cached_readme_listing;
 
-    std::ifstream ss(cache.GetCachePath("readme.ld"), std::ios::binary);
-    if(ss.is_open())
-    {
-        cereal::BinaryInputArchive archive(ss);
-        if(VerifyCachedReadme(ss, archive))
+    try {
+        std::ifstream ss(cache.GetCachePath("readme.ld"), std::ios::binary);
+        if(ss.is_open())
         {
-            block_reader listing_block(ss);
-            archive(cached_readme_listing);
+            cereal::BinaryInputArchive archive(ss);
+            if(VerifyCachedReadme(ss, archive))
+            {
+                block_reader listing_block(ss);
+                archive(cached_readme_listing);
+            }
         }
+    } catch(const std::exception& e) {
+        // TODO(#131): fix root cause of these exceptions
+        this->Log("Error: Failed to read cached readme listing: %s", e.what());
+        cached_readme_listing.clear();
     }
     return cached_readme_listing;
 }
@@ -659,16 +665,22 @@ auto DataPlugin::ReadCachedReadmeStore() -> readme_data_store
 {
     readme_data_store store_lines;
 
-    std::ifstream ss(cache.GetCachePath("readme.ld"), std::ios::binary);
-    if(ss.is_open())
-    {
-        cereal::BinaryInputArchive archive(ss);
-        if(VerifyCachedReadme(ss, archive))
+    try {
+        std::ifstream ss(cache.GetCachePath("readme.ld"), std::ios::binary);
+        if(ss.is_open())
         {
-            block_reader::skip(ss); // skip listing block
-            block_reader lines_block(ss);
-            archive(store_lines);
+            cereal::BinaryInputArchive archive(ss);
+            if(VerifyCachedReadme(ss, archive))
+            {
+                block_reader::skip(ss); // skip listing block
+                block_reader lines_block(ss);
+                archive(store_lines);
+            }
         }
+    } catch(const std::exception& e) {
+        // TODO(#131): fix root cause of these exceptions
+        this->Log("Error: Failed to read cached readme store: %s", e.what());
+        store_lines.clear();
     }
     return store_lines;
 }