protocol login at lua

modules/client_entergame/entergame.otmod

@@ -8,6 +8,7 @@ Module
     - client_topmenu
 
   @onLoad: |
+    dofile 'protocollogin'
     dofile 'entergame'
     dofile 'characterlist'
     EnterGame.init()

modules/client_entergame/protocollogin.lua

@@ -0,0 +1,184 @@
+ProtocolLogin = extends(Protocol)
+
+function ProtocolLogin.create()
+  local protocolLogin = ProtocolLogin.internalCreate()
+  return protocolLogin
+end
+
+LoginServerError = 10
+LoginServerMotd = 20
+LoginServerUpdateNeeded = 30
+LoginServerCharacterList = 100
+
+GameExtendedOpcode = 0
+GameProtocolChecksum = 1
+GameAccountNames = 2
+GameChallangeOnLogin = 3
+GameStackposOnTileAddThing = 4
+GamePenalityOnDeath = 5
+GameNameOnNpcTrade = 6
+GameDoubleFreeCapacity = 7
+GameDoubleExperience = 8
+GameTotalCapacity = 9
+GameSkillsBase = 10
+GameAdditionalPlayerStats = 11
+GameIdOnCancelAttack = 12
+GameChannelPlayerList = 13
+GamePlayerMounts = 14
+GameEnvironmentEffect = 15
+GameCreatureType = 16
+GameCreatureAdditionalInfo = 17
+GameCreaturePassableInfo = 18
+GameItemAnimationPhase = 19
+GameTrucatedPingOpcode = 20
+GameReverseCreatureStack = 21
+
+RSA = "109120132967399429278860960508995541528237502902798129123468757937266291492576446330739696001110603907230888610072655818825358503429057592827629436413108566029093628212635953836686562675849720620786279431090218017681061521755056710823876476444260558147179707119674283982419152118103759076030616683978566631413"
+
+function ProtocolLogin:parseError(msg)
+  local errorMessage = msg:getString()
+  signalcall(self.onError, self, errorMessage, false)
+end
+
+function ProtocolLogin:parseMotd(msg)
+  local motd = msg:getString()
+  signalcall(self.onMotd, self, motd)
+end
+
+function ProtocolLogin:parseCharacterList(msg)
+  local characters = {}
+  local charactersCount = msg:getU8()
+  for i=1,charactersCount do
+    local character = {}
+    character[1] = msg:getString()
+    character[2] = msg:getString()
+    character[3] = iptostring(msg:getU32())
+    character[4] = msg:getU16()
+    characters[i] = character
+  end
+  local premDays = msg:getU16()
+  signalcall(self.onCharacterList, self, characters, premDays)
+end
+
+function ProtocolLogin:onOpcode(opcode, msg)
+  if opcode == LoginServerError then
+    self:parseError(msg)
+  elseif opcode == LoginServerMotd then
+    self:parseMotd(msg)
+  elseif opcode == LoginServerUpdateNeeded then
+    return false
+	elseif opcode == LoginServerCharacterList then
+    self:parseCharacterList(msg)
+  else
+    return false
+  end
+  return true
+end
+
+function ProtocolLogin:sendLoginPacket()
+  local msg = OutputMessage.create()
+  msg:addU8(1) -- ClientEnterAccount
+  msg:addU16(1) -- ClientOs
+  msg:addU16(g_game.getClientVersion())
+
+  msg:addU32(g_thingsType.getSignature())
+  msg:addU32(g_sprites.getSignature())
+  msg:addU32(0) -- pic sig
+
+  local paddingBytes = 128
+  msg:addU8(0) -- first RSA byte must be 0
+  paddingBytes = paddingBytes - 1
+
+  -- xtea key
+  self:generateXteaKey()
+  local xteaKey = self:getXteaKey()
+  msg:addU32(xteaKey[1])
+  msg:addU32(xteaKey[2])
+  msg:addU32(xteaKey[3])
+  msg:addU32(xteaKey[4])
+  paddingBytes = paddingBytes - 16
+
+  if g_game.getFeature(GameProtocolChecksum) then
+    self:enableChecksum()
+  end
+
+  if g_game.getFeature(GameAccountNames) then
+    msg:addString(self.accountName)
+    msg:addString(self.accountPassword)
+    paddingBytes = paddingBytes - (4 + string.len(self.accountName) + string.len(self.accountPassword))
+  else
+    msg:addU32(tonumber(self.accountName))
+    msg:addString(self.accountPassword)
+    paddingBytes = paddingBytes - (6 + string.len(self.accountPassword))
+  end
+
+  msg:addPaddingBytes(paddingBytes) -- this crashes without 0
+  msg:encryptRSA(128, RSA)
+
+  self:send(msg)
+  self:enableChecksum()
+  self:recv()
+end
+
+-- void ProtocolLogin::sendLoginPacket()
+-- {
+--     OutputMessagePtr msg(new OutputMessage);
+
+--     msg->addU8(Proto::ClientEnterAccount);
+--     msg->addU16(Proto::ClientOs);
+--     msg->addU16(Proto::ClientVersion);
+
+--     msg->addU32(g_thingsType.getSignature()); // data signature
+--     msg->addU32(g_sprites.getSignature()); // sprite signature
+--     msg->addU32(Proto::PicSignature); // pic signature
+
+--     int paddingBytes = 128;
+--     msg->addU8(0); // first RSA byte must be 0
+--     paddingBytes -= 1;
+
+--     // xtea key
+--     generateXteaKey();
+
+--     msg->addU32(m_xteaKey[0]);
+--     msg->addU32(m_xteaKey[1]);
+--     msg->addU32(m_xteaKey[2]);
+--     msg->addU32(m_xteaKey[3]);
+--     paddingBytes -= 16;
+
+--     if(g_game.getFeature(Otc::GameProtocolChecksum))
+--         enableChecksum();
+
+--     if(g_game.getFeature(Otc::GameAccountNames)) {
+--         msg->addString(m_accountName);
+--         msg->addString(m_accountPassword);
+--         paddingBytes -= 4 + m_accountName.length() + m_accountPassword.length();
+--     } else {
+--         msg->addU32(stdext::from_string<uint32>(m_accountName));
+--         msg->addString(m_accountPassword);
+--         paddingBytes -= 6 + m_accountPassword.length();
+--     }
+
+--     msg->addPaddingBytes(paddingBytes); // complete the 128 bytes for rsa encryption with zeros
+--     msg->encryptRSA(128, Proto::RSA);
+
+--     send(msg);
+--     enableXteaEncryption();
+--     recv();
+-- }
+
+-- events
+function ProtocolLogin:onConnect()
+  self:sendLoginPacket()
+end
+
+-- public functions
+function ProtocolLogin:login(host, port, accountName, accountPassword)
+  if string.len(accountName) == 0 or string.len(accountPassword) == 0 then
+    signalcall(self.onError, self, "You must enter an account name and password.", false)
+  end
+
+  self.accountName = accountName
+  self.accountPassword = accountPassword
+
+  self:connect(host, port)
+end

