Merge pull request #1556 from comex/project-moration

Rudimentary version of Wii IPC determinism.  Ported from my old udpnet branch.

Source/Core/Common/FileSearch.cpp

@@ -2,101 +2,60 @@
 // Licensed under GPLv2+
 // Refer to the license.txt file included.
 
+#if !__clang__ && __GNUC__ == 4 && __GNUC_MINOR__ < 9
+#error <regex> is broken in GCC < 4.9; please upgrade
+#endif
+
 #include <algorithm>
-#include <cstring>
+#include <functional>
+#include <regex>
 
 #include "Common/CommonPaths.h"
 #include "Common/FileSearch.h"
-#include "Common/StringUtil.h"
+#include "Common/FileUtil.h"
 
-#ifndef _WIN32
-#include <dirent.h>
-#else
-#include <windows.h>
-#endif
-
-
-CFileSearch::CFileSearch(const CFileSearch::XStringVector& _rSearchStrings, const CFileSearch::XStringVector& _rDirectories)
+static std::vector<std::string> FileSearchWithTest(const std::vector<std::string>& directories, bool recursive, std::function<bool(const File::FSTEntry &)> callback)
 {
-	// Reverse the loop order for speed?
-	for (auto& _rSearchString : _rSearchStrings)
+	std::vector<std::string> result;
+	for (const std::string& directory : directories)
 	{
-		for (auto& _rDirectory : _rDirectories)
-		{
-			FindFiles(_rSearchString, _rDirectory);
-		}
+		File::FSTEntry top = File::ScanDirectoryTree(directory, recursive);
+
+		std::function<void(File::FSTEntry&)> DoEntry;
+		DoEntry = [&](File::FSTEntry& entry) {
+			if (callback(entry))
+				result.push_back(entry.physicalName);
+			for (auto& child : entry.children)
+				DoEntry(child);
+		};
+		DoEntry(top);
 	}
+	// remove duplicates
+	std::sort(result.begin(), result.end());
+	result.erase(std::unique(result.begin(), result.end()), result.end());
+	return result;
 }
 
-
-void CFileSearch::FindFiles(const std::string& _searchString, const std::string& _strPath)
+std::vector<std::string> DoFileSearch(const std::vector<std::string>& globs, const std::vector<std::string>& directories, bool recursive)
 {
-	std::string GCMSearchPath;
-	BuildCompleteFilename(GCMSearchPath, _strPath, _searchString);
-#ifdef _WIN32
-	WIN32_FIND_DATA findData;
-	HANDLE FindFirst = FindFirstFile(UTF8ToTStr(GCMSearchPath).c_str(), &findData);
-
-	if (FindFirst != INVALID_HANDLE_VALUE)
+	std::string regex_str = "^(";
+	for (const auto& str : globs)
 	{
-		bool bkeepLooping = true;
-
-		while (bkeepLooping)
-		{
-			if (findData.cFileName[0] != '.')
-			{
-				std::string strFilename;
-				BuildCompleteFilename(strFilename, _strPath, TStrToUTF8(findData.cFileName));
-				m_FileNames.push_back(strFilename);
-			}
-
-			bkeepLooping = FindNextFile(FindFirst, &findData) ? true : false;
-		}
+		if (regex_str.size() != 2)
+			regex_str += "|";
+		// convert glob to regex
+		regex_str += std::regex_replace(std::regex_replace(str, std::regex("\\."), "\\."), std::regex("\\*"), ".*");
 	}
-	FindClose(FindFirst);
-
-
-#else
-	// TODO: super lame/broken
-
-	auto end_match(_searchString);
-
-	// assuming we have a "*.blah"-like pattern
-	if (!end_match.empty() && end_match[0] == '*')
-		end_match.erase(0, 1);
-
-	// ugly
-	if (end_match == ".*")
-		end_match.clear();
-
-	DIR* dir = opendir(_strPath.c_str());
-
-	if (!dir)
-		return;
-
-	while (auto const dp = readdir(dir))
-	{
-		std::string found(dp->d_name);
-
-		if ((found != ".") && (found != "..") &&
-		    (found.size() >= end_match.size()) &&
-		    std::equal(end_match.rbegin(), end_match.rend(), found.rbegin()))
-		{
-			std::string full_name;
-			if (_strPath.c_str()[_strPath.size() - 1] == DIR_SEP_CHR)
-				full_name = _strPath + found;
-			else
-				full_name = _strPath + DIR_SEP + found;
-
-			m_FileNames.push_back(full_name);
-		}
-	}
-
-	closedir(dir);
-#endif
+	regex_str += ")$";
+	std::regex regex(regex_str);
+	return FileSearchWithTest(directories, recursive, [&](const File::FSTEntry& entry) {
+		return std::regex_match(entry.virtualName, regex);
+	});
 }
 
-const CFileSearch::XStringVector& CFileSearch::GetFileNames() const
+std::vector<std::string> FindSubdirectories(const std::vector<std::string>& directories, bool recursive)
 {
-	return m_FileNames;
+	return FileSearchWithTest(directories, true, [&](const File::FSTEntry& entry) {
+		return entry.isDirectory;
+	});
 }

Source/Core/Common/FileSearch.h

@@ -7,18 +7,5 @@
 #include <string>
 #include <vector>
 
-class CFileSearch
-{
-public:
-	typedef std::vector<std::string>XStringVector;
-
-	CFileSearch(const XStringVector& _rSearchStrings, const XStringVector& _rDirectories);
-	const XStringVector& GetFileNames() const;
-
-private:
-
-	void FindFiles(const std::string& _searchString, const std::string& _strPath);
-
-	XStringVector m_FileNames;
-};
-
+std::vector<std::string> DoFileSearch(const std::vector<std::string>& globs, const std::vector<std::string>& directories, bool recursive = false);
+std::vector<std::string> FindSubdirectories(const std::vector<std::string>& directories, bool recursive);

Source/Core/Common/FileUtil.cpp

@@ -20,6 +20,7 @@
 #include <commdlg.h>   // for GetSaveFileName
 #include <direct.h>    // getcwd
 #include <io.h>
+#include <objbase.h>   // guid stuff
 #include <shellapi.h>
 #include <windows.h>
 #else
@@ -453,11 +454,14 @@ bool CreateEmptyFile(const std::string &filename)
 
 // Scans the directory tree gets, starting from _Directory and adds the
 // results into parentEntry. Returns the number of files+directories found
