[svn] * Proper SVN structureinit

--HG--
branch : trunk

1 files changed, 664 insertions, 0 deletions

diff --git a/src/game/WorldSocket.cpp b/src/game/WorldSocket.cpp
new file mode 100644
index 00000000000..d52c0962862
--- /dev/null
+++ b/src/game/WorldSocket.cpp
@@ -0,0 +1,664 @@
+/*
+ * Copyright (C) 2005-2008 MaNGOS <http://www.mangosproject.org/>
+ *
+ * This program 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
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+/** \file
+    \ingroup u2w
+*/
+
+#include "Common.h"
+#include "Log.h"
+#include "Opcodes.h"
+#include "Database/DatabaseEnv.h"
+#include "Auth/Sha1.h"
+#include "WorldPacket.h"
+#include "WorldSocket.h"
+#include "WorldSession.h"
+#include "World.h"
+#include "WorldSocketMgr.h"
+#include "Policies/SingletonImp.h"
+#include "WorldLog.h"
+#include "AddonHandler.h"
+#include "sockets/Utility.h"
+#include "Util.h"
+
+// GCC have alternative #pragma pack(N) syntax and old gcc version not support pack(push,N), also any gcc version not support it at some platform
+#if defined( __GNUC__ )
+#pragma pack(1)
+#else
+#pragma pack(push,1)
+#endif
+
+/// Client Packet Header
+struct ClientPktHeader
+{
+    uint16 size;
+    uint32 cmd;
+};
+
+/// Server Packet Header
+struct ServerPktHeader
+{
+    uint16 size;
+    uint16 cmd;
+};
+
+// GCC have alternative #pragma pack() syntax and old gcc version not support pack(pop), also any gcc version not support it at some platform
+#if defined( __GNUC__ )
+#pragma pack()
+#else
+#pragma pack(pop)
+#endif
+
+#define SOCKET_CHECK_PACKET_SIZE(P,S) if((P).size() < (S)) return SizeError((P),(S));
+
+/// WorldSocket construction and initialization.
+WorldSocket::WorldSocket(ISocketHandler &sh): TcpSocket(sh), _cmd(0), _remaining(0), _session(NULL)
+{
+    _seed = static_cast<uint32>(rand32());
+    m_LastPingMSTime = 0;                                   // first time it will counted as overspeed maybe, but this is not important
+    m_OverSpeedPings = 0;
+
+    if (sWorld.getConfig(CONFIG_TCP_NO_DELAY))
+        SetTcpNodelay(true);
+}
+
+/// WorldSocket destructor
+WorldSocket::~WorldSocket()
+{
+    if(_session)
+        _session->SetSocket(0);
+
+    WorldPacket *packet;
+
+    ///- Go through the to-be-sent queue and delete remaining packets
+    while(!_sendQueue.empty())
+    {
+        packet = _sendQueue.next();
+        delete packet;
+    }
+}
+
+/// Copy the packet to the to-be-sent queue
+void WorldSocket::SendPacket(WorldPacket const* packet)
+{
+    WorldPacket *pck = new WorldPacket(*packet);
+    ASSERT(pck);
+    _sendQueue.add(pck);
+}
+
+/// On client connection
+void WorldSocket::OnAccept()
+{
+    ///- Add the current socket to the list of sockets to be managed (WorldSocketMgr)
+    sWorldSocketMgr.AddSocket(this);
+    Utility::ResolveLocal();
+
+    ///- Send a AUTH_CHALLENGE packet
+    WorldPacket packet( SMSG_AUTH_CHALLENGE, 4 );
+    packet << _seed;
+
+    SendPacket(&packet);
+}
+
+/// Read the client transmitted data
+void WorldSocket::OnRead()
+{
+    TcpSocket::OnRead();
+
+    while(1)
+    {
+        ///- Read the packet header and decipher it (if needed)
+        if (!_remaining)
+        {
+            if (ibuf.GetLength() < 6)
+                break;
+
+            ClientPktHeader hdr;
+
+            ibuf.Read((char *)&hdr, 6);
+            _crypt.DecryptRecv((uint8 *)&hdr, 6);
+
+            _remaining = ntohs(hdr.size) - 4;
+            _cmd = hdr.cmd;
+        }
+
+        if (ibuf.GetLength() < _remaining)
+            break;
+
+        ///- Read the remaining of the packet
+        WorldPacket packet((uint16)_cmd, _remaining);
+
+        packet.resize(_remaining);
+        if(_remaining) ibuf.Read((char*)packet.contents(), _remaining);
+        _remaining = 0;
+
+        ///- If log of world packets is enable, log the incoming packet
+        if( sWorldLog.LogWorld() )
+        {
+            sWorldLog.Log("CLIENT:\nSOCKET: %u\nLENGTH: %u\nOPCODE: %s (0x%.4X)\nDATA:\n",
+                (uint32)GetSocket(),
+                packet.size(),
+                LookupOpcodeName(packet.GetOpcode()),
+                packet.GetOpcode());
+
+            uint32 p = 0;
+            while (p < packet.size())
+            {
+                for (uint32 j = 0; j < 16 && p < packet.size(); j++)
+                    sWorldLog.Log("%.2X ", packet[p++]);
+                sWorldLog.Log("\n");
+            }
+            sWorldLog.Log("\n\n");
+        }
+
+        ///- If the packet is PING, KEEP_ALIVE or AUTH_SESSION, handle immediately
+        switch (_cmd)
+        {
+            case CMSG_KEEP_ALIVE:
+                break;                                      // just ignore, network connectivity timeout preventing
+            case CMSG_PING:
+            {
+                _HandlePing(packet);
+                break;
+            }
+            case CMSG_AUTH_SESSION:
+            {
+                _HandleAuthSession(packet);
+                break;
+            }
+            default:
+            {
+                ///- Else, put it in the world session queue for this user (need to be already authenticated)
+                if (_session)
+                    _session->QueuePacket(packet);
+                else
+                    sLog.outDetail("Received out of place packet with cmdid 0x%.4X", _cmd);
+                break;
+            }
+        }
+    }
+}
+
+/// On socket closing
+void WorldSocket::CloseSocket()
+{
+    ///- Set CloseAndDelete flag for TcpSocket class
+    SetCloseAndDelete(true);
+
+    ///- Set _session to NULL. Prevent crashes
+    _session = NULL;
+}
+
+/// On socket deleting
+void WorldSocket::OnDelete()
+{
+    ///- Stop sending remaining data through this socket
+    if (_session)
+    {
+        _session->SetSocket(NULL);
+        // Session deleted from World session list at socket==0, This is only back reference from socket to session.
+        _session = NULL;
+    }
+
+    ///- Remove the socket from the WorldSocketMgr list
+    sWorldSocketMgr.RemoveSocket(this);
+
+    ///- Removes socket from player queue
+    sWorld.RemoveQueuedPlayer(this);
+}
+
+/// Handle the client authentication packet
+void WorldSocket::_HandleAuthSession(WorldPacket& recvPacket)
+{
+    uint8 digest[20];
+    uint32 clientSeed;
+    uint32 unk2;
+    uint32 BuiltNumberClient;
+    uint32 id, security;
+    bool tbc = false;
+    std::string account;
+    Sha1Hash sha1;
+    BigNumber v, s, g, N, x, I;
+    WorldPacket packet, SendAddonPacked;
+
+    BigNumber K;
+
+    SOCKET_CHECK_PACKET_SIZE(recvPacket,4+4+1+4+20);
+
+    ///- Read the content of the packet
+    recvPacket >> BuiltNumberClient;                        // for now no use
+    recvPacket >> unk2;
+    recvPacket >> account;
+
+    // recheck size
+    SOCKET_CHECK_PACKET_SIZE(recvPacket,4+4+(account.size()+1)+4+20);
+
+    recvPacket >> clientSeed;
+    recvPacket.read(digest, 20);
+
+    sLog.outDebug("Auth: client %u, unk2 %u, account %s, clientseed %u", BuiltNumberClient, unk2, account.c_str(), clientSeed);
+
+    ///- Normalize account name
+    //utf8ToUpperOnlyLatin(account); -- client already send account in expected form
+
+    ///- Get the account information from the realmd database
+    std::string safe_account = account;                     // Duplicate, else will screw the SHA hash verification below
+    loginDatabase.escape_string(safe_account);
+    //No SQL injection, username escaped.
+    //                                                 0   1        2           3        4       5              6  7  8    9         10
+    QueryResult *result = loginDatabase.PQuery("SELECT id, gmlevel, sessionkey, last_ip, locked, sha_pass_hash, v, s, tbc, mutetime, locale FROM account WHERE username = '%s'", safe_account.c_str());
+
+    ///- Stop if the account is not found
+    if ( !result )
+    {
+        packet.Initialize( SMSG_AUTH_RESPONSE, 1 );
+        packet << uint8( AUTH_UNKNOWN_ACCOUNT );
+        SendPacket( &packet );
+        sLog.outDetail( "SOCKET: Sent Auth Response (unknown account)." );
+        return;
+    }
+
+    Field* fields = result->Fetch();
+
+    tbc = fields[8].GetUInt8() && sWorld.getConfig(CONFIG_EXPANSION) > 0;
+
+    N.SetHexStr("894B645E89E1535BBDAD5B8B290650530801B18EBFBF5E8FAB3C82872A3E9BB7");
+    g.SetDword(7);
+    I.SetHexStr(fields[5].GetString());
+
+    //In case of leading zeros in the I hash, restore them
+    uint8 mDigest[SHA_DIGEST_LENGTH];
+    memset(mDigest,0,SHA_DIGEST_LENGTH);
+    if (I.GetNumBytes() <= SHA_DIGEST_LENGTH)
+        memcpy(mDigest,I.AsByteArray(),I.GetNumBytes());
+
+    std::reverse(mDigest,mDigest+SHA_DIGEST_LENGTH);
+
+    s.SetHexStr(fields[7].GetString());
+    sha1.UpdateData(s.AsByteArray(), s.GetNumBytes());
+    sha1.UpdateData(mDigest, SHA_DIGEST_LENGTH);
+    sha1.Finalize();
+    x.SetBinary(sha1.GetDigest(), sha1.GetLength());
+    v = g.ModExp(x, N);
+
+    const char* sStr = s.AsHexStr();                        //Must be freed by OPENSSL_free()
+    const char* vStr = v.AsHexStr();                        //Must be freed by OPENSSL_free()
+    const char* vold = fields[6].GetString();
+    sLog.outDebug("SOCKET: (s,v) check s: %s v_old: %s v_new: %s", sStr, vold, vStr );
+    loginDatabase.PExecute("UPDATE account SET v = '0', s = '0' WHERE username = '%s'", safe_account.c_str());
+    if ( !vold || strcmp( vStr, vold ) )
+    {
+        packet.Initialize( SMSG_AUTH_RESPONSE, 1 );
+        packet << uint8( AUTH_UNKNOWN_ACCOUNT );
+        SendPacket( &packet );
+        sLog.outDetail( "SOCKET: User not logged.");
+        delete result;
+        OPENSSL_free((void*)sStr);
+        OPENSSL_free((void*)vStr);
+        return;
+    }
+    OPENSSL_free((void*)sStr);
+    OPENSSL_free((void*)vStr);
+
+    ///- Re-check ip locking (same check as in realmd).
+    if(fields[4].GetUInt8() == 1)                           // if ip is locked
+    {
+        if ( strcmp(fields[3].GetString(),GetRemoteAddress().c_str()) )
+        {
+            packet.Initialize( SMSG_AUTH_RESPONSE, 1 );
+            packet << uint8( AUTH_FAILED );
+            SendPacket( &packet );
+
+            sLog.outDetail( "SOCKET: Sent Auth Response (Account IP differs)." );
+            delete result;
+            return;
+        }
+    }
+
+    id = fields[0].GetUInt32();
+    security = fields[1].GetUInt16();
+    K.SetHexStr(fields[2].GetString());
+    time_t mutetime = time_t(fields[9].GetUInt64());
+
+    LocaleConstant locale = LocaleConstant(fields[10].GetUInt8());
+    if (locale>=MAX_LOCALE)
+        locale=LOCALE_enUS;
+
+    delete result;
+
+    ///- Re-check account ban (same check as in realmd) /// TO DO: why on earth do 2 checks for same thing?
+    QueryResult *banresult = loginDatabase.PQuery("SELECT bandate,unbandate FROM account_banned WHERE id = '%u' AND active = 1", id);
+    if(banresult)                                           // if account banned
+    {
+        packet.Initialize( SMSG_AUTH_RESPONSE, 1 );
+        packet << uint8( AUTH_BANNED );
+        SendPacket( &packet );
+
+        sLog.outDetail( "SOCKET: Sent Auth Response (Account banned)." );
+        delete banresult;
+        return;
+    }
+
+    ///- Check locked state for server
+    AccountTypes allowedAccountType = sWorld.GetPlayerSecurityLimit();
+    if( allowedAccountType > SEC_PLAYER && security < allowedAccountType)
+    {
+        WorldPacket Packet(SMSG_AUTH_RESPONSE, 1);
+        Packet << uint8(AUTH_UNAVAILABLE);
+        SendPacket(&Packet);
+        return;
+    }
+
+    ///- kick already loaded player with same account (if any) and remove session
+    ///- if player is in loading and want to load again, return
+    if(!sWorld.RemoveSession(id))
+    {
+        return;
+    }
+
+    ///- Check that Key and account name are the same on client and server
+    Sha1Hash sha;
+
+    uint32 t = 0;
+    uint32 seed = _seed;
+
+    sha.UpdateData(account);
+    sha.UpdateData((uint8 *)&t, 4);
+    sha.UpdateData((uint8 *)&clientSeed, 4);
+    sha.UpdateData((uint8 *)&seed, 4);
+    sha.UpdateBigNumbers(&K, NULL);
+    sha.Finalize();
+
+    if (memcmp(sha.GetDigest(), digest, 20))
+    {
+        packet.Initialize( SMSG_AUTH_RESPONSE, 1 );
+        packet << uint8( AUTH_FAILED );
+        SendPacket( &packet );
+
+        sLog.outDetail( "SOCKET: Sent Auth Response (authentication failed)." );
+        return;
+    }
+
+    ///- Initialize the encryption with the Key
+    _crypt.SetKey(&K);
+    _crypt.Init();
+
+    ///- Send 'Auth is ok'
+    packet.Initialize( SMSG_AUTH_RESPONSE, 1+4+1+4+1 );
+    packet << uint8( AUTH_OK );
+    packet << uint32(0);                                    // unknown random value...
+    packet << uint8(0);                                     // can be 0 and 2
+    packet << uint32(0);                                    // const 0
+    packet << uint8(tbc ? 1 : 0);                           // 0 - normal, 1 - TBC, must be set in database manually for each account
+    SendPacket(&packet);
+
+    ///- Create a new WorldSession for the player and add it to the World
+    _session = new WorldSession(id, this,security,tbc,mutetime,locale);
+    sWorld.AddSession(_session);
+
+    if(sLog.IsOutDebug())                                   // optimize disabled debug output
+    {
+        sLog.outDebug( "SOCKET: Client '%s' authenticated successfully.", account.c_str() );
+        sLog.outDebug( "Account: '%s' Logged in from IP %s.", account.c_str(), GetRemoteAddress().c_str());
+    }
+
+    ///- Update the last_ip in the database
+    //No SQL injection, username escaped.
+    std::string address = GetRemoteAddress();
+    loginDatabase.escape_string(address);
+    loginDatabase.PExecute("UPDATE account SET last_ip = '%s' WHERE username = '%s'",address.c_str(), safe_account.c_str());
+
+    // do small delay (10ms) at accepting successful authed connection to prevent dropping packets by client
+    // don't must harm anyone (let login ~100 accounts in 1 sec ;) )
+    #ifdef WIN32
+    Sleep(10);
+    #else
+    ZThread::Thread::sleep(10);
+    #endif
+
+    ///- Check that we do not exceed the maximum number of online players in the realm
+    uint32 Sessions  = sWorld.GetActiveAndQueuedSessionCount();
+    uint32 pLimit    = sWorld.GetPlayerAmountLimit();
+    uint32 QueueSize = sWorld.GetQueueSize();               //number of players in the queue
+    bool   inQueue   = false;
+    --Sessions;                                             //so we don't count the user trying to login as a session and queue the socket that we are using
+
+    if( pLimit >  0 && Sessions >= pLimit && security == SEC_PLAYER )
+    {
+        sWorld.AddQueuedPlayer(this);
+        SendAuthWaitQue(sWorld.GetQueuePos(this));
+        sWorld.UpdateMaxSessionCounters();
+        sLog.outDetail( "PlayerQueue: %s is in Queue Position (%u).",safe_account.c_str(),++QueueSize);
+        inQueue = true;
+    }
+
+    ///- Create and send the Addon packet
+    if(sAddOnHandler.BuildAddonPacket(&recvPacket, &SendAddonPacked))
+        SendPacket(&SendAddonPacked);
+
+    if(inQueue)
+        return;
+
+    sWorld.UpdateMaxSessionCounters();
+
+    // Updates the population
+    if (pLimit > 0)
+    {
+        float popu = sWorld.GetActiveSessionCount();        //updated number of users on the server
+        popu /= pLimit;
+        popu *= 2;
+        loginDatabase.PExecute("UPDATE realmlist SET population = '%f' WHERE id = '%d'",popu,realmID);
+        sLog.outDetail( "Server Population (%f).",popu);
+    }
+
+    return;
+}
+
+/// Handle the Ping packet
+void WorldSocket::_HandlePing(WorldPacket& recvPacket)
+{
+    uint32 ping;
+    uint32 latency;
+
+    CHECK_PACKET_SIZE(recvPacket,8);
+
+    ///- Get the ping packet content
+    recvPacket >> ping;
+    recvPacket >> latency;
+
+    if (_session )
+        _session->SetLatency(latency);
+
+    ///- check ping speed for players
+    if(_session && _session->GetSecurity() == SEC_PLAYER)
+    {
+        uint32 cur_mstime = getMSTime();
+
+        // can overflow and start from 0
+        uint32 diff_mstime = getMSTimeDiff(m_LastPingMSTime,cur_mstime);
+        m_LastPingMSTime = cur_mstime;
+        if(diff_mstime < 27000)                             // should be 30000 (=30 secs), add little tolerance
+        {
+            ++m_OverSpeedPings;
+
+            uint32 max_count = sWorld.getConfig(CONFIG_MAX_OVERSPEED_PINGS);
+            if(max_count && m_OverSpeedPings > max_count)
+            {
+                sLog.outBasic("Player %s from account id %u kicked for overspeed ping packets from client (non-playable connection lags or cheating) ",_session->GetPlayerName(),_session->GetAccountId());
+                _session->KickPlayer();
+                return;
+            }
+        }
+        else
+            m_OverSpeedPings = 0;
+
+    }
+
+    ///- And put the pong answer in the to-be-sent queue
+    WorldPacket packet( SMSG_PONG, 4 );
+    packet << ping;
+    SendPacket(&packet);
+
+    return;
+}
+
+/// Handle the update order for the socket
+void WorldSocket::SendSinglePacket()
+{
+    WorldPacket *packet;
+    ServerPktHeader hdr;
+
+    ///- If we have packet to send
+    if (!_sendQueue.empty())
+    {
+        packet = _sendQueue.next();
+
+        hdr.size = ntohs((uint16)packet->size() + 2);
+        hdr.cmd = packet->GetOpcode();
+
+        if( sWorldLog.LogWorld() )
+        {
+            sWorldLog.Log("SERVER:\nSOCKET: %u\nLENGTH: %u\nOPCODE: %s (0x%.4X)\nDATA:\n",
+                (uint32)GetSocket(),
+                packet->size(),
+                LookupOpcodeName(packet->GetOpcode()),
+                packet->GetOpcode());
+
+            uint32 p = 0;
+            while (p < packet->size())
+            {
+                for (uint32 j = 0; j < 16 && p < packet->size(); j++)
+                    sWorldLog.Log("%.2X ", (*packet)[p++]);
+
+                sWorldLog.Log("\n");
+            }
+
+            sWorldLog.Log("\n\n");
+        }
+
+        ///- Encrypt (if needed) the header
+        _crypt.EncryptSend((uint8*)&hdr, 4);
+
+        ///- Send the header and body to the client
+        TcpSocket::SendBuf((char*)&hdr, 4);
+        if(!packet->empty()) TcpSocket::SendBuf((char*)packet->contents(), packet->size());
+
+        delete packet;
+    }
+}
+
+void WorldSocket::Update(time_t diff)
+{
+    const uint32 SEND_PACKETS_MAX = 100;
+    const uint32 SEND_BUFFER_SIZE = 1024;
+
+    uint8 sendBuffer[SEND_BUFFER_SIZE];
+
+    while (!_sendQueue.empty())
+    {
+        bool haveBigPacket = false;
+        uint32 bufferSize = 0;
+
+        ///- While we have packets to send
+        for (uint32 packetCount = 0; (packetCount < SEND_PACKETS_MAX) && !_sendQueue.empty(); packetCount++)
+        {
+            ServerPktHeader *hdr = (ServerPktHeader*)&sendBuffer[bufferSize];
+
+            // check merge possibility.
+            WorldPacket *front = _sendQueue.front();
+            uint32 packetSize = front->size();
+
+            if ((sizeof(*hdr) + packetSize) > SEND_BUFFER_SIZE)
+            {
+                haveBigPacket = true;
+                break;
+            }
+
+            if ((bufferSize + sizeof(*hdr) + packetSize) > sizeof(sendBuffer))
+                break;
+
+            // can be merged
+            WorldPacket *packet = _sendQueue.next();
+
+            hdr->size = ntohs((uint16)packetSize + 2);
+            hdr->cmd = packet->GetOpcode();
+
+            if( sWorldLog.LogWorld() )
+            {
+                sWorldLog.Log("SERVER:\nSOCKET: %u\nLENGTH: %u\nOPCODE: %s (0x%.4X)\nDATA:\n",
+                    (uint32)GetSocket(),
+                    packetSize,
+                    LookupOpcodeName(packet->GetOpcode()),
+                    packet->GetOpcode());
+
+                uint32 p = 0;
+                while (p < packetSize)
+                {
+                    for (uint32 j = 0; j < 16 && p < packetSize; j++)
+                        sWorldLog.Log("%.2X ", (*packet)[p++]);
+
+                    sWorldLog.Log("\n");
+                }
+
+                sWorldLog.Log("\n\n");
+            }
+
+            ///- Encrypt (if needed) the header
+            _crypt.EncryptSend((uint8*)hdr, sizeof(*hdr));
+            bufferSize += sizeof(*hdr);
+
+            if (packetSize)
+            {
+                memcpy(&sendBuffer[bufferSize], packet->contents(), packetSize);
+                bufferSize += packetSize;
+            }
+
+            ///- Send the header and body to the client
+            delete packet;
+        }
+
+        // send merged packets
+        if (bufferSize) TcpSocket::SendBuf((char*)sendBuffer, bufferSize);
+        // send too big non-merged packet
+        if (haveBigPacket) SendSinglePacket();
+    }
+}
+
+/// Handle the authentication waiting queue (to be completed)
+void WorldSocket::SendAuthWaitQue(uint32 position)
+{
+    if(position == 0)
+    {
+        WorldPacket packet( SMSG_AUTH_RESPONSE, 1 );
+        packet << uint8( AUTH_OK );
+        SendPacket(&packet);
+    }
+    else
+    {
+        WorldPacket packet( SMSG_AUTH_RESPONSE, 5 );
+        packet << uint8( AUTH_WAIT_QUEUE );
+        packet << uint32 (position);                        //amount of players in queue
+        SendPacket(&packet);
+    }
+}
+
+void WorldSocket::SizeError(WorldPacket const& packet, uint32 size) const
+{
+    sLog.outError("Client send packet %s (%u) with size %u but expected %u (attempt crash server?), skipped",
+        LookupOpcodeName(packet.GetOpcode()),packet.GetOpcode(),packet.size(),size);
+}