src/framework/luafunctions.cpp

@@ -46,6 +46,7 @@ void Application::registerLuaFunctions()
     g_lua.bindGlobalFunction("pointtostring", [](const Point& v) { return stdext::to_string(v); });
     g_lua.bindGlobalFunction("colortostring", [](const Color& v) { return stdext::to_string(v); });
     g_lua.bindGlobalFunction("sizetostring", [](const Size& v) { return stdext::to_string(v); });
+    g_lua.bindGlobalFunction("iptostring", [](int v) { return stdext::ip_to_string(v); });
 
     g_lua.registerStaticClass("g_crypt");
     g_lua.bindClassStaticFunction("g_crypt", "encrypt", Crypt::encrypt);
@@ -397,11 +398,17 @@ void Application::registerLuaFunctions()
 
     // Protocol
     g_lua.registerClass<Protocol>();
-    //g_lua.bindClassMemberFunction<Protocol>("connect", &Protocol::connect);
+    g_lua.bindClassStaticFunction<Protocol>("create", []{ return ProtocolPtr(new Protocol); });
+    g_lua.bindClassMemberFunction<Protocol>("connect", &Protocol::connect);
     g_lua.bindClassMemberFunction<Protocol>("disconnect", &Protocol::disconnect);
     g_lua.bindClassMemberFunction<Protocol>("isConnected", &Protocol::isConnected);
     g_lua.bindClassMemberFunction<Protocol>("isConnecting", &Protocol::isConnecting);