-u32 ScanDirectoryTree(const std::string &directory, FSTEntry& parentEntry)
+FSTEntry ScanDirectoryTree(const std::string &directory, bool recursive)
 {
 	INFO_LOG(COMMON, "ScanDirectoryTree: directory %s", directory.c_str());
 	// How many files + directories we found
-	u32 foundEntries = 0;
+	FSTEntry parent_entry;
+	parent_entry.physicalName = directory;
+	parent_entry.isDirectory = true;
+	parent_entry.size = 0;
 #ifdef _WIN32
 	// Find the first file in the directory.
 	WIN32_FIND_DATA ffd;
@@ -466,59 +470,55 @@ u32 ScanDirectoryTree(const std::string &directory, FSTEntry& parentEntry)
 	if (hFind == INVALID_HANDLE_VALUE)
 	{
 		FindClose(hFind);
-		return foundEntries;
+		return parent_entry;
 	}
 	// Windows loop
 	do
 	{
-		FSTEntry entry;
-		const std::string virtualName(TStrToUTF8(ffd.cFileName));
+		const std::string virtual_name(TStrToUTF8(ffd.cFileName));
 #else
 	struct dirent dirent, *result = nullptr;
 
 	DIR *dirp = opendir(directory.c_str());
 	if (!dirp)
-		return 0;
+			return parent_entry;
 
-	// non Windows loop
-	while (!readdir_r(dirp, &dirent, &result) && result)
-	{
-		FSTEntry entry;
-		const std::string virtualName(result->d_name);
-#endif
-		// check for "." and ".."
-		if (((virtualName[0] == '.') && (virtualName[1] == '\0')) ||
-				((virtualName[0] == '.') && (virtualName[1] == '.') &&
-				 (virtualName[2] == '\0')))
-			continue;
-		entry.virtualName = virtualName;
-		entry.physicalName = directory;
-		entry.physicalName += DIR_SEP + entry.virtualName;
-
-		if (IsDirectory(entry.physicalName))
+		// non Windows loop
+		while (!readdir_r(dirp, &dirent, &result) && result)
 		{
-			entry.isDirectory = true;
-			// is a directory, lets go inside
-			entry.size = ScanDirectoryTree(entry.physicalName, entry);
-			foundEntries += (u32)entry.size;
-		}
-		else
-		{ // is a file
-			entry.isDirectory = false;
-			entry.size = GetSize(entry.physicalName.c_str());
-		}
-		++foundEntries;
-		// Push into the tree
-		parentEntry.children.push_back(entry);
-#ifdef _WIN32
-	} while (FindNextFile(hFind, &ffd) != 0);
+			const std::string virtual_name(result->d_name);
+	#endif
+			if (virtual_name == "." || virtual_name == "..")
+				continue;
+			auto physical_name = directory + DIR_SEP + virtual_name;
+			FSTEntry entry;
+			entry.isDirectory = IsDirectory(physical_name);
+			if (entry.isDirectory)
+			{
+				if (recursive)
+					entry = ScanDirectoryTree(physical_name, true);
+				else
+					entry.size = 0;
+			}
+			else
+			{
+				entry.size = GetSize(physical_name);
+			}
+			entry.virtualName = virtual_name;
+			entry.physicalName = physical_name;
+
+			++parent_entry.size;
+			// Push into the tree
+			parent_entry.children.push_back(entry);
+	#ifdef _WIN32
+		} while (FindNextFile(hFind, &ffd) != 0);
 	FindClose(hFind);
 #else
 	}
 	closedir(dirp);
 #endif
 	// Return number of entries found.
-	return foundEntries;
+	return parent_entry;
 }
 
 
@@ -628,14 +628,11 @@ void CopyDir(const std::string &source_path, const std::string &dest_path)
 		if (virtualName == "." || virtualName == "..")
 			continue;
 
-		std::string source, dest;
-		source = source_path + virtualName;
-		dest = dest_path + virtualName;
+		std::string source = source_path + DIR_SEP + virtualName;
+		std::string dest = dest_path + DIR_SEP + virtualName;
 		if (IsDirectory(source))
 		{
-			source += '/';
-			dest += '/';
-			if (!File::Exists(dest)) File::CreateFullPath(dest);
+			if (!File::Exists(dest)) File::CreateFullPath(dest + DIR_SEP);
 			CopyDir(source, dest);
 		}
 		else if (!File::Exists(dest)) File::Copy(source, dest);
@@ -670,6 +667,32 @@ bool SetCurrentDir(const std::string &directory)
 	return __chdir(directory.c_str()) == 0;
 }
 
