SPX Protocol Support (with compress)

modules/gamelib/const.lua

@@ -165,6 +165,7 @@ GameThingUpgradeClassification = 86
 GameThingCounter = 87
 GameThingClock = 88
 GameThingPodiumItemType = 89
+GameSequencedPackets = 90
 GameLoadSprInsteadProtobuf = 100
 
 TextColors = {

modules/gamelib/protocollogin.lua

@@ -133,9 +133,17 @@ function ProtocolLogin:sendLoginPacket()
     end
 
     self:send(msg)
+
     if g_game.getFeature(GameLoginPacketEncryption) then
         self:enableXteaEncryption()
     end
+
+    if g_game.getFeature(GameSequencedPackets) then
+        scheduleEvent(function()
+            self:enabledSequencedPackets()
+        end, 10)
+    end
+
     self:recv()
 end
 

src/client/const.h

@@ -517,6 +517,7 @@ namespace Otc
         GameThingCounter = 87,
         GameThingClock = 88,
         GameThingPodiumItemType = 89,
+        GameSequencedPackets = 90,
 
         //  others
         GameLoadSprInsteadProtobuf = 100,

src/client/game.cpp

@@ -614,11 +614,10 @@ bool Game::walk(const Otc::Direction direction, bool isKeyDown /*= false*/)
         m_localPlayer->lockWalk();
     }
 
-
     // must cancel follow before any new walk
     if (isFollowing())
         cancelFollow();
-    
+
     m_localPlayer->stopAutoWalk();
 
     g_lua.callGlobalField("g_game", "onWalk", direction);
@@ -1739,6 +1738,7 @@ void Game::setClientVersion(int version)
     }
 
     if (version >= 1290) {
+        enableFeature(Otc::GameSequencedPackets);
         enableFeature(Otc::GameThingClock);
         enableFeature(Otc::GameThingCounter);
         enableFeature(Otc::GameThingPodiumItemType);

src/client/protocolgamesend.cpp

@@ -125,6 +125,9 @@ void ProtocolGame::sendLoginPacket(uint32_t challengeTimestamp, uint8_t challeng
 
     if (g_game.getFeature(Otc::GameLoginPacketEncryption))
         enableXteaEncryption();
+
+    if (g_game.getFeature(Otc::GameSequencedPackets))
+        enabledSequencedPackets();
 }
 
 void ProtocolGame::sendEnterGame()

src/framework/luafunctions.cpp

@@ -775,6 +775,7 @@ void Application::registerLuaFunctions()
     g_lua.bindClassMemberFunction<Protocol>("getXteaKey", &Protocol::getXteaKey);
     g_lua.bindClassMemberFunction<Protocol>("generateXteaKey", &Protocol::generateXteaKey);
     g_lua.bindClassMemberFunction<Protocol>("enableXteaEncryption", &Protocol::enableXteaEncryption);
+    g_lua.bindClassMemberFunction<Protocol>("enabledSequencedPackets", &Protocol::enabledSequencedPackets);
     g_lua.bindClassMemberFunction<Protocol>("enableChecksum", &Protocol::enableChecksum);
 
     // InputMessage

src/framework/net/outputmessage.cpp

@@ -113,6 +113,14 @@ void OutputMessage::writeChecksum()
     m_messageSize += 4;
 }
 