-    g_lua.bindClassMemberFunction<Protocol>("send", &Protocol::send);
+    g_lua.bindClassMemberFunction<Protocol>("send", &Protocol::send); // must change to safeSend
+    g_lua.bindClassMemberFunction<Protocol>("recv", &Protocol::recv);
+    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>("enableChecksum", &Protocol::enableChecksum);
 
     // Module
     g_lua.registerClass<Module>();

src/framework/net/protocol.cpp

@@ -151,6 +151,15 @@ void Protocol::generateXteaKey()
     m_xteaKey[3] = unif(eng);
 }
 
+std::vector<int> Protocol::getXteaKey()
+{
+    std::vector<int> xteaKey;
+    xteaKey.resize(4);
+    for(int i = 0; i < 4; ++i)
+        xteaKey[i] = m_xteaKey[i];
+    return xteaKey;
+}
+
 bool Protocol::xteaDecrypt(const InputMessagePtr& inputMessage)
 {
     uint16 encryptedSize = inputMessage->getUnreadSize();
@@ -215,3 +224,8 @@ void Protocol::xteaEncrypt(const OutputMessagePtr& outputMessage)
         readPos = readPos + 2;
     }
 }
+
+void Protocol::onConnect()
+{
+    callLuaField("onConnect");
+}

src/framework/net/protocol.h

@@ -41,20 +41,21 @@ public:
     bool isConnected();
     bool isConnecting();
 
+    void generateXteaKey();
+    std::vector<int> getXteaKey();
+    void enableXteaEncryption() { m_xteaEncryptionEnabled = true; }
+
+    void enableChecksum() { m_checksumEnabled = true; }
+
     virtual void send(const OutputMessagePtr& outputMessage);
+    void recv();
 
     ProtocolPtr asProtocol() { return std::static_pointer_cast<Protocol>(shared_from_this()); }
 
 protected:
-    void recv();
+    virtual void onConnect();
-
+    virtual void onRecv(const InputMessagePtr& inputMessage) {}
-    virtual void onConnect() = 0;
+    virtual void onError(const boost::system::error_code& err) {}
-    virtual void onRecv(const InputMessagePtr& inputMessage) = 0;
-    virtual void onError(const boost::system::error_code& err) = 0;
-
-    void enableChecksum() { m_checksumEnabled = true; }
-    void enableXteaEncryption() { m_xteaEncryptionEnabled = true; }
-    void generateXteaKey();
 
     uint32 m_xteaKey[4];
 

src/otclient/luafunctions.cpp

@@ -167,14 +167,11 @@ void OTClient::registerLuaFunctions()
     g_lua.bindClassStaticFunction("g_game", "getCharacterName", std::bind(&Game::getCharacterName, &g_game));
     g_lua.bindClassStaticFunction("g_game", "getWorldName", std::bind(&Game::getWorldName, &g_game));
     g_lua.bindClassStaticFunction("g_game", "getGMActions", std::bind(&Game::getGMActions, &g_game));
+    g_lua.bindClassStaticFunction("g_game", "getClientVersion", std::bind(&Game::getClientVersion, &g_game));
+    g_lua.bindClassStaticFunction("g_game", "getFeature", std::bind(&Game::getFeature, &g_game, std::placeholders::_1));
 
     g_lua.bindGlobalFunction("getOufitColor", Outfit::getColor);
 