+std::string CreateTempDir()
+{
+#ifdef _WIN32
+	TCHAR temp[MAX_PATH];
+	if (!GetTempPath(MAX_PATH, temp))
+		return "";
+
+	GUID guid;
+	CoCreateGuid(&guid);
+	TCHAR tguid[40];
+	StringFromGUID2(guid, tguid, 39);
+	tguid[39] = 0;
+	std::string dir = TStrToUTF8(temp) + "/" + TStrToUTF8(tguid);
+	if (!CreateDir(dir))
+		return "";
+	dir = ReplaceAll(dir, "\\", DIR_SEP);
+	return dir;
+#else
+	const char* base = getenv("TMPDIR") ?: "/tmp";
+	std::string path = std::string(base) + "/DolphinWii.XXXXXX";
+	if (!mkdtemp(&path[0]))
+		return "";
+	return path;
+#endif
+}
+
 std::string GetTempFilenameForAtomicWrite(const std::string &path)
 {
 	std::string abs = path;
@@ -738,17 +761,9 @@ static void RebuildUserDirectories(unsigned int dir_index)
 {
 	switch (dir_index)
 	{
-	case D_WIIROOT_IDX:
-		s_user_paths[D_WIIUSER_IDX]    = s_user_paths[D_WIIROOT_IDX] + DIR_SEP;
-		s_user_paths[D_WIISYSCONF_IDX] = s_user_paths[D_WIIUSER_IDX] + WII_SYSCONF_DIR + DIR_SEP;
-		s_user_paths[D_WIIWC24_IDX]    = s_user_paths[D_WIIUSER_IDX] + WII_WC24CONF_DIR DIR_SEP;
-		s_user_paths[F_WIISYSCONF_IDX] = s_user_paths[D_WIISYSCONF_IDX] + WII_SYSCONF;
-		break;
-
 	case D_USER_IDX:
 		s_user_paths[D_GCUSER_IDX]         = s_user_paths[D_USER_IDX] + GC_USER_DIR DIR_SEP;
 		s_user_paths[D_WIIROOT_IDX]        = s_user_paths[D_USER_IDX] + WII_USER_DIR;
-		s_user_paths[D_WIIUSER_IDX]        = s_user_paths[D_WIIROOT_IDX] + DIR_SEP;
 		s_user_paths[D_CONFIG_IDX]         = s_user_paths[D_USER_IDX] + CONFIG_DIR DIR_SEP;
 		s_user_paths[D_GAMESETTINGS_IDX]   = s_user_paths[D_USER_IDX] + GAMESETTINGS_DIR DIR_SEP;
 		s_user_paths[D_MAPS_IDX]           = s_user_paths[D_USER_IDX] + MAPS_DIR DIR_SEP;
@@ -766,14 +781,11 @@ static void RebuildUserDirectories(unsigned int dir_index)
 		s_user_paths[D_DUMPDSP_IDX]        = s_user_paths[D_DUMP_IDX] + DUMP_DSP_DIR DIR_SEP;
 		s_user_paths[D_LOGS_IDX]           = s_user_paths[D_USER_IDX] + LOGS_DIR DIR_SEP;
 		s_user_paths[D_MAILLOGS_IDX]       = s_user_paths[D_LOGS_IDX] + MAIL_LOGS_DIR DIR_SEP;
-		s_user_paths[D_WIISYSCONF_IDX]     = s_user_paths[D_WIIUSER_IDX] + WII_SYSCONF_DIR DIR_SEP;
-		s_user_paths[D_WIIWC24_IDX]    = s_user_paths[D_WIIUSER_IDX] + WII_WC24CONF_DIR DIR_SEP;
 		s_user_paths[D_THEMES_IDX]         = s_user_paths[D_USER_IDX] + THEMES_DIR DIR_SEP;
 		s_user_paths[F_DOLPHINCONFIG_IDX]  = s_user_paths[D_CONFIG_IDX] + DOLPHIN_CONFIG;
 		s_user_paths[F_DEBUGGERCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + DEBUGGER_CONFIG;
 		s_user_paths[F_LOGGERCONFIG_IDX]   = s_user_paths[D_CONFIG_IDX] + LOGGER_CONFIG;
 		s_user_paths[F_MAINLOG_IDX]        = s_user_paths[D_LOGS_IDX] + MAIN_LOG;
-		s_user_paths[F_WIISYSCONF_IDX]     = s_user_paths[D_WIISYSCONF_IDX] + WII_SYSCONF;
 		s_user_paths[F_RAMDUMP_IDX]        = s_user_paths[D_DUMP_IDX] + RAM_DUMP;
 		s_user_paths[F_ARAMDUMP_IDX]       = s_user_paths[D_DUMP_IDX] + ARAM_DUMP;
 		s_user_paths[F_FAKEVMEMDUMP_IDX]   = s_user_paths[D_DUMP_IDX] + FAKEVMEM_DUMP;

Source/Core/Common/FileUtil.h

@@ -20,8 +20,8 @@
 enum {
 	D_USER_IDX,
 	D_GCUSER_IDX,
-	D_WIIROOT_IDX,
-	D_WIIUSER_IDX,
+	D_WIIROOT_IDX, // always points to User/Wii or global user-configured directory
+	D_SESSION_WIIROOT_IDX, // may point to minimal temporary directory for determinism
 	D_CONFIG_IDX, // global settings
 	D_GAMESETTINGS_IDX, // user-specified settings which override both the global and the default settings (per game)
 	D_MAPS_IDX,
@@ -39,14 +39,11 @@ enum {
 	D_LOAD_IDX,
 	D_LOGS_IDX,
 	D_MAILLOGS_IDX,
-	D_WIISYSCONF_IDX,
-	D_WIIWC24_IDX,
 	D_THEMES_IDX,
 	F_DOLPHINCONFIG_IDX,
 	F_DEBUGGERCONFIG_IDX,
 	F_LOGGERCONFIG_IDX,
 	F_MAINLOG_IDX,
-	F_WIISYSCONF_IDX,
 	F_RAMDUMP_IDX,
 	F_ARAMDUMP_IDX,
 	F_FAKEVMEMDUMP_IDX,
@@ -107,9 +104,8 @@ bool Copy(const std::string &srcFilename, const std::string &destFilename);
 // creates an empty file filename, returns true on success
 bool CreateEmptyFile(const std::string &filename);
 
-// Scans the directory tree gets, starting from _Directory and adds the
-// results into parentEntry. Returns the number of files+directories found
-u32 ScanDirectoryTree(const std::string &directory, FSTEntry& parentEntry);
+// Recursive or non-recursive list of files under directory.
+FSTEntry ScanDirectoryTree(const std::string &directory, bool recursive);
 
 // deletes the given directory and anything under it. Returns true on success.
 bool DeleteDirRecursively(const std::string &directory);
@@ -123,6 +119,9 @@ void CopyDir(const std::string &source_path, const std::string &dest_path);
 // Set the current directory to given directory
 bool SetCurrentDir(const std::string &directory);
 
+// Creates and returns the path to a new temporary directory.
+std::string CreateTempDir();
+
 // Get a filename that can hopefully be atomically renamed to the given path.
 std::string GetTempFilenameForAtomicWrite(const std::string &path);
 

Source/Core/Common/NandPaths.cpp

@@ -7,6 +7,7 @@
 #include <string>
 #include <utility>
 
+#include "Common/CommonPaths.h"
 #include "Common/CommonTypes.h"
 #include "Common/FileUtil.h"
 #include "Common/NandPaths.h"
@@ -15,17 +16,55 @@
 namespace Common
 {
 
+static std::string s_temp_wii_root;
+
+void InitializeWiiRoot(bool use_dummy)
+{
+	ShutdownWiiRoot();
+	if (use_dummy)
+	{
+		s_temp_wii_root = File::CreateTempDir();
+		if (s_temp_wii_root.empty())
+		{
+			ERROR_LOG(WII_IPC_FILEIO, "Could not create temporary directory");
+			return;
+		}
+		File::CopyDir(File::GetSysDirectory() + WII_USER_DIR, s_temp_wii_root);
+		WARN_LOG(WII_IPC_FILEIO, "Using temporary directory %s for minimal Wii FS", s_temp_wii_root.c_str());
+		static bool s_registered;
+		if (!s_registered)
+		{
+			s_registered = true;
+			atexit(ShutdownWiiRoot);
+		}
+		File::SetUserPath(D_SESSION_WIIROOT_IDX, s_temp_wii_root);
+	}
+	else
+	{
+		File::SetUserPath(D_SESSION_WIIROOT_IDX, File::GetUserPath(D_WIIROOT_IDX));
+	}
+}
+
+void ShutdownWiiRoot()
+{
+	if (!s_temp_wii_root.empty())
+	{
+		File::DeleteDirRecursively(s_temp_wii_root);
+		s_temp_wii_root.clear();
+	}
+}
+
 std::string GetTicketFileName(u64 _titleID)
 {
-	return StringFromFormat("%sticket/%08x/%08x.tik",
-			File::GetUserPath(D_WIIUSER_IDX).c_str(),
+	return StringFromFormat("%s/ticket/%08x/%08x.tik",
+			File::GetUserPath(D_SESSION_WIIROOT_IDX).c_str(),
 			(u32)(_titleID >> 32), (u32)_titleID);
 }
 
 std::string GetTitleDataPath(u64 _titleID)
 {
-	return StringFromFormat("%stitle/%08x/%08x/data/",
-			File::GetUserPath(D_WIIUSER_IDX).c_str(),
+	return StringFromFormat("%s/title/%08x/%08x/data/",
+			File::GetUserPath(D_SESSION_WIIROOT_IDX).c_str(),
 			(u32)(_titleID >> 32), (u32)_titleID);
 }
 
@@ -35,8 +74,8 @@ std::string GetTMDFileName(u64 _titleID)
 }
 std::string GetTitleContentPath(u64 _titleID)
 {
-	return StringFromFormat("%stitle/%08x/%08x/content/",
-			File::GetUserPath(D_WIIUSER_IDX).c_str(),
+	return StringFromFormat("%s/title/%08x/%08x/content/",
+			File::GetUserPath(D_SESSION_WIIROOT_IDX).c_str(),
 			(u32)(_titleID >> 32), (u32)_titleID);
 }
 
@@ -89,8 +128,7 @@ void ReadReplacements(replace_v& replacements)
 {
 	replacements.clear();
 	const std::string replace_fname = "/sys/replace";
-	std::string filename(File::GetUserPath(D_WIIROOT_IDX));
-	filename += replace_fname;
+	std::string filename = File::GetUserPath(D_SESSION_WIIROOT_IDX) + replace_fname;
 
 	if (!File::Exists(filename))
 		CreateReplacementFile(filename);

Source/Core/Common/NandPaths.h

@@ -18,6 +18,9 @@ namespace Common
 	typedef std::pair<char, std::string> replace_t;
 	typedef std::vector<replace_t> replace_v;
 
+	void InitializeWiiRoot(bool use_temporary);
+	void ShutdownWiiRoot();
+
 	std::string GetTicketFileName(u64 _titleID);
 	std::string GetTMDFileName(u64 _titleID);
 	std::string GetTitleDataPath(u64 _titleID);

Source/Core/Common/SysConf.cpp

@@ -8,6 +8,7 @@
 #include <string>
 #include <vector>
 
+#include "Common/CommonPaths.h"
 #include "Common/CommonTypes.h"
 #include "Common/FileUtil.h"
 #include "Common/SysConf.h"
@@ -15,8 +16,7 @@
 SysConf::SysConf()
 	: m_IsValid(false)
 {
-	m_FilenameDefault = File::GetUserPath(F_WIISYSCONF_IDX);
-	m_IsValid = LoadFromFile(m_FilenameDefault);
+	UpdateLocation();
 }
 
 SysConf::~SysConf()
@@ -38,6 +38,10 @@ void SysConf::Clear()
 
 bool SysConf::LoadFromFile(const std::string& filename)
 {
+	if (m_IsValid)
+		Clear();
+	m_IsValid = false;
+
 	// Basic check
 	if (!File::Exists(filename))
 	{
@@ -67,6 +71,7 @@ bool SysConf::LoadFromFile(const std::string& filename)
 		if (LoadFromFileInternal(f.ReleaseHandle()))
 		{
 			m_Filename = filename;
+			m_IsValid = true;
 			return true;
 		}
 	}
@@ -107,6 +112,7 @@ bool SysConf::LoadFromFileInternal(FILE *fh)
 		f.ReadArray(curEntry.name, curEntry.nameLength);
 		curEntry.name[curEntry.nameLength] = '\0';
 		// Get length of data
+		curEntry.data = nullptr;
 		curEntry.dataLength = 0;
 		switch (curEntry.type)
 		{
@@ -362,6 +368,7 @@ void SysConf::GenerateSysConf()
 	g.WriteBytes("SCed", 4);
 
 	m_Filename = m_FilenameDefault;
+	m_IsValid = true;
 }
 
 bool SysConf::SaveToFile(const std::string& filename)
@@ -409,17 +416,17 @@ void SysConf::UpdateLocation()
 	// Clear the old filename and set the default filename to the new user path
 	// So that it can be generated if the file does not exist in the new location
 	m_Filename.clear();
-	m_FilenameDefault =  File::GetUserPath(F_WIISYSCONF_IDX);
+	// Note: We don't use the dummy Wii root here (if in use) because this is
+	// all tied up with the configuration code.  In the future this should
+	// probably just be synced with the other settings.
+	m_FilenameDefault = File::GetUserPath(D_WIIROOT_IDX) + DIR_SEP WII_SYSCONF_DIR DIR_SEP WII_SYSCONF;
 	Reload();
 }
 
 bool SysConf::Reload()
 {
-	if (m_IsValid)
-		Clear();
-
 	std::string& filename = m_Filename.empty() ? m_FilenameDefault : m_Filename;
 
-	m_IsValid = LoadFromFile(filename);
+	LoadFromFile(filename);
 	return m_IsValid;
 }

Source/Core/Core/Boot/Boot_BS2Emu.cpp

@@ -199,7 +199,10 @@ bool CBoot::SetupWiiMemory(DiscIO::IVolume::ECountry country)
 
 	if (serno.empty() || serno == "000000000")
 	{
-		serno = gen.generateSerialNumber();
+		if (Core::g_want_determinism)
+			serno = "123456789";
+		else
+			serno = gen.generateSerialNumber();
 		INFO_LOG(BOOT, "No previous serial number found, generated one instead: %s", serno.c_str());
 	}
 	else

Source/Core/Core/ConfigManager.cpp

@@ -475,8 +475,6 @@ void SConfig::LoadGeneralSettings(IniFile& ini)
 
 	general->Get("NANDRootPath", &m_NANDPath);
 	File::SetUserPath(D_WIIROOT_IDX, m_NANDPath);
-	DiscIO::cUIDsys::AccessInstance().UpdateLocation();
-	DiscIO::CSharedContent::AccessInstance().UpdateLocation();
 	general->Get("WirelessMac", &m_WirelessMac);
 }
 

Source/Core/Core/Core.cpp

@@ -831,6 +831,7 @@ void UpdateWantDeterminism(bool initial)
 		g_video_backend->UpdateWantDeterminism(new_want_determinism);
 		// We need to clear the cache because some parts of the JIT depend on want_determinism, e.g. use of FMA.
 		JitInterface::ClearCache();
+		Common::InitializeWiiRoot(g_want_determinism);
 
 		Core::PauseAndLock(false, was_unpaused);
 	}

Source/Core/Core/CoreTiming.cpp

@@ -226,6 +226,12 @@ u64 GetIdleTicks()
 void ScheduleEvent_Threadsafe(int cyclesIntoFuture, int event_type, u64 userdata)
 {
 	_assert_msg_(POWERPC, !Core::IsCPUThread(), "ScheduleEvent_Threadsafe from wrong thread");
+	if (Core::g_want_determinism)
+	{
+		ERROR_LOG(POWERPC, "Someone scheduled an off-thread \"%s\" event while netplay or movie play/record "
+		                   "was active.  This is likely to cause a desync.",
+		                   event_types[event_type].name.c_str());
+	}
 	std::lock_guard<std::mutex> lk(tsWriteLock);
 	Event ne;
 	ne.time = globalTimer + cyclesIntoFuture;

Source/Core/Core/HW/GCMemcardDirectory.cpp

@@ -151,16 +151,7 @@ GCMemcardDirectory::GCMemcardDirectory(const std::string& directory, int slot, u
 		hdrfile.ReadBytes(&m_hdr, BLOCK_SIZE);
 	}
 
-	File::FSTEntry FST_Temp;
-	File::ScanDirectoryTree(m_SaveDirectory, FST_Temp);
-
-	CFileSearch::XStringVector Directory;
-	Directory.push_back(m_SaveDirectory);
-	CFileSearch::XStringVector Extensions;
-	Extensions.push_back("*.gci");
-
-	CFileSearch FileSearch(Extensions, Directory);
-	const CFileSearch::XStringVector& rFilenames = FileSearch.GetFileNames();
+	std::vector<std::string> rFilenames = DoFileSearch({"*.gci"}, {m_SaveDirectory});
 
 	if (rFilenames.size() > 112)
 	{
@@ -170,7 +161,7 @@ GCMemcardDirectory::GCMemcardDirectory(const std::string& directory, int slot, u
 		4000);
 	}
 
-	for (auto gciFile : rFilenames)
+	for (const std::string& gciFile : rFilenames)
 	{
 		if (m_saves.size() == DIRLEN)
 		{

Source/Core/Core/HW/HW.cpp

@@ -4,6 +4,7 @@
 
 #include "Common/ChunkFile.h"
 #include "Common/CommonTypes.h"
+#include "Common/NandPaths.h"
 
 #include "Core/ConfigManager.h"
 #include "Core/Core.h"
@@ -25,6 +26,7 @@
 #include "Core/IPC_HLE/WII_IPC_HLE.h"
 #include "Core/PowerPC/PowerPC.h"
 #include "Core/PowerPC/PPCAnalyst.h"
+#include "DiscIO/NANDContentLoader.h"
 
 namespace HW
 {
@@ -50,6 +52,9 @@ namespace HW
 
 		if (SConfig::GetInstance().m_LocalCoreStartupParameter.bWii)
 		{
+			Common::InitializeWiiRoot(Core::g_want_determinism);
+			DiscIO::cUIDsys::AccessInstance().UpdateLocation();
+			DiscIO::CSharedContent::AccessInstance().UpdateLocation();
 			WII_IPCInterface::Init();
 			WII_IPC_HLE_Interface::Init();
 		}
@@ -70,6 +75,7 @@ namespace HW
 		{
 			WII_IPCInterface::Shutdown();
 			WII_IPC_HLE_Interface::Shutdown();
+			Common::ShutdownWiiRoot();
 		}
 
 		State::Shutdown();

Source/Core/Core/HW/WiiSaveCrypted.cpp

@@ -62,14 +62,13 @@ bool CWiiSaveCrypted::ExportWiiSave(u64 title_id)
 
 void CWiiSaveCrypted::ExportAllSaves()
 {
-	std::string title_folder = File::GetUserPath(D_WIIUSER_IDX) + "title";
+	std::string title_folder = File::GetUserPath(D_WIIROOT_IDX) + "/title";
 	std::vector<u64> titles;
 	const u32 path_mask = 0x00010000;
 	for (int i = 0; i < 8; ++i)
 	{
-		File::FSTEntry fst_tmp;
 		std::string folder = StringFromFormat("%s/%08x/", title_folder.c_str(), path_mask | i);
-		File::ScanDirectoryTree(folder, fst_tmp);
+		File::FSTEntry fst_tmp = File::ScanDirectoryTree(folder, false);
 
 		for (const File::FSTEntry& entry : fst_tmp.children)
 		{
@@ -627,8 +626,7 @@ void CWiiSaveCrypted::ScanForFiles(const std::string& save_directory, std::vecto
 			file_list.push_back(directories[i]);
 		}
 
-		File::FSTEntry fst_tmp;
-		File::ScanDirectoryTree(directories[i], fst_tmp);
+		File::FSTEntry fst_tmp = File::ScanDirectoryTree(directories[i], false);
 		for (const File::FSTEntry& elem : fst_tmp.children)
 		{
 			if (elem.virtualName != "banner.bin")

Source/Core/Core/HW/WiimoteEmu/EmuSubroutines.cpp

@@ -22,6 +22,7 @@
 
 #include "Common/CommonTypes.h"
 #include "Common/FileUtil.h"
+#include "Common/NandPaths.h"
 
 #include "Core/HW/WiimoteEmu/WiimoteEmu.h"
 #include "Core/HW/WiimoteEmu/WiimoteHid.h"
@@ -275,7 +276,7 @@ void Wiimote::WriteData(const wm_write_data* const wd)
 			{
 				// writing the whole mii block each write :/
 				std::ofstream file;
-				OpenFStream(file, File::GetUserPath(D_WIIUSER_IDX) + "mii.bin", std::ios::binary | std::ios::out);
+				OpenFStream(file, File::GetUserPath(D_SESSION_WIIROOT_IDX) + "/mii.bin", std::ios::binary | std::ios::out);
 				file.write((char*)m_eeprom + 0x0FCA, 0x02f0);
 				file.close();
 			}
@@ -417,7 +418,7 @@ void Wiimote::ReadData(const wm_read_data* const rd)
 			{
 				// reading the whole mii block :/
 				std::ifstream file;
-				file.open((File::GetUserPath(D_WIIUSER_IDX) + "mii.bin").c_str(), std::ios::binary | std::ios::in);
+				file.open((File::GetUserPath(D_SESSION_WIIROOT_IDX) + "/mii.bin").c_str(), std::ios::binary | std::ios::in);
 				file.read((char*)m_eeprom + 0x0FCA, 0x02f0);
 				file.close();
 			}

Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_FileIO.cpp

@@ -5,11 +5,14 @@
 #include <algorithm>
 
 #include "Common/ChunkFile.h"
+#include "Common/CommonPaths.h"
 #include "Common/CommonTypes.h"
 #include "Common/FileUtil.h"
 #include "Common/NandPaths.h"
 #include "Common/StringUtil.h"
 
+#include "Core/Core.h"
+#include "Core/IPC_HLE/WII_IPC_HLE.h"
 #include "Core/IPC_HLE/WII_IPC_HLE_Device_FileIO.h"
 #include "Core/IPC_HLE/WII_IPC_HLE_Device_fs.h"
 
@@ -19,7 +22,7 @@ static Common::replace_v replacements;
 // This is used by several of the FileIO and /dev/fs functions
 std::string HLE_IPC_BuildFilename(std::string path_wii)
 {
-	std::string path_full = File::GetUserPath(D_WIIROOT_IDX);
+	std::string path_full = File::GetUserPath(D_SESSION_WIIROOT_IDX);
 
 	// Replaces chars that FAT32 can't support with strings defined in /sys/replace
 	for (auto& replacement : replacements)

Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_fs.cpp

@@ -5,7 +5,6 @@
 #include "Common/ChunkFile.h"
 #include "Common/CommonPaths.h"
 #include "Common/CommonTypes.h"
-#include "Common/FileSearch.h"
 #include "Common/FileUtil.h"
 #include "Common/NandPaths.h"
 #include "Common/StringUtil.h"
@@ -33,7 +32,7 @@ IPCCommandResult CWII_IPC_HLE_Device_fs::Open(u32 _CommandAddress, u32 _Mode)
 {
 	// clear tmp folder
 	{
-		std::string Path = File::GetUserPath(D_WIIUSER_IDX) + "tmp";
+		std::string Path = HLE_IPC_BuildFilename("/tmp");
 		File::DeleteDirRecursively(Path);
 		File::CreateDir(Path);
 	}
@@ -106,25 +105,28 @@ IPCCommandResult CWII_IPC_HLE_Device_fs::IOCtlV(u32 _CommandAddress)
 				break;
 			}
 
-			// make a file search
-			CFileSearch::XStringVector Directories;
-			Directories.push_back(DirName);
-
-			CFileSearch::XStringVector Extensions;
-			Extensions.push_back("*.*");
-
-			CFileSearch FileSearch(Extensions, Directories);
+			File::FSTEntry entry = File::ScanDirectoryTree(DirName, false);
 
 			// it is one
 			if ((CommandBuffer.InBuffer.size() == 1) && (CommandBuffer.PayloadBuffer.size() == 1))
 			{
-				size_t numFile = FileSearch.GetFileNames().size();
+				size_t numFile = entry.children.size();
 				INFO_LOG(WII_IPC_FILEIO, "\t%lu files found", (unsigned long)numFile);
 
 				Memory::Write_U32((u32)numFile, CommandBuffer.PayloadBuffer[0].m_Address);
 			}
 			else
 			{
+				for (File::FSTEntry& child : entry.children)
+				{
+					// Decode entities of invalid file system characters so that
+					// games (such as HP:HBP) will be able to find what they expect.
+					for (const Common::replace_t& r : replacements)
+						child.virtualName = ReplaceAll(child.virtualName, r.second, {r.first});
+				}
+
+				std::sort(entry.children.begin(), entry.children.end(), [](const File::FSTEntry& one, const File::FSTEntry& two) { return one.virtualName < two.virtualName; });
+
 				u32 MaxEntries = Memory::Read_U32(CommandBuffer.InBuffer[0].m_Address);
 
 				memset(Memory::GetPointer(CommandBuffer.PayloadBuffer[0].m_Address), 0, CommandBuffer.PayloadBuffer[0].m_Size);
@@ -132,22 +134,10 @@ IPCCommandResult CWII_IPC_HLE_Device_fs::IOCtlV(u32 _CommandAddress)
 				size_t numFiles = 0;
 				char* pFilename = (char*)Memory::GetPointer((u32)(CommandBuffer.PayloadBuffer[0].m_Address));
 
-				for (size_t i=0; i<FileSearch.GetFileNames().size(); i++)
+				for (size_t i=0; i < entry.children.size() && i < MaxEntries; i++)
 				{
-					if (i >= MaxEntries)
-						break;
+					const std::string& FileName = entry.children[i].virtualName;
 
-					std::string name, ext;
-					SplitPath(FileSearch.GetFileNames()[i], nullptr, &name, &ext);
-					std::string FileName = name + ext;
-
-					// Decode entities of invalid file system characters so that
-					// games (such as HP:HBP) will be able to find what they expect.
-					for (const Common::replace_t& r : replacements)
-					{
-						for (size_t j = 0; (j = FileName.find(r.second, j)) != FileName.npos; ++j)
-							FileName.replace(j, r.second.length(), 1, r.first);
-					}
 
 					strcpy(pFilename, FileName.c_str());
 					pFilename += FileName.length();
@@ -192,10 +182,9 @@ IPCCommandResult CWII_IPC_HLE_Device_fs::IOCtlV(u32 _CommandAddress)
 				}
 				else
 				{
-					File::FSTEntry parentDir;
-					// add one for the folder itself, allows some games to create their save files
-					// R8XE52 (Jurassic: The Hunted), STEETR (Tetris Party Deluxe) now create their saves with this change
-					iNodes = 1 + File::ScanDirectoryTree(path, parentDir);
+					File::FSTEntry parentDir = File::ScanDirectoryTree(path, true);
+					// add one for the folder itself
+					iNodes = 1 + (u32)parentDir.size;
 
 					u64 totalSize = ComputeTotalFileSize(parentDir); // "Real" size, to be converted to nand blocks
 
@@ -232,7 +221,6 @@ IPCCommandResult CWII_IPC_HLE_Device_fs::IOCtlV(u32 _CommandAddress)
 IPCCommandResult CWII_IPC_HLE_Device_fs::IOCtl(u32 _CommandAddress)
 {
 	//u32 DeviceID = Memory::Read_U32(_CommandAddress + 8);
-	//LOG(WII_IPC_FILEIO, "FS: IOCtl (Device=%s, DeviceID=%08x)", GetDeviceName().c_str(), DeviceID);
 
 	u32 Parameter =  Memory::Read_U32(_CommandAddress + 0xC);
 	u32 BufferIn =  Memory::Read_U32(_CommandAddress + 0x10);
@@ -494,7 +482,7 @@ void CWII_IPC_HLE_Device_fs::DoState(PointerWrap& p)
 
 	// handle /tmp
 
-	std::string Path = File::GetUserPath(D_WIIUSER_IDX) + "tmp";
+	std::string Path = File::GetUserPath(D_SESSION_WIIROOT_IDX) + "/tmp";
 	if (p.GetMode() == PointerWrap::MODE_READ)
 	{
 		File::DeleteDirRecursively(Path);
@@ -542,8 +530,7 @@ void CWII_IPC_HLE_Device_fs::DoState(PointerWrap& p)
 	{
 		//recurse through tmp and save dirs and files
 
-		File::FSTEntry parentEntry;
-		File::ScanDirectoryTree(Path, parentEntry);
+		File::FSTEntry parentEntry = File::ScanDirectoryTree(Path, true);
 		std::deque<File::FSTEntry> todo;
 		todo.insert(todo.end(), parentEntry.children.begin(),
 			    parentEntry.children.end());

Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_hid.cpp

@@ -129,6 +129,12 @@ IPCCommandResult CWII_IPC_HLE_Device_hid::Close(u32 _CommandAddress, bool _bForc
 
 IPCCommandResult CWII_IPC_HLE_Device_hid::IOCtl(u32 _CommandAddress)
 {
+	if (Core::g_want_determinism)
+	{
+		Memory::Write_U32(-1, _CommandAddress + 0x4);
+		return IPC_DEFAULT_REPLY;
+	}
+
 	u32 Parameter     = Memory::Read_U32(_CommandAddress + 0xC);
 	u32 BufferIn      = Memory::Read_U32(_CommandAddress + 0x10);
 	u32 BufferInSize  = Memory::Read_U32(_CommandAddress + 0x14);

Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_net.cpp

@@ -15,6 +15,7 @@
 #include "Common/StringUtil.h"
 
 #include "Core/ConfigManager.h"
+#include "Core/Core.h"
 #include "Core/ec_wii.h"
 #include "Core/IPC_HLE/ICMP.h"
 #include "Core/IPC_HLE/WII_IPC_HLE_Device_es.h"
@@ -314,6 +315,10 @@ static void GetMacAddress(u8* mac)
 	// Parse MAC address from config, and generate a new one if it doesn't
 	// exist or can't be parsed.
 	std::string wireless_mac = SConfig::GetInstance().m_WirelessMac;
+
+	if (Core::g_want_determinism)
+		wireless_mac = "12:34:56:78:9a:bc";
+
 	if (!StringToMacAddress(wireless_mac, mac))
 	{
 		GenerateMacAddress(IOS, mac);
@@ -639,6 +644,13 @@ static unsigned int opt_name_mapping[][2] = {
 
 IPCCommandResult CWII_IPC_HLE_Device_net_ip_top::IOCtl(u32 _CommandAddress)
 {
+	if (Core::g_want_determinism)
+	{
+		Memory::Write_U32(-1, _CommandAddress + 4);
+		return IPC_DEFAULT_REPLY;
+	}
+
+
 	u32 Command       = Memory::Read_U32(_CommandAddress + 0x0C);
 	u32 BufferIn      = Memory::Read_U32(_CommandAddress + 0x10);
 	u32 BufferInSize  = Memory::Read_U32(_CommandAddress + 0x14);
@@ -1217,65 +1229,68 @@ IPCCommandResult CWII_IPC_HLE_Device_net_ip_top::IOCtlV(u32 CommandAddress)
 		{
 			u32 address = 0;
 #ifdef _WIN32
-			PIP_ADAPTER_ADDRESSES AdapterAddresses = nullptr;
-			ULONG OutBufferLength = 0;
-			ULONG RetVal = 0, i;
-			for (i = 0; i < 5; ++i)
+			if (!Core::g_want_determinism)
 			{
-				RetVal = GetAdaptersAddresses(
-					AF_INET,
-					0,
-					nullptr,
-					AdapterAddresses,
-					&OutBufferLength);
-
-				if (RetVal != ERROR_BUFFER_OVERFLOW)
+				PIP_ADAPTER_ADDRESSES AdapterAddresses = nullptr;
+				ULONG OutBufferLength = 0;
+				ULONG RetVal = 0, i;
+				for (i = 0; i < 5; ++i)
 				{
-					break;
-				}
+					RetVal = GetAdaptersAddresses(
+						AF_INET,
+						0,
+						nullptr,
+						AdapterAddresses,
+						&OutBufferLength);
 
+					if (RetVal != ERROR_BUFFER_OVERFLOW)
+					{
+						break;
+					}
+
+					if (AdapterAddresses != nullptr)
+					{
+						FREE(AdapterAddresses);
+					}
+
+					AdapterAddresses = (PIP_ADAPTER_ADDRESSES)MALLOC(OutBufferLength);
+					if (AdapterAddresses == nullptr)
+					{
+						RetVal = GetLastError();
+						break;
+					}
+				}
+				if (RetVal == NO_ERROR)
+				{
+					unsigned long dwBestIfIndex = 0;
+					IPAddr dwDestAddr = (IPAddr)0x08080808;
+					// If successful, output some information from the data we received
+					PIP_ADAPTER_ADDRESSES AdapterList = AdapterAddresses;
+					if (GetBestInterface(dwDestAddr, &dwBestIfIndex) == NO_ERROR)
+					{
+						while (AdapterList)
+						{
+							if (AdapterList->IfIndex == dwBestIfIndex &&
+								AdapterList->FirstDnsServerAddress &&
+								AdapterList->OperStatus == IfOperStatusUp)
+							{
+								INFO_LOG(WII_IPC_NET, "Name of valid interface: %S", AdapterList->FriendlyName);
+								INFO_LOG(WII_IPC_NET, "DNS: %u.%u.%u.%u",
+									(unsigned char)AdapterList->FirstDnsServerAddress->Address.lpSockaddr->sa_data[2],
+									(unsigned char)AdapterList->FirstDnsServerAddress->Address.lpSockaddr->sa_data[3],
+									(unsigned char)AdapterList->FirstDnsServerAddress->Address.lpSockaddr->sa_data[4],
+									(unsigned char)AdapterList->FirstDnsServerAddress->Address.lpSockaddr->sa_data[5]);
+								address = Common::swap32(*(u32*)(&AdapterList->FirstDnsServerAddress->Address.lpSockaddr->sa_data[2]));
+								break;
+							}
+							AdapterList = AdapterList->Next;
+						}
+					}
+				}
 				if (AdapterAddresses != nullptr)
 				{
 					FREE(AdapterAddresses);
 				}
-
-				AdapterAddresses = (PIP_ADAPTER_ADDRESSES)MALLOC(OutBufferLength);
-				if (AdapterAddresses == nullptr)
-				{
-					RetVal = GetLastError();
-					break;
-				}
-			}
-			if (RetVal == NO_ERROR)
-			{
-				unsigned long dwBestIfIndex = 0;
-				IPAddr dwDestAddr = (IPAddr)0x08080808;
-				// If successful, output some information from the data we received
-				PIP_ADAPTER_ADDRESSES AdapterList = AdapterAddresses;
-				if (GetBestInterface(dwDestAddr, &dwBestIfIndex) == NO_ERROR)
-				{
-					while (AdapterList)
-					{
-						if (AdapterList->IfIndex == dwBestIfIndex &&
-							AdapterList->FirstDnsServerAddress &&
-							AdapterList->OperStatus == IfOperStatusUp)
-						{
-							INFO_LOG(WII_IPC_NET, "Name of valid interface: %S", AdapterList->FriendlyName);
-							INFO_LOG(WII_IPC_NET, "DNS: %u.%u.%u.%u",
-								(unsigned char)AdapterList->FirstDnsServerAddress->Address.lpSockaddr->sa_data[2],
-								(unsigned char)AdapterList->FirstDnsServerAddress->Address.lpSockaddr->sa_data[3],
-								(unsigned char)AdapterList->FirstDnsServerAddress->Address.lpSockaddr->sa_data[4],
-								(unsigned char)AdapterList->FirstDnsServerAddress->Address.lpSockaddr->sa_data[5]);
-							address = Common::swap32(*(u32*)(&AdapterList->FirstDnsServerAddress->Address.lpSockaddr->sa_data[2]));
-							break;
-						}
-						AdapterList = AdapterList->Next;
-					}
-				}
-			}
-			if (AdapterAddresses != nullptr)
-			{
-				FREE(AdapterAddresses);
 			}
 #endif
 			if (address == 0)

Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_net.h

@@ -4,9 +4,12 @@
 
 #pragma once
 
+#include "Common/CommonPaths.h"
 #include "Common/FileUtil.h"
+#include "Common/NandPaths.h"
 #include "Common/Timer.h"
 
+#include "Core/HW/EXI_DeviceIPL.h"
 #include "Core/IPC_HLE/WII_IPC_HLE_Device.h"
 
 #ifdef _WIN32
@@ -171,7 +174,7 @@ private:
 public:
 	NWC24Config()
 	{
-		path = File::GetUserPath(D_WIIWC24_IDX) + "nwc24msg.cfg";
+		path = File::GetUserPath(D_SESSION_WIIROOT_IDX) + "/" WII_WC24CONF_DIR "/nwc24msg.cfg";
 		ReadConfig();
 	}
 
@@ -210,7 +213,7 @@ public:
 	{
 		if (!File::Exists(path))
 		{
-			if (!File::CreateFullPath(File::GetUserPath(D_WIIWC24_IDX)))
+			if (!File::CreateFullPath(File::GetUserPath(D_SESSION_WIIROOT_IDX) + "/" WII_WC24CONF_DIR))
 			{
 				ERROR_LOG(WII_IPC_WC24, "Failed to create directory for WC24");
 			}
@@ -321,7 +324,7 @@ class WiiNetConfig
 public:
 	WiiNetConfig()
 	{
-		path = File::GetUserPath(D_WIISYSCONF_IDX) + "net/02/config.dat";
+		path = File::GetUserPath(D_SESSION_WIIROOT_IDX) + "/" WII_SYSCONF_DIR "/net/02/config.dat";
 		ReadConfig();
 	}
 
@@ -346,7 +349,7 @@ public:
 	{
 		if (!File::Exists(path))
 		{
-			if (!File::CreateFullPath(std::string(File::GetUserPath(D_WIISYSCONF_IDX) + "net/02/")))
+			if (!File::CreateFullPath(std::string(File::GetUserPath(D_SESSION_WIIROOT_IDX) + "/" WII_SYSCONF_DIR "/net/02/")))
 			{
 				ERROR_LOG(WII_IPC_NET, "Failed to create directory for network config file");
 			}
@@ -528,21 +531,26 @@ private:
 	u64 rtc;
 	s64 utcdiff;
 
-	// Seconds between 1.1.1970 and 4.1.2008 16:00:38
-	static const u64 wii_bias = 0x477E5826;
+	// TODO: depending on CEXIIPL is a hack which I don't feel like removing
+	// because the function itself is pretty hackish; wait until I re-port my
+	// netplay rewrite; also, is that random 16:00:38 actually meaningful?
+	// seems very very doubtful since Wii was released in 2006
+
+	// Seconds between 1.1.2000 and 4.1.2008 16:00:38
+	static const u64 wii_bias = 0x477E5826 - 0x386D4380;
 
 	// Returns seconds since Wii epoch
 	// +/- any bias set from IOCTL_NW24_SET_UNIVERSAL_TIME
 	u64 GetAdjustedUTC() const
 	{
-		return Common::Timer::GetTimeSinceJan1970() - wii_bias + utcdiff;
+		return CEXIIPL::GetGCTime() - wii_bias + utcdiff;
 	}
 
 	// Store the difference between what the Wii thinks is UTC and
 	// what the host OS thinks
 	void SetAdjustedUTC(u64 wii_utc)
 	{
-		utcdiff = Common::Timer::GetTimeSinceJan1970() - wii_bias - wii_utc;
+		utcdiff = CEXIIPL::GetGCTime() - wii_bias - wii_utc;
 	}
 };