src/game/WorldSocket.cpp

   1 /*
   2  * Copyright (C) 2005,2006 MaNGOS <http://www.mangosproject.org/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include "Common.h"
  20 #include "Log.h"
  21 #include "Opcodes.h"
  22 #include "Config/ConfigEnv.h"
  23 #include "Database/DatabaseEnv.h"
  24 #include "Auth/Sha1.h"
  25 #include "WorldPacket.h"
  26 #include "WorldSocket.h"
  27 #include "WorldSession.h"
  28 #include "World.h"
  29 #include "WorldSocketMgr.h"
  30 #include "NameTables.h"
  31 #include "Policies/SingletonImp.h"
  32 #include "WorldLog.h"
  33 #include "AddonHandler.h"
  34 #include "zlib/zlib.h"
  35 #include "../realmd/AuthCodes.h"
  36 #include <cwctype>                                          // needs for towupper
  37
  38 // Only GCC 4.1.0 and later support #pragma pack(push,1) syntax
  39 #if __GNUC__ && (GCC_MAJOR < 4 || GCC_MAJOR == 4 && GCC_MINOR < 1)
  40 #pragma pack(1)
  41 #else
  42 #pragma pack(push,1)
  43 #endif
  44
  45 struct ClientPktHeader
  46 {
  47     uint16 size;
  48     uint32 cmd;
  49 };
  50
  51 struct ServerPktHeader
  52 {
  53     uint16 size;
  54     uint16 cmd;
  55 };
  56
  57 // Only GCC 4.1.0 and later support #pragma pack(pop) syntax
  58 #if __GNUC__ && (GCC_MAJOR < 4 || GCC_MAJOR == 4 && GCC_MINOR < 1)
  59 #pragma pack()
  60 #else
  61 #pragma pack(pop)
  62 #endif
  63
  64 WorldSocket::WorldSocket(SocketHandler &sh): TcpSocket(sh), _cmd(0), _remaining(0), _session(NULL)
  65 {
  66     _seed = _GetSeed();
  67 }
  68
  69 WorldSocket::~WorldSocket()
  70 {
  71     WorldPacket *packet;
  72
  73     while(!_sendQueue.empty())
  74     {
  75         packet = _sendQueue.next();
  76         delete packet;
  77     }
  78 }
  79
  80 uint32 WorldSocket::_GetSeed()
  81 {
  82     return 0xDEADBABE;
  83 }
  84
  85 void WorldSocket::SendPacket(WorldPacket* packet)
  86 {
  87     WorldPacket *pck = new WorldPacket(*packet);
  88     ASSERT(pck);
  89
  90     _sendQueue.add(pck);
  91 }
  92
  93 void WorldSocket::OnAccept()
  94 {
  95     WorldPacket packet;
  96
  97     sWorldSocketMgr.AddSocket(this);
  98
  99     packet.Initialize( SMSG_AUTH_CHALLENGE );
 100     packet << _seed;
 101
 102     SendPacket(&packet);
 103 }
 104
 105 void WorldSocket::OnRead()
 106 {
 107     TcpSocket::OnRead();
 108
 109     while(1)
 110     {
 111         if (!_remaining)
 112         {
 113             if (ibuf.GetLength() < 6)
 114                 break;
 115
 116             ClientPktHeader hdr;
 117
 118             ibuf.Read((char *)&hdr, 6);
 119             _crypt.DecryptRecv((uint8 *)&hdr, 6);
 120
 121             _remaining = ntohs(hdr.size) - 4;
 122             _cmd = hdr.cmd;
 123         }
 124
 125         if (ibuf.GetLength() < _remaining)
 126             break;
 127
 128         WorldPacket packet;
 129
 130         packet.resize(_remaining);
 131         packet.SetOpcode((uint16)_cmd);
 132         if(_remaining) ibuf.Read((char*)packet.contents(), _remaining);
 133
 134         if( sWorldLog.LogWorld() )
 135         {
 136             sWorldLog.Log("CLIENT:\nSOCKET: %u\nLENGTH: %u\nOPCODE: %s (0x%.4X)\nDATA:\n",
 137                 (uint32)GetSocket(),
 138                 _remaining,
 139                 LookupName(packet.GetOpcode(), g_worldOpcodeNames),
 140                 packet.GetOpcode());
 141
 142             uint32 p = 0;
 143             while (p < packet.size())
 144             {
 145                 for (uint32 j = 0; j < 16 && p < packet.size(); j++)
 146                     sWorldLog.Log("%.2X ", packet[p++]);
 147
 148                 sWorldLog.Log("\n");
 149             }
 150
 151             sWorldLog.Log("\n\n");
 152         }
 153
 154         _remaining = 0;
 155
 156         switch (_cmd)
 157         {
 158             case CMSG_PING:
 159             {
 160                 _HandlePing(packet);
 161                 break;
 162             }
 163             case CMSG_AUTH_SESSION:
 164             {
 165                 _HandleAuthSession(packet);
 166                 break;
 167             }
 168             default:
 169             {
 170                 if (_session)
 171                     _session->QueuePacket(packet);
 172                 else
 173                     sLog.outDetail("Received out of place packet with cmdid 0x%.4X", _cmd);
 174             }
 175         }
 176     }
 177 }
 178
 179 void WorldSocket::OnDelete()
 180 {
 181     if (_session)
 182     {
 183         _session->SetSocket(0);
 184         _session = 0;
 185     }
 186
 187     sWorldSocketMgr.RemoveSocket(this);
 188 }
 189
 190 void WorldSocket::_HandleAuthSession(WorldPacket& recvPacket)
 191 {
 192     uint8 digest[20];
 193     uint32 clientSeed;
 194     uint32 unk2;
 195     uint32 BuiltNumberClient;
 196     uint32 id, security;
 197     std::string account;
 198     Sha1Hash I;
 199     Sha1Hash sha1;
 200     BigNumber v, s, g, N, x;
 201     std::string password;
 202     WorldPacket packet, SendAddonPacked;
 203
 204     BigNumber K;
 205
 206     try
 207     {
 208         recvPacket >> BuiltNumberClient;                    // for now no use
 209         recvPacket >> unk2;
 210         recvPacket >> account;
 211         recvPacket >> clientSeed;
 212         recvPacket.read(digest, 20);
 213     }
 214     catch(ByteBuffer::error &)
 215     {
 216         sLog.outError("WorldSocket::_HandleAuthSession Get Incomplete packet");
 217         return;
 218     }
 219
 220     loginDatabase.escape_string(account);
 221
 222     QueryResult *result = loginDatabase.PQuery("SELECT `id`,`gmlevel`,`sessionkey`,`last_ip`,`locked`, `password`, `v`, `s` FROM `account` WHERE `username` = '%s'", account.c_str());
 223
 224     if ( !result )
 225     {
 226
 227         packet.Initialize( SMSG_AUTH_RESPONSE );
 228         packet << uint8( AUTH_UNKNOWN_ACCOUNT );
 229         SendPacket( &packet );
 230
 231         sLog.outDetail( "SOCKET: Sent Auth Response (unknown account)." );
 232         return;
 233     }
 234
 235     N.SetHexStr("894B645E89E1535BBDAD5B8B290650530801B18EBFBF5E8FAB3C82872A3E9BB7");
 236     g.SetDword(7);
 237     password = (*result)[5].GetString();
 238     std::transform(password.begin(), password.end(), password.begin(), std::towupper);
 239
 240     s.SetHexStr((*result)[7].GetString());
 241     std::string sI = account + ":" + password;
 242     I.UpdateData(sI);
 243     I.Finalize();
 244     sha1.UpdateData(s.AsByteArray(), s.GetNumBytes());
 245     sha1.UpdateData(I.GetDigest(), 20);
 246     sha1.Finalize();
 247     x.SetBinary(sha1.GetDigest(), sha1.GetLength());
 248     v = g.ModExp(x, N);
 249
 250     sLog.outDebug("SOCKET: (s,v) check s: %s v_old: %s v_new: %s", s.AsHexStr(), (*result)[6].GetString(), v.AsHexStr() );
 251     if ( strcmp(v.AsHexStr(),(*result)[6].GetString() ) )
 252     {
 253         packet.Initialize( SMSG_AUTH_RESPONSE );
 254         packet << uint8( AUTH_UNKNOWN_ACCOUNT );
 255         SendPacket( &packet );
 256         sLog.outDetail( "SOCKET: User not logged.");
 257         delete result;
 258         return;
 259     }
 260
 261     id = (*result)[0].GetUInt32();
 262     security = (*result)[1].GetUInt16();
 263     K.SetHexStr((*result)[2].GetString());
 264
 265     delete result;
 266
 267     uint32 num = sWorld.GetSessionCount();
 268     if (sWorld.GetPlayerLimit() > 0 && num > sWorld.GetPlayerLimit() && security == 0)
 269     {
 270
 271         packet.Initialize( SMSG_AUTH_RESPONSE );
 272         //packet << uint8( 21 );
 273         packet << uint8( CSTATUS_FULL);
 274         SendPacket( &packet );
 275         sLog.outBasic( "SOCKET: Sent Auth Response (server full)." );
 276         return;
 277     }
 278
 279     WorldSession *session = sWorld.FindSession( id );
 280     if( session )
 281     {
 282         packet.Initialize( SMSG_AUTH_RESPONSE );
 283         //packet << uint8( 13 );
 284         packet << uint8( AUTH_ALREADY_ONLINE );
 285         SendPacket( &packet );
 286
 287         sLog.outDetail( "SOCKET: Sent Auth Response (already connected)." );
 288
 289         session->LogoutPlayer(false);
 290
 291         return;
 292     }
 293
 294     Sha1Hash sha;
 295
 296     uint32 t = 0;
 297     uint32 seed = _seed;
 298
 299     sha.UpdateData(account);
 300     sha.UpdateData((uint8 *)&t, 4);
 301     sha.UpdateData((uint8 *)&clientSeed, 4);
 302     sha.UpdateData((uint8 *)&seed, 4);
 303     sha.UpdateBigNumbers(&K, NULL);
 304     sha.Finalize();
 305
 306     if (memcmp(sha.GetDigest(), digest, 20))
 307     {
 308
 309         packet.Initialize( SMSG_AUTH_RESPONSE );
 310         //packet << uint8( 21 );
 311         packet << uint8( AUTH_FAILED );
 312
 313         SendPacket( &packet );
 314
 315         sLog.outDetail( "SOCKET: Sent Auth Response (authentification failed)." );
 316         return;
 317     }
 318
 319     _crypt.SetKey(K.AsByteArray(), 40);
 320     _crypt.Init();
 321
 322     //Send Auth is okey
 323     packet.Initialize( SMSG_AUTH_RESPONSE );
 324     packet << uint8( AUTH_OK );                             //0x0C
 325     //packet << uint8( 0xB0 ); - redundent
 326     //packet << uint8( 0x09 );
 327     //packet << uint8( 0x02 );
 328     //packet << uint8( 0x00 );
 329     //packet << uint8( 0x02 );
 330     //packet << uint32( 0x0 );
 331
 332     SendPacket(&packet);
 333
 334     _session = new WorldSession(id, this);
 335
 336     ASSERT(_session);
 337     _session->SetSecurity(security);
 338     sWorld.AddSession(_session);
 339
 340     sLog.outBasic( "SOCKET: Client '%s' authed successfully.", account.c_str() );
 341     sLog.outString( "Account: '%s' Login.", account.c_str() );
 342
 343     // do small delay (10ms) at accepting successful authed connection to prevent droping packets by client
 344     // don't must harm anyone (let login ~100 accounts in 1 sec ;) )
 345     #ifdef WIN32
 346     Sleep(10);
 347     #endif
 348     //! Handled Addons
 349
 350     //Create Addon Packet
 351     //sAddOnHandler.BuildAddonPacket(&recvPacket, &SendAddonPacked, recvPacket.rpos());
 352     SendAddonPacked.Initialize(SMSG_ADDON_INFO);            // fix banned addon
 353     SendAddonPacked << uint8( 0x41 );                       // fix banned addon
 354     SendAddonPacked << uint8( 0x64 );                       // fix banned addon
 355     SendAddonPacked << uint8( 0x64 );                       // fix banned addon
 356     SendAddonPacked << uint8( 0x6f );                       // fix banned addon
 357     SendAddonPacked << uint8( 0x6e );                       // fix banned addon
 358     SendAddonPacked << uint8( 0x00 );                       // fix banned addon
 359     SendPacket(&SendAddonPacked);
 360
 361     return;
 362 }
 363
 364 void WorldSocket::_HandlePing(WorldPacket& recvPacket)
 365 {
 366     WorldPacket packet;
 367     uint32 ping;
 368
 369     try
 370     {
 371         recvPacket >> ping;
 372     }
 373     catch(ByteBuffer::error &)
 374     {
 375         sLog.outDetail("Incomplete packet");
 376         return;
 377     }
 378
 379     packet.Initialize( SMSG_PONG );
 380     packet << ping;
 381     SendPacket(&packet);
 382
 383     return;
 384 }
 385
 386 void WorldSocket::Update(time_t diff)
 387 {
 388     WorldPacket *packet;
 389     ServerPktHeader hdr;
 390
 391     while(!_sendQueue.empty())
 392     {
 393         packet = _sendQueue.next();
 394
 395         hdr.size = ntohs((uint16)packet->size() + 2);
 396         hdr.cmd = packet->GetOpcode();
 397
 398         if( sWorldLog.LogWorld() )
 399         {
 400             sWorldLog.Log("SERVER:\nSOCKET: %u\nLENGTH: %u\nOPCODE: %s (0x%.4X)\nDATA:\n",
 401                 (uint32)GetSocket(),
 402                 packet->size(),
 403                 LookupName(packet->GetOpcode(), g_worldOpcodeNames),
 404                 packet->GetOpcode());
 405
 406             uint32 p = 0;
 407             while (p < packet->size())
 408             {
 409                 for (uint32 j = 0; j < 16 && p < packet->size(); j++)
 410                     sWorldLog.Log("%.2X ", (*packet)[p++]);
 411
 412                 sWorldLog.Log("\n");
 413             }
 414
 415             sWorldLog.Log("\n\n");
 416         }
 417
 418         _crypt.EncryptSend((uint8*)&hdr, 4);
 419
 420         TcpSocket::SendBuf((char*)&hdr, 4);
 421         if(packet->size()) TcpSocket::SendBuf((char*)packet->contents(), packet->size());
 422
 423         delete packet;
 424     }
 425 }
 426
 427 void WorldSocket::SendAuthWaitQue(uint32 PlayersInQue)
 428 {
 429     WorldPacket packet;
 430     packet.Initialize( SMSG_AUTH_RESPONSE );
 431     packet << uint8( AUTH_WAIT_QUEUE );
 432     packet << uint32 (0x00);                                //unknown
 433     packet << uint32 (0x00);                                //unknown
 434     packet << uint8 (0x00);                                 //unknown
 435     packet << uint32 (PlayersInQue);                        //amount of players in que
 436     SendPacket(&packet);
 437 }