-    g_lua.registerClass<ProtocolLogin, Protocol>();
-    g_lua.bindClassStaticFunction<ProtocolLogin>("create", &ProtocolLogin::create);
-    g_lua.bindClassMemberFunction<ProtocolLogin>("login", &ProtocolLogin::login);
-    g_lua.bindClassMemberFunction<ProtocolLogin>("cancelLogin", &ProtocolLogin::cancelLogin);
-
     g_lua.registerClass<ProtocolGame, Protocol>();
     g_lua.bindClassStaticFunction<ProtocolGame>("create", []{ return ProtocolGamePtr(new ProtocolGame); });
     g_lua.bindClassMemberFunction<ProtocolGame>("login", &ProtocolGame::login);

src/otclient/net/protocollogin.cpp

@@ -28,42 +28,20 @@
 #include <otclient/core/spritemanager.h>
 #include <otclient/core/game.h>
 
-void ProtocolLogin::login(const std::string& host, int port, const std::string& accountName, const std::string& accountPassword)
-{
-    if(accountName.empty() || accountPassword.empty()) {
-        callLuaField("onError", "You must enter an account name and password.");
-        return;
-    }
-
-    m_accountName = accountName;
-    m_accountPassword = accountPassword;
-
-    connect(host, port);
-}
-
-void ProtocolLogin::onConnect()
-{
-    sendLoginPacket();
-}
-
 void ProtocolLogin::onRecv(const InputMessagePtr& msg)
 {
     try {
         while(!msg->eof()) {
             int opcode = msg->getU8();
+
+            // try to parse in lua first
+            if(callLuaField<bool>("onOpcode", opcode, msg))
+                continue;
+
             switch(opcode) {
-            case Proto::LoginServerError:
-                parseError(msg);
-                break;
-            case Proto::LoginServerMotd:
-                parseMOTD(msg);
-                break;
             case Proto::LoginServerUpdateNeeded:
                 callLuaField("onError", "Client needs update.");
                 break;
-            case Proto::LoginServerCharacterList:
-                parseCharacterList(msg);
-                break;
             default:
                 stdext::throw_exception(stdext::format("unknown opcode %d", opcode));
                 break;
@@ -126,34 +104,3 @@ void ProtocolLogin::sendLoginPacket()
     enableXteaEncryption();
     recv();
 }
-
-void ProtocolLogin::parseError(const InputMessagePtr& msg)
-{
-    std::string error = msg->getString();
-    callLuaField("onError", error, false);
-}
-
-void ProtocolLogin::parseMOTD(const InputMessagePtr& msg)
-{
-    std::string motd = msg->getString();
-    callLuaField("onMotd", motd);
-}
-
-void ProtocolLogin::parseCharacterList(const InputMessagePtr& msg)
-{
-    typedef std::tuple<std::string, std::string, std::string, int> CharacterInfo;
-    typedef std::vector<CharacterInfo> CharaterList;
-    CharaterList charList;
-
-    int numCharacters = msg->getU8();
-    for(int i = 0; i < numCharacters; ++i) {
-        std::string name = msg->getString();
-        std::string world = msg->getString();
-        uint32 ip = msg->getU32();
-        uint16 port = msg->getU16();
-        charList.push_back(CharacterInfo(name, world, stdext::ip_to_string(ip), port));
-    }
-    int premDays = msg->getU16();
-
-    callLuaField("onCharacterList", charList, premDays);
-}

src/otclient/net/protocollogin.h

@@ -46,10 +46,6 @@ public:
 private:
     void sendLoginPacket();
 
-    void parseError(const InputMessagePtr& inputMessage);
-    void parseMOTD(const InputMessagePtr& inputMessage);
-    void parseCharacterList(const InputMessagePtr& inputMessage);
-
     std::string m_accountName, m_accountPassword;
 
 };