Native Branch: Add CMD_XFER_ACCEPT support

src/realmd/AuthCodes.h

@@ -35,10 +35,9 @@ enum eAuthCmd : uint8
     CMD_REALM_LIST                  = 0x10,
     CMD_XFER_INITIATE               = 0x30,
     CMD_XFER_DATA                   = 0x31,
-    // these opcodes no longer exist in currently supported client
     CMD_XFER_ACCEPT                 = 0x32,
     CMD_XFER_RESUME                 = 0x33,
-    CMD_XFER_CANCEL                 = 0x34
+    CMD_XFER_CANCEL                 = 0x34,
 };
 
 // not used by us currently

src/realmd/AuthSocket.h

@@ -33,6 +33,7 @@
 #include "ByteBuffer.h"
 #include "IO/Networking/AsyncSocket.h"
 #include "IO/Timer/TimerHandle.h"
+#include "IO/Filesystem/FileHandle.h"
 
 struct PINData
 {
@@ -77,11 +78,11 @@ class AuthSocket : public IO::Networking::AsyncSocket<AuthSocket>
         void _HandleReconnectChallenge();
         void _HandleReconnectProof();
         void _HandleRealmList();
-        //data transfer handle for patch
 
-        bool _HandleXferResume();
-        bool _HandleXferCancel();
-        bool _HandleXferAccept();
+        //data transfer handle for patch
+        void _HandleXferAccept();
+        void _HandleXferResume();
+        void _HandleXferCancel();
 
     private:
         enum eStatus
@@ -95,7 +96,6 @@ class AuthSocket : public IO::Networking::AsyncSocket<AuthSocket>
         };
 
         bool VerifyVersion(uint8 const* a, int32 aLength, uint8 const* versionProof, bool isReconnect);
-        std::string GetRealmAddress(Realm const& realm) const;
 
         SRP6 srp;
         BigNumber m_reconnectProof;
@@ -139,11 +139,14 @@ class AuthSocket : public IO::Networking::AsyncSocket<AuthSocket>
         typedef std::map<uint32, AccountTypes> AccountSecurityMap;
         AccountSecurityMap m_accountSecurityOnRealm;
 
-        ACE_HANDLE m_patch = ACE_INVALID_HANDLE;
+        // Auto kick realmd client connection after some time
+        std::shared_ptr<IO::Timer::TimerHandle> m_sessionDurationTimeout;
 
-        void InitPatch();
+        // Patching stuff
+        void InitAndHandOverControlToPatchHandler();
+        std::unique_ptr<IO::Filesystem::FileHandleReadonly> m_pendingPatchFile = nullptr;
 
-        std::shared_ptr<IO::Timer::TimerHandle> m_sessionDurationTimeout;
+        void RepeatInternalXferLoop(std::shared_ptr<uint8_t[]> rawChunk);
 };
 
 #endif

src/realmd/CMakeLists.txt