+void OutputMessage::writeSequence(uint32_t sequence)
+{
+    assert(m_headerPos >= 4);
+    m_headerPos -= 4;
+    stdext::writeULE32(m_buffer + m_headerPos, sequence);
+    m_messageSize += 4;
+}
+
 void OutputMessage::writeMessageSize()
 {
     assert(m_headerPos - 2 >= 0);

src/framework/net/outputmessage.h

@@ -62,6 +62,7 @@ class OutputMessage : public LuaObject
     uint8_t* getDataBuffer() { return m_buffer + MAX_HEADER_SIZE; }
 
     void writeChecksum();
+    void writeSequence(uint32_t sequence);
     void writeMessageSize();
 
     friend class Protocol;

src/framework/net/protocol.cpp

@@ -25,14 +25,17 @@
 #include <framework/core/application.h>
 #include "connection.h"
 
-Protocol::Protocol() :m_inputMessage(std::make_shared<InputMessage>()) {}
+Protocol::Protocol() :m_inputMessage(std::make_shared<InputMessage>()) {
+    inflateInit2(&m_zstream, -15);
+}
 
 Protocol::~Protocol()
 {
 #ifndef NDEBUG
     assert(!g_app.isTerminated());
 #endif
     disconnect();
+    inflateEnd(&m_zstream);
 }
 
 void Protocol::connect(const std::string_view host, uint16_t port)
@@ -57,7 +60,9 @@ void Protocol::send(const OutputMessagePtr& outputMessage)
         xteaEncrypt(outputMessage);
 
     // write checksum
-    if (m_checksumEnabled)
+    if (m_sequencedPackets)
+        outputMessage->writeSequence(m_packetNumber++);
+    else if (m_checksumEnabled)
         outputMessage->writeChecksum();
 
     // write message size
@@ -115,8 +120,11 @@ void Protocol::internalRecvData(uint8_t* buffer, uint16_t size)
 
     m_inputMessage->fillBuffer(buffer, size);
 
-    if (m_checksumEnabled && !m_inputMessage->readChecksum()) {
-        g_logger.traceError("got a network message with invalid checksum");
+    bool decompress = false;
+    if (m_sequencedPackets) {
+        decompress = (m_inputMessage->getU32() & 1 << 31);
+    } else if (m_checksumEnabled && !m_inputMessage->readChecksum()) {
+        g_logger.traceError(stdext::format("got a network message with invalid checksum, size: %i", (int)m_inputMessage->getMessageSize()));
         return;
     }
 
@@ -126,6 +134,32 @@ void Protocol::internalRecvData(uint8_t* buffer, uint16_t size)
             return;
         }
     }
+
+    if (decompress) {
+        static uint8_t zbuffer[InputMessage::BUFFER_MAXSIZE];
+
+        m_zstream.next_in = m_inputMessage->getDataBuffer();
+        m_zstream.next_out = zbuffer;
+        m_zstream.avail_in = m_inputMessage->getUnreadSize();
+        m_zstream.avail_out = InputMessage::BUFFER_MAXSIZE;
+
+        int32_t ret = inflate(&m_zstream, Z_FINISH);
+        if (ret != Z_OK && ret != Z_STREAM_END) {
+            g_logger.traceError(stdext::format("failed to decompress message - %s", m_zstream.msg));
+            return;
+        }
+
+        const uint32_t totalSize = m_zstream.total_out;
+        inflateReset(&m_zstream);
+        if (totalSize == 0) {
+            g_logger.traceError(stdext::format("invalid size of decompressed message - %i", totalSize));
+            return;
+        }
+
+        m_inputMessage->fillBuffer(zbuffer, totalSize);
+        m_inputMessage->setMessageSize(m_inputMessage->getHeaderSize() + totalSize);
+    }
+
     onRecv(m_inputMessage);
 }
 

src/framework/net/protocol.h

@@ -28,6 +28,7 @@
 #include "outputmessage.h"
 
 #include <framework/luaengine/luaobject.h>
+#include <zlib.h>
 
  // @bindclass
 class Protocol : public LuaObject
@@ -52,6 +53,7 @@ class Protocol : public LuaObject
     void enableXteaEncryption() { m_xteaEncryptionEnabled = true; }
 
     void enableChecksum() { m_checksumEnabled = true; }
+    void enabledSequencedPackets() { m_sequencedPackets = true; }
 
     virtual void send(const OutputMessagePtr& outputMessage);
     virtual void recv();
@@ -64,6 +66,7 @@ class Protocol : public LuaObject
     virtual void onError(const std::error_code& err);
 
     std::array<uint32_t, 4> m_xteaKey{};
+    uint32_t m_packetNumber{ 0 };
 
 private:
     void internalRecvHeader(uint8_t* buffer, uint16_t size);
@@ -73,7 +76,11 @@ class Protocol : public LuaObject
     void xteaEncrypt(const OutputMessagePtr& outputMessage) const;
 
     bool m_checksumEnabled{ false };
+    bool m_sequencedPackets{ false };
     bool m_xteaEncryptionEnabled{ false };
+
     ConnectionPtr m_connection;
     InputMessagePtr m_inputMessage;
+
+    z_stream m_zstream{};
 };