Ticket #3255: t3255_prevent_replay_overwrites_v5.patch

source/ps/Replay.cpp

@@ -28 +28 @@
 #include "ps/Loader.h"
 #include "ps/Mod.h"
 #include "ps/Profile.h"
 #include "ps/ProfileViewer.h"
 #include "ps/Pyrogenesis.h"
+#include "ps/VisualReplay.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "scriptinterface/ScriptStats.h"
 #include "simulation2/Simulation2.h"
 #include "simulation2/helpers/SimulationCommand.h"
 
+#include <ctime>
 #include <sstream>
 #include <fstream>
 #include <iomanip>
 
-#if MSC_VERSION
-#include <process.h>
-#define getpid _getpid // use the non-deprecated function name
-#endif
-
 static std::string Hexify(const std::string& s)
 {
     std::stringstream str;
     str << std::hex;
     for (size_t i = 0; i < s.size(); ++i)
@@ -63 +60 @@
     delete m_Stream;
 }
 
 void CReplayLogger::StartGame(JS::MutableHandleValue attribs)
 {
+    const time_t timestamp = std::time(nullptr);
+
     // Add timestamp, since the file-modification-date can change
-    m_ScriptInterface.SetProperty(attribs, "timestamp", std::to_string(std::time(nullptr)));
+    m_ScriptInterface.SetProperty(attribs, "timestamp", std::to_string(timestamp));
 
     // Add engine version and currently loaded mods for sanity checks when replaying
     m_ScriptInterface.SetProperty(attribs, "engine_version", CStr(engine_version));
     m_ScriptInterface.SetProperty(attribs, "mods", g_modsLoaded);
 
-    // Construct the directory name based on the PID, to be relatively unique.
-    // Append "-1", "-2" etc if we run multiple matches in a single session,
-    // to avoid accidentally overwriting earlier logs.
-    static int run = -1;
+    // Construct directory name (for example 2015-11-02_0012)
+    const struct tm* now = localtime(&timestamp);
+    char directory[256];
+    int i = 0;
     do
     {
-        std::wstringstream name;
-        name << getpid();
-        if (++run)
-            name << "-" << run;
-
-        m_Directory = psLogDir() / L"sim_log" / name.str();
-    } while (DirectoryExists(m_Directory));
+        const CStr directoryFormat = ++i < 10000 ? "%04d-%02d-%02d_%04d" : "%04d-%02d-%02d_%d";
+        sprintf(directory, directoryFormat.c_str(), now->tm_year + 1900, now->tm_mon + 1, now->tm_mday, i);
+        m_Directory = VisualReplay::GetDirectoryName() / CStr(directory);
+    } while (DirectoryExists(m_Directory) || FileExists(m_Directory));
 
+    debug_printf("Writing replay to %s\n", m_Directory.string8().c_str());
     CreateDirectories(m_Directory, 0700);
 
     m_Stream = new std::ofstream(OsString(m_Directory / L"commands.txt").c_str(), std::ofstream::out | std::ofstream::trunc);
     *m_Stream << "start " << m_ScriptInterface.StringifyJSON(attribs, false) << "\n";
 }

source/ps/VisualReplay.cpp

@@ -1 @@
-/* Copyright (C) 2015 Wildfire Games.
+/* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
@@ -25 +25 @@
 #include "network/NetClient.h"
 #include "network/NetServer.h"
 #include "ps/CLogger.h"
 #include "ps/Filesystem.h"
 #include "ps/Game.h"
+#include "ps/GameSetup/Paths.h"
+#include "ps/Mod.h"
 #include "ps/Pyrogenesis.h"
 #include "ps/Replay.h"
 #include "scriptinterface/ScriptInterface.h"
 
 /**
@@ -36 +38 @@
  */
 const u8 minimumReplayDuration = 3;
 
 OsPath VisualReplay::GetDirectoryName()
 {
-    return OsPath(psLogDir() / L"sim_log");
+    const Paths paths(g_args);
+    return OsPath(paths.UserData() / "replays" / engine_version);
 }
 
 void VisualReplay::StartVisualReplay(const CStrW& directory)
 {
     ENSURE(!g_NetServer);

source/simulation2/Simulation2.cpp

@@ -77 +77 @@
         if (CConfigDB::IsInitialised())
         {
             CFG_GET_VAL("ooslog", m_EnableOOSLog);
             CFG_GET_VAL("serializationtest", m_EnableSerializationTest);
         }
+
+        std::stringstream pid;
+        pid << getpid();
+        m_OOSLogPath = psLogDir() / "oos_logs" / pid.str();
+
+        if (m_EnableOOSLog)
+            debug_printf("Writing ooslogs to %s\n", m_OOSLogPath.string8().c_str());
     }
 
     ~CSimulation2Impl()
     {
         UnregisterFileReloadFunc(ReloadChangedFileCB, this);
@@ -130 +137 @@
     std::set<VfsPath> m_LoadedScripts;
 
     uint32_t m_TurnNumber;
 
     bool m_EnableOOSLog;
-
+    OsPath m_OOSLogPath;
 
     // Functions and data for the serialization test mode: (see Update() for relevant comments)
-
     bool m_EnableSerializationTest;
 
     struct SerializationTestState
     {
         std::stringstream state;
@@ -293 +299 @@
 
 void CSimulation2Impl::ReportSerializationFailure(
     SerializationTestState* primaryStateBefore, SerializationTestState* primaryStateAfter,
     SerializationTestState* secondaryStateBefore, SerializationTestState* secondaryStateAfter)
 {
-    OsPath path = psLogDir() / "oos_log";
+    OsPath path = psLogDir() / "serializationtest";
     CreateDirectories(path, 0700);
 
+    debug_printf("Writing serializationtest-data to %s\n", path.string8().c_str());
+
     // Clean up obsolete files from previous runs
     wunlink(path / "hash.before.a");
     wunlink(path / "hash.before.b");
     wunlink(path / "debug.before.a");
     wunlink(path / "debug.before.b");
@@ -547 +555 @@
 
 void CSimulation2Impl::DumpState()
 {
     PROFILE("DumpState");
 
-    std::stringstream pid;
-    pid << getpid();
     std::stringstream name;\
     name << std::setw(5) << std::setfill('0') << m_TurnNumber << ".txt";
-    OsPath path = psLogDir() / "sim_log" / pid.str() / name.str();
+    OsPath path = m_OOSLogPath / name.str();
     CreateDirectories(path.Parent(), 0700);
     std::ofstream file (OsString(path).c_str(), std::ofstream::out | std::ofstream::trunc);
 
     file << "State hash: " << std::hex;
     std::string hashRaw;
@@ -583 +589 @@
 {
     delete m;
 }
 
 // Forward all method calls to the appropriate CSimulation2Impl/CComponentManager methods:
-
 void CSimulation2::EnableOOSLog()
 {
     m->m_EnableOOSLog = true;
+    debug_printf("Writing ooslogs to %s\n", m->m_OOSLogPath.string8().c_str());
 }
 
 void CSimulation2::EnableSerializationTest()
 {
     m->m_EnableSerializationTest = true;