@@ -16,15 +16,15 @@
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 set(EXECUTABLE_NAME realmd)
-set(EXECUTABLE_SRCS 
+set(EXECUTABLE_SRCS
   AuthCodes.h
   AuthSocket.h
-  PatchHandler.h
   RealmList.h
   AuthSocket.cpp
-  Main.cpp
-  PatchHandler.cpp
   RealmList.cpp
+  ClientPatchCache.h
+  ClientPatchCache.cpp
+  Main.cpp
 )
 
 

src/realmd/ClientPatchCache.cpp

@@ -0,0 +1,94 @@
+#include "./ClientPatchCache.h"
+#include "Policies/SingletonImp.h"
+#include "Log.h"
+#include "md5.h"
+#include "Config/Config.h"
+#include "IO/Filesystem/FileSystem.h"
+#include "IO/Filesystem/FileHandle.h"
+
+INSTANTIATE_SINGLETON_1(ClientPatchCache);
+
+ClientPatchCache::ClientPatchCache()
+{
+    LoadPatchesInfo();
+}
+
+void ClientPatchCache::LoadPatchesInfo()
+{
+    std::string folderPath = sConfig.GetStringDefault("PatchesDir", "./patches") + "/";
+    std::string fullFolderPath = IO::Filesystem::ToAbsolutePath(folderPath);
+
+    sLog.Out(LOG_BASIC, LOG_LVL_DEBUG, "[PatchCache] Loading available game client patches from folder %s", fullFolderPath.c_str());
+
+    for (const std::string& filePath : IO::Filesystem::GetAllFilesInFolder(fullFolderPath, IO::Filesystem::OutputFilePath::FullFilePath))
+    {
+        auto fileHandle = IO::Filesystem::TryOpenFileReadonly(filePath, IO::Filesystem::FileOpenFlags::HintSequentialRead);
+        if (fileHandle)
+        {
+            sLog.Out(LOG_BASIC, LOG_LVL_DEBUG, "[PatchCache] Calculate hash of %s", filePath.c_str());
+            CalculateAndCacheHash(std::move(fileHandle));
+        }
+        else
+        {
+            sLog.Out(LOG_BASIC, LOG_LVL_ERROR, "[PatchCache] Failed to open %s", filePath.c_str());
+        }
+    }
+}
+
+Md5HashDigest ClientPatchCache::GetOrCalculateHash(std::unique_ptr<IO::Filesystem::FileHandleReadonly> const& fileHandle)
+{
+    auto filePath = fileHandle->GetAbsoluteFilePath();
+    auto lastModifyDate = fileHandle->GetLastModifyDate();
+    auto fileSize = fileHandle->GetTotalFileSize();
+
+    m_knownPatches_mutex.lock_shared();
+    auto const& exisingEntry = m_knownPatches.find(filePath);
+    if (exisingEntry == m_knownPatches.end() || exisingEntry->second.lastModifyDate != lastModifyDate || exisingEntry->second.fileSize != fileSize)
+    { // file does not exist in cache or was changed
+        m_knownPatches_mutex.unlock_shared();
+        sLog.Out(LOG_BASIC, LOG_LVL_BASIC, "[PatchCache] Detected change of file '%s'. Will recalculate hash.", filePath.c_str());
+        // It's important to have a duplicate file handle here, since we want to guarantee easy access
+        return CalculateAndCacheHash(fileHandle->DuplicateFileHandle());
+    }
+    else
+    { // we can use the existent entry
+        Md5HashDigest md5Hash = exisingEntry->second.md5Hash;
+        m_knownPatches_mutex.unlock_shared();
+        return md5Hash;
+    }
+}
+
+Md5HashDigest ClientPatchCache::CalculateAndCacheHash(std::unique_ptr<IO::Filesystem::FileHandleReadonly> fileHandle)
+{
+    MD5_CTX ctx;
+    MD5_Init(&ctx);
+
+    size_t constexpr CHECK_CHUNK_SIZE = 1024 * 1024; // 1 MiB Chunks
+    std::vector<uint8_t> buffer(CHECK_CHUNK_SIZE);
+
+    uint64_t totalRead = 0;
+
+    do { // Read the file chunk by chunk and add insert it into our MD5_Update
+        uint64_t actuallyRead = fileHandle->ReadSync(buffer.data(), CHECK_CHUNK_SIZE);
+        MD5_Update(&ctx, buffer.data(), (size_t) actuallyRead);
+
+        totalRead += actuallyRead;
+
+        if (actuallyRead < CHECK_CHUNK_SIZE)
+            break; // we read less than expected, meaning the file is done
+    } while (true);
+
+    PatchCacheEntry entry;
+    entry.filePath = fileHandle->GetAbsoluteFilePath();
+    entry.lastModifyDate = fileHandle->GetLastModifyDate();
+    entry.fileSize = fileHandle->GetTotalFileSize();
+    MD5_Final(entry.md5Hash.digest.data(), &ctx);
+
+    MANGOS_ASSERT(totalRead == entry.fileSize);
+
+    m_knownPatches_mutex.lock();
+    m_knownPatches.emplace(entry.filePath, entry);
+    m_knownPatches_mutex.unlock();
+
+    return entry.md5Hash;
+}

src/realmd/ClientPatchCache.h

@@ -0,0 +1,51 @@
+#ifndef MANGOS_CLIENTPATCHCACHE_H
+#define MANGOS_CLIENTPATCHCACHE_H
+
+#include <mutex>
+#include <shared_mutex>
+#include <array>
+#include <memory>
+#include <unordered_map>
+#include <chrono>
+
+#include "IO/Filesystem/FileHandle.h"
+#include "Policies/Singleton.h"
+
+struct Md5HashDigest
+{
+    std::array<uint8_t, 16> digest;
+};
+
+struct PatchCacheEntry
+{
+    // To figure out if the file was changed
+    std::string filePath;
+    uint64_t fileSize;
+    std::chrono::system_clock::time_point lastModifyDate;
+
+    // The stuff we are actually interested in
+    Md5HashDigest md5Hash;
+};
+
+/// Caches MD5 hash of client patches present on the server
+class ClientPatchCache : public MaNGOS::Singleton<ClientPatchCache, MaNGOS::ClassLevelLockable<ClientPatchCache, std::mutex>>
+{
+    public:
+        explicit ClientPatchCache();
+
+        /// This function will detect changes in the size or modification date of the file
+        /// The FileHandle will be untouched (You can use the same handle to send the data to the client)
+        Md5HashDigest GetOrCalculateHash(std::unique_ptr<IO::Filesystem::FileHandleReadonly> const& fileHandle);
+
+        /// The FileHandle will be taken over and freed
+        Md5HashDigest CalculateAndCacheHash(std::unique_ptr<IO::Filesystem::FileHandleReadonly> fileHandle);
+
+    private:
+        void LoadPatchesInfo();
+        std::shared_mutex m_knownPatches_mutex; // will be read-lock when normal access, will be write-lock when adding a new entry
+        std::unordered_map<std::string /*filePath*/, PatchCacheEntry> m_knownPatches;
+};
+
+#define sRealmdPatchCache MaNGOS::Singleton<ClientPatchCache>::Instance()
+
+#endif //MANGOS_CLIENTPATCHCACHE_H

src/realmd/Main.cpp

@@ -26,6 +26,7 @@
 #include "Common.h"
 #include "Database/DatabaseEnv.h"
 #include "RealmList.h"
+#include "ClientPatchCache.h"
 
 #include "Config/Config.h"
 #include "Log.h"
@@ -270,6 +271,8 @@ extern int main(int argc, char **argv)
         return 1;
     }
 
+    (void) sRealmdPatchCache; // <-- This will initialize the singleton. Which will preload all known patches.
+
     // cleanup query
     // set expired bans to inactive
     LoginDatabase.BeginTransaction();