src/game/WorldSocket.cpp

   1 /*
   2  * Copyright (C) 2005-2010 MaNGOS <http://getmangos.com/>
   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 <ace/Message_Block.h>
  20 #include <ace/OS_NS_string.h>
  21 #include <ace/OS_NS_unistd.h>
  22 #include <ace/os_include/arpa/os_inet.h>
  23 #include <ace/os_include/netinet/os_tcp.h>
  24 #include <ace/os_include/sys/os_types.h>
  25 #include <ace/os_include/sys/os_socket.h>
  26 #include <ace/OS_NS_string.h>
  27 #include <ace/Reactor.h>
  28 #include <ace/Auto_Ptr.h>
  29
  30 #include "WorldSocket.h"
  31 #include "Common.h"
  32
  33 #include "Util.h"
  34 #include "World.h"
  35 #include "WorldPacket.h"
  36 #include "SharedDefines.h"
  37 #include "ByteBuffer.h"
  38 #include "Opcodes.h"
  39 #include "Database/DatabaseEnv.h"
  40 #include "Auth/BigNumber.h"
  41 #include "Auth/Sha1.h"
  42 #include "WorldSession.h"
  43 #include "WorldSocketMgr.h"
  44 #include "Log.h"
  45 #include "DBCStores.h"
  46
  47 #if defined( __GNUC__ )
  48 #pragma pack(1)
  49 #else
  50 #pragma pack(push,1)
  51 #endif
  52
  53 struct ServerPktHeader
  54 {
  55     /**
  56      * size is the length of the payload _plus_ the length of the opcode
  57      */
  58     ServerPktHeader(uint32 size, uint16 cmd) : size(size)
  59     {
  60         uint8 headerIndex=0;
  61         if(isLargePacket())
  62         {
  63             sLog.outDebug("initializing large server to client packet. Size: %u, cmd: %u", size, cmd);
  64             header[headerIndex++] = 0x80|(0xFF &(size>>16));
  65         }
  66         header[headerIndex++] = 0xFF &(size>>8);
  67         header[headerIndex++] = 0xFF &size;
  68
  69         header[headerIndex++] = 0xFF & cmd;
  70         header[headerIndex++] = 0xFF & (cmd>>8);
  71     }
  72
  73     uint8 getHeaderLength()
  74     {
  75         // cmd = 2 bytes, size= 2||3bytes
  76         return 2+(isLargePacket()?3:2);
  77     }
  78
  79     bool isLargePacket()
  80     {
  81         return size > 0x7FFF;
  82     }
  83
  84     const uint32 size;
  85     uint8 header[5];
  86 };
  87
  88 struct ClientPktHeader
  89 {
  90     uint16 size;
  91     uint32 cmd;
  92 };
  93
  94 #if defined( __GNUC__ )
  95 #pragma pack()
  96 #else
  97 #pragma pack(pop)
  98 #endif
  99
 100 WorldSocket::WorldSocket (void) :
 101 WorldHandler (),
 102 m_Session (0),
 103 m_RecvWPct (0),
 104 m_RecvPct (),
 105 m_Header (sizeof (ClientPktHeader)),
 106 m_OutBuffer (0),
 107 m_OutBufferSize (65536),
 108 m_OutActive (false),
 109 m_Seed (static_cast<uint32> (rand32 ())),
 110 m_OverSpeedPings (0),
 111 m_LastPingTime (ACE_Time_Value::zero)
 112 {
 113     reference_counting_policy ().value (ACE_Event_Handler::Reference_Counting_Policy::ENABLED);
 114
 115     msg_queue()->high_water_mark(8*1024*1024);
 116     msg_queue()->low_water_mark(8*1024*1024);
 117 }
 118
 119 WorldSocket::~WorldSocket (void)
 120 {
 121     if (m_RecvWPct)
 122         delete m_RecvWPct;
 123
 124     if (m_OutBuffer)
 125         m_OutBuffer->release ();
 126
 127     closing_ = true;
 128
 129     peer ().close ();
 130 }
 131
 132 bool WorldSocket::IsClosed (void) const
 133 {
 134     return closing_;
 135 }
 136
 137 void WorldSocket::CloseSocket (void)
 138 {
 139     {
 140         ACE_GUARD (LockType, Guard, m_OutBufferLock);
 141
 142         if (closing_)
 143             return;
 144
 145         closing_ = true;
 146         peer ().close_writer ();
 147     }
 148
 149     {
 150         ACE_GUARD (LockType, Guard, m_SessionLock);
 151
 152         m_Session = NULL;
 153     }
 154 }
 155
 156 const std::string& WorldSocket::GetRemoteAddress (void) const
 157 {
 158     return m_Address;
 159 }
 160
 161 int WorldSocket::SendPacket (const WorldPacket& pct)
 162 {
 163     ACE_GUARD_RETURN (LockType, Guard, m_OutBufferLock, -1);
 164
 165     if (closing_)
 166         return -1;
 167
 168     // Dump outgoing packet.
 169     sLog.outWorldPacketDump(uint32(get_handle()), pct.GetOpcode(), LookupOpcodeName(pct.GetOpcode()), &pct, false);
 170
 171     ServerPktHeader header(pct.size()+2, pct.GetOpcode());
 172     m_Crypt.EncryptSend ((uint8*)header.header, header.getHeaderLength());
 173
 174     if (m_OutBuffer->space () >= pct.size () + header.getHeaderLength() && msg_queue()->is_empty())
 175     {
 176         // Put the packet on the buffer.
 177         if (m_OutBuffer->copy ((char*) header.header, header.getHeaderLength()) == -1)
 178             ACE_ASSERT (false);
 179
 180         if (!pct.empty ())
 181             if (m_OutBuffer->copy ((char*) pct.contents (), pct.size ()) == -1)
 182                 ACE_ASSERT (false);
 183     }
 184     else
 185     {
 186         // Enqueue the packet.
 187         ACE_Message_Block* mb;
 188
 189         ACE_NEW_RETURN(mb, ACE_Message_Block(pct.size () + header.getHeaderLength()), -1);
 190
 191         mb->copy((char*) header.header, header.getHeaderLength());
 192
 193         if (!pct.empty ())
 194             mb->copy((const char*)pct.contents(), pct.size ());
 195
 196         if(msg_queue()->enqueue_tail(mb,(ACE_Time_Value*)&ACE_Time_Value::zero) == -1)
 197         {
 198             sLog.outError("WorldSocket::SendPacket enqueue_tail");
 199             mb->release();
 200             return -1;
 201         }
 202     }
 203
 204     return 0;
 205 }
 206
 207 long WorldSocket::AddReference (void)
 208 {
 209     return static_cast<long> (add_reference ());
 210 }
 211
 212 long WorldSocket::RemoveReference (void)
 213 {
 214     return static_cast<long> (remove_reference ());
 215 }
 216
 217 int WorldSocket::open (void *a)
 218 {
 219     ACE_UNUSED_ARG (a);
 220
 221     // Prevent double call to this func.
 222     if (m_OutBuffer)
 223         return -1;
 224
 225     // This will also prevent the socket from being Updated
 226     // while we are initializing it.
 227     m_OutActive = true;
 228
 229     // Hook for the manager.
 230     if (sWorldSocketMgr->OnSocketOpen (this) == -1)
 231         return -1;
 232
 233     // Allocate the buffer.
 234     ACE_NEW_RETURN (m_OutBuffer, ACE_Message_Block (m_OutBufferSize), -1);
 235
 236     // Store peer address.
 237     ACE_INET_Addr remote_addr;
 238
 239     if (peer ().get_remote_addr (remote_addr) == -1)
 240     {
 241         sLog.outError ("WorldSocket::open: peer ().get_remote_addr errno = %s", ACE_OS::strerror (errno));
 242         return -1;
 243     }
 244
 245     m_Address = remote_addr.get_host_addr ();
 246
 247     // Send startup packet.
 248     WorldPacket packet (SMSG_AUTH_CHALLENGE, 24);
 249     packet << uint32(1);                                    // 1...31
 250     packet << m_Seed;
 251     packet << uint32(0xF3539DA3);                           // random data
 252     packet << uint32(0x6E8547B9);                           // random data
 253     packet << uint32(0x9A6AA2F8);                           // random data
 254     packet << uint32(0xA4F170F4);                           // random data
 255
 256     if (SendPacket (packet) == -1)
 257         return -1;
 258
 259     // Register with ACE Reactor
 260     if (reactor ()->register_handler(this, ACE_Event_Handler::READ_MASK | ACE_Event_Handler::WRITE_MASK) == -1)
 261     {
 262         sLog.outError ("WorldSocket::open: unable to register client handler errno = %s", ACE_OS::strerror (errno));
 263         return -1;
 264     }
 265
 266     // reactor takes care of the socket from now on
 267     remove_reference ();
 268
 269     return 0;
 270 }
 271
 272 int WorldSocket::close (int)
 273 {
 274     shutdown ();
 275
 276     closing_ = true;
 277
 278     remove_reference ();
 279
 280     return 0;
 281 }
 282
 283 int WorldSocket::handle_input (ACE_HANDLE)
 284 {
 285     if (closing_)
 286         return -1;
 287
 288     switch (handle_input_missing_data ())
 289     {
 290         case -1 :
 291         {
 292             if ((errno == EWOULDBLOCK) ||
 293                 (errno == EAGAIN))
 294             {
 295                 return Update ();                           // interesting line ,isn't it ?
 296             }
 297
 298             DEBUG_LOG ("WorldSocket::handle_input: Peer error closing connection errno = %s", ACE_OS::strerror (errno));
 299
 300             errno = ECONNRESET;
 301             return -1;
 302         }
 303         case 0:
 304         {
 305             DEBUG_LOG ("WorldSocket::handle_input: Peer has closed connection");
 306
 307             errno = ECONNRESET;
 308             return -1;
 309         }
 310         case 1:
 311             return 1;
 312         default:
 313             return Update ();                               // another interesting line ;)
 314     }
 315
 316     ACE_NOTREACHED(return -1);
 317 }
 318
 319 int WorldSocket::handle_output (ACE_HANDLE)
 320 {
 321     ACE_GUARD_RETURN (LockType, Guard, m_OutBufferLock, -1);
 322
 323     if (closing_)
 324         return -1;
 325
 326     const size_t send_len = m_OutBuffer->length ();
 327
 328     if (send_len == 0)
 329         return handle_output_queue (Guard);
 330
 331 #ifdef MSG_NOSIGNAL
 332     ssize_t n = peer ().send (m_OutBuffer->rd_ptr (), send_len, MSG_NOSIGNAL);
 333 #else
 334     ssize_t n = peer ().send (m_OutBuffer->rd_ptr (), send_len);
 335 #endif // MSG_NOSIGNAL
 336
 337     if (n == 0)
 338         return -1;
 339     else if (n == -1)
 340     {
 341         if (errno == EWOULDBLOCK || errno == EAGAIN)
 342             return schedule_wakeup_output (Guard);
 343
 344         return -1;
 345     }
 346     else if (n < (ssize_t)send_len) //now n > 0
 347     {
 348         m_OutBuffer->rd_ptr (static_cast<size_t> (n));
 349
 350         // move the data to the base of the buffer
 351         m_OutBuffer->crunch ();
 352
 353         return schedule_wakeup_output (Guard);
 354     }
 355     else //now n == send_len
 356     {
 357         m_OutBuffer->reset ();
 358
 359         return handle_output_queue (Guard);
 360     }
 361
 362     ACE_NOTREACHED (return 0);
 363 }
 364
 365 int WorldSocket::handle_output_queue (GuardType& g)
 366 {
 367     if(msg_queue()->is_empty())
 368         return cancel_wakeup_output(g);
 369
 370     ACE_Message_Block *mblk;
 371
 372     if(msg_queue()->dequeue_head(mblk, (ACE_Time_Value*)&ACE_Time_Value::zero) == -1)
 373     {
 374         sLog.outError("WorldSocket::handle_output_queue dequeue_head");
 375         return -1;
 376     }
 377
 378     const size_t send_len = mblk->length ();
 379
 380 #ifdef MSG_NOSIGNAL
 381     ssize_t n = peer ().send (mblk->rd_ptr (), send_len, MSG_NOSIGNAL);
 382 #else
 383     ssize_t n = peer ().send (mblk->rd_ptr (), send_len);
 384 #endif // MSG_NOSIGNAL
 385
 386     if (n == 0)
 387     {
 388         mblk->release();
 389
 390         return -1;
 391     }
 392     else if (n == -1)
 393     {
 394         if (errno == EWOULDBLOCK || errno == EAGAIN)
 395         {
 396             msg_queue()->enqueue_head(mblk, (ACE_Time_Value*) &ACE_Time_Value::zero);
 397             return schedule_wakeup_output (g);
 398         }
 399
 400         mblk->release();
 401         return -1;
 402     }
 403     else if (n < (ssize_t)send_len) //now n > 0
 404     {
 405         mblk->rd_ptr (static_cast<size_t> (n));
 406
 407         if (msg_queue()->enqueue_head(mblk, (ACE_Time_Value*) &ACE_Time_Value::zero) == -1)
 408         {
 409             sLog.outError("WorldSocket::handle_output_queue enqueue_head");
 410             mblk->release();
 411             return -1;
 412         }
 413
 414         return schedule_wakeup_output (g);
 415     }
 416     else //now n == send_len
 417     {
 418         mblk->release();
 419
 420         return msg_queue()->is_empty() ? cancel_wakeup_output(g) : ACE_Event_Handler::WRITE_MASK;
 421     }
 422
 423     ACE_NOTREACHED(return -1);
 424 }
 425
 426 int WorldSocket::handle_close (ACE_HANDLE h, ACE_Reactor_Mask)
 427 {
 428     // Critical section
 429     {
 430         ACE_GUARD_RETURN (LockType, Guard, m_OutBufferLock, -1);
 431
 432         closing_ = true;
 433
 434         if (h == ACE_INVALID_HANDLE)
 435             peer ().close_writer ();
 436     }
 437
 438     // Critical section
 439     {
 440         ACE_GUARD_RETURN (LockType, Guard, m_SessionLock, -1);
 441
 442         m_Session = NULL;
 443     }
 444
 445     return 0;
 446 }
 447
 448 int WorldSocket::Update (void)
 449 {
 450     if (closing_)
 451         return -1;
 452
 453     if (m_OutActive || (m_OutBuffer->length () == 0 && msg_queue()->is_empty()))
 454         return 0;
 455
 456     int ret;
 457     do
 458         ret = handle_output (get_handle ());
 459     while( ret > 0 );
 460
 461     return ret;
 462 }
 463
 464 int WorldSocket::handle_input_header (void)
 465 {
 466     ACE_ASSERT (m_RecvWPct == NULL);
 467
 468     ACE_ASSERT (m_Header.length () == sizeof (ClientPktHeader));
 469
 470     m_Crypt.DecryptRecv ((uint8*) m_Header.rd_ptr (), sizeof (ClientPktHeader));
 471
 472     ClientPktHeader& header = *((ClientPktHeader*) m_Header.rd_ptr ());
 473
 474     EndianConvertReverse(header.size);
 475     EndianConvert(header.cmd);
 476
 477     if ((header.size < 4) || (header.size > 10240) || (header.cmd  > 10240))
 478     {
 479         sLog.outError ("WorldSocket::handle_input_header: client sent malformed packet size = %d , cmd = %d",
 480                        header.size, header.cmd);
 481
 482         errno = EINVAL;
 483         return -1;
 484     }
 485
 486     header.size -= 4;
 487
 488     ACE_NEW_RETURN (m_RecvWPct, WorldPacket ((uint16) header.cmd, header.size), -1);
 489
 490     if(header.size > 0)
 491     {
 492         m_RecvWPct->resize (header.size);
 493         m_RecvPct.base ((char*) m_RecvWPct->contents (), m_RecvWPct->size ());
 494     }
 495     else
 496     {
 497         ACE_ASSERT(m_RecvPct.space() == 0);
 498     }
 499
 500     return 0;
 501 }
 502
 503 int WorldSocket::handle_input_payload (void)
 504 {
 505     // set errno properly here on error !!!
 506     // now have a header and payload
 507
 508     ACE_ASSERT (m_RecvPct.space () == 0);
 509     ACE_ASSERT (m_Header.space () == 0);
 510     ACE_ASSERT (m_RecvWPct != NULL);
 511
 512     const int ret = ProcessIncoming (m_RecvWPct);
 513
 514     m_RecvPct.base (NULL, 0);
 515     m_RecvPct.reset ();
 516     m_RecvWPct = NULL;
 517
 518     m_Header.reset ();
 519
 520     if (ret == -1)
 521         errno = EINVAL;
 522
 523     return ret;
 524 }
 525
 526 int WorldSocket::handle_input_missing_data (void)
 527 {
 528     char buf [4096];
 529
 530     ACE_Data_Block db ( sizeof (buf),
 531                         ACE_Message_Block::MB_DATA,
 532                         buf,
 533                         0,
 534                         0,
 535                         ACE_Message_Block::DONT_DELETE,
 536                         0);
 537
 538     ACE_Message_Block message_block(&db,
 539                                     ACE_Message_Block::DONT_DELETE,
 540                                     0);
 541
 542     const size_t recv_size = message_block.space ();
 543
 544     const ssize_t n = peer ().recv (message_block.wr_ptr (),
 545                                           recv_size);
 546
 547     if (n <= 0)
 548         return (int)n;
 549
 550     message_block.wr_ptr (n);
 551
 552     while (message_block.length () > 0)
 553     {
 554         if (m_Header.space () > 0)
 555         {
 556             //need to receive the header
 557             const size_t to_header = (message_block.length () > m_Header.space () ? m_Header.space () : message_block.length ());
 558             m_Header.copy (message_block.rd_ptr (), to_header);
 559             message_block.rd_ptr (to_header);
 560
 561             if (m_Header.space () > 0)
 562             {
 563                 // Couldn't receive the whole header this time.
 564                 ACE_ASSERT (message_block.length () == 0);
 565                 errno = EWOULDBLOCK;
 566                 return -1;
 567             }
 568
 569             // We just received nice new header
 570             if (handle_input_header () == -1)
 571             {
 572                 ACE_ASSERT ((errno != EWOULDBLOCK) && (errno != EAGAIN));
 573                 return -1;
 574             }
 575         }
 576
 577         // Its possible on some error situations that this happens
 578         // for example on closing when epoll receives more chunked data and stuff
 579         // hope this is not hack ,as proper m_RecvWPct is asserted around
 580         if (!m_RecvWPct)
 581         {
 582             sLog.outError ("Forcing close on input m_RecvWPct = NULL");
 583             errno = EINVAL;
 584             return -1;
 585         }
 586
 587         // We have full read header, now check the data payload
 588         if (m_RecvPct.space () > 0)
 589         {
 590             //need more data in the payload
 591             const size_t to_data = (message_block.length () > m_RecvPct.space () ? m_RecvPct.space () : message_block.length ());
 592             m_RecvPct.copy (message_block.rd_ptr (), to_data);
 593             message_block.rd_ptr (to_data);
 594
 595             if (m_RecvPct.space () > 0)
 596             {
 597                 // Couldn't receive the whole data this time.
 598                 ACE_ASSERT (message_block.length () == 0);
 599                 errno = EWOULDBLOCK;
 600                 return -1;
 601             }
 602         }
 603
 604         //just received fresh new payload
 605         if (handle_input_payload () == -1)
 606         {
 607             ACE_ASSERT ((errno != EWOULDBLOCK) && (errno != EAGAIN));
 608             return -1;
 609         }
 610     }
 611
 612     return n == recv_size ? 1 : 2;
 613 }
 614
 615 int WorldSocket::cancel_wakeup_output (GuardType& g)
 616 {
 617     if (!m_OutActive)
 618         return 0;
 619
 620     m_OutActive = false;
 621
 622     g.release ();
 623
 624     if (reactor ()->cancel_wakeup
 625         (this, ACE_Event_Handler::WRITE_MASK) == -1)
 626     {
 627         // would be good to store errno from reactor with errno guard
 628         sLog.outError ("WorldSocket::cancel_wakeup_output");
 629         return -1;
 630     }
 631
 632     return 0;
 633 }
 634
 635 int WorldSocket::schedule_wakeup_output (GuardType& g)
 636 {
 637     if (m_OutActive)
 638         return 0;
 639
 640     m_OutActive = true;
 641
 642     g.release ();
 643
 644     if (reactor ()->schedule_wakeup
 645         (this, ACE_Event_Handler::WRITE_MASK) == -1)
 646     {
 647         sLog.outError ("WorldSocket::schedule_wakeup_output");
 648         return -1;
 649     }
 650
 651     return 0;
 652 }
 653
 654 int WorldSocket::ProcessIncoming (WorldPacket* new_pct)
 655 {
 656     ACE_ASSERT (new_pct);
 657
 658     // manage memory ;)
 659     ACE_Auto_Ptr<WorldPacket> aptr (new_pct);
 660
 661     const ACE_UINT16 opcode = new_pct->GetOpcode ();
 662
 663     if (opcode >= NUM_MSG_TYPES)
 664     {
 665         sLog.outError( "SESSION: received non-existed opcode 0x%.4X", opcode);
 666         return -1;
 667     }
 668
 669     if (closing_)
 670         return -1;
 671
 672     // Dump received packet.
 673     sLog.outWorldPacketDump(uint32(get_handle()), new_pct->GetOpcode(), LookupOpcodeName(new_pct->GetOpcode()), new_pct, true);
 674
 675     try
 676     {
 677         switch(opcode)
 678         {
 679             case CMSG_PING:
 680                 return HandlePing (*new_pct);
 681             case CMSG_AUTH_SESSION:
 682                 if (m_Session)
 683                 {
 684                     sLog.outError ("WorldSocket::ProcessIncoming: Player send CMSG_AUTH_SESSION again");
 685                     return -1;
 686                 }
 687
 688                 return HandleAuthSession (*new_pct);
 689             case CMSG_KEEP_ALIVE:
 690                 DEBUG_LOG ("CMSG_KEEP_ALIVE ,size: %d", new_pct->size ());
 691
 692                 return 0;
 693             default:
 694             {
 695                 ACE_GUARD_RETURN (LockType, Guard, m_SessionLock, -1);
 696
 697                 if (m_Session != NULL)
 698                 {
 699                     // OK ,give the packet to WorldSession
 700                     aptr.release ();
 701                     // WARNINIG here we call it with locks held.
 702                     // Its possible to cause deadlock if QueuePacket calls back
 703                     m_Session->QueuePacket (new_pct);
 704                     return 0;
 705                 }
 706                 else
 707                 {
 708                     sLog.outError ("WorldSocket::ProcessIncoming: Client not authed opcode = %u", uint32(opcode));
 709                     return -1;
 710                 }
 711             }
 712         }
 713     }
 714     catch (ByteBufferException &)
 715     {
 716         sLog.outError("WorldSocket::ProcessIncoming ByteBufferException occured while parsing an instant handled packet (opcode: %u) from client %s, accountid=%i.",
 717                 opcode, GetRemoteAddress().c_str(), m_Session?m_Session->GetAccountId():-1);
 718         if(sLog.IsOutDebug())
 719         {
 720             sLog.outDebug("Dumping error-causing packet:");
 721             new_pct->hexlike();
 722         }
 723
 724         if (sWorld.getConfig(CONFIG_BOOL_KICK_PLAYER_ON_BAD_PACKET))
 725         {
 726             sLog.outDetail("Disconnecting session [account id %i / address %s] for badly formatted packet.",
 727                 m_Session?m_Session->GetAccountId():-1, GetRemoteAddress().c_str());
 728
 729             return -1;
 730         }
 731         else
 732             return 0;
 733     }
 734
 735     ACE_NOTREACHED (return 0);
 736 }
 737
 738 int WorldSocket::HandleAuthSession (WorldPacket& recvPacket)
 739 {
 740     // NOTE: ATM the socket is singlethread, have this in mind ...
 741     uint8 digest[20];
 742     uint32 clientSeed;
 743     uint32 unk2, unk3;
 744     uint64 unk4;
 745     uint32 ClientBuild;
 746     uint32 id, security;
 747     uint8 expansion = 0;
 748     LocaleConstant locale;
 749     std::string account;
 750     Sha1Hash sha1;
 751     BigNumber v, s, g, N;
 752     WorldPacket packet, SendAddonPacked;
 753
 754     BigNumber K;
 755
 756     // Read the content of the packet
 757     recvPacket >> ClientBuild;
 758     recvPacket >> unk2;
 759     recvPacket >> account;
 760     recvPacket >> unk3;
 761     recvPacket >> clientSeed;
 762     recvPacket >> unk4;
 763     recvPacket.read (digest, 20);
 764
 765     DEBUG_LOG ("WorldSocket::HandleAuthSession: client %u, unk2 %u, account %s, unk3 %u, clientseed %u",
 766                 ClientBuild,
 767                 unk2,
 768                 account.c_str (),
 769                 unk3,
 770                 clientSeed);
 771
 772     // Check the version of client trying to connect
 773     if(!IsAcceptableClientBuild(ClientBuild))
 774     {
 775         packet.Initialize (SMSG_AUTH_RESPONSE, 1);
 776         packet << uint8 (AUTH_VERSION_MISMATCH);
 777
 778         SendPacket (packet);
 779
 780         sLog.outError ("WorldSocket::HandleAuthSession: Sent Auth Response (version mismatch).");
 781         return -1;
 782     }
 783
 784     // Get the account information from the realmd database
 785     std::string safe_account = account; // Duplicate, else will screw the SHA hash verification below
 786     loginDatabase.escape_string (safe_account);
 787     // No SQL injection, username escaped.
 788
 789     QueryResult *result =
 790           loginDatabase.PQuery ("SELECT "
 791                                 "id, "                      //0
 792                                 "gmlevel, "                 //1
 793                                 "sessionkey, "              //2
 794                                 "last_ip, "                 //3
 795                                 "locked, "                  //4
 796                                 "v, "                       //5
 797                                 "s, "                       //6
 798                                 "expansion, "               //7
 799                                 "mutetime, "                //8
 800                                 "locale "                   //9
 801                                 "FROM account "
 802                                 "WHERE username = '%s'",
 803                                 safe_account.c_str ());
 804
 805     // Stop if the account is not found
 806     if (!result)
 807     {
 808         packet.Initialize (SMSG_AUTH_RESPONSE, 1);
 809         packet << uint8 (AUTH_UNKNOWN_ACCOUNT);
 810
 811         SendPacket (packet);
 812
 813         sLog.outError ("WorldSocket::HandleAuthSession: Sent Auth Response (unknown account).");
 814         return -1;
 815     }
 816
 817     Field* fields = result->Fetch ();
 818
 819     expansion = ((sWorld.getConfig(CONFIG_UINT32_EXPANSION) > fields[7].GetUInt8()) ? fields[7].GetUInt8() : sWorld.getConfig(CONFIG_UINT32_EXPANSION));
 820
 821     N.SetHexStr ("894B645E89E1535BBDAD5B8B290650530801B18EBFBF5E8FAB3C82872A3E9BB7");
 822     g.SetDword (7);
 823
 824     v.SetHexStr(fields[5].GetString());
 825     s.SetHexStr (fields[6].GetString ());
 826
 827     const char* sStr = s.AsHexStr ();                       //Must be freed by OPENSSL_free()
 828     const char* vStr = v.AsHexStr ();                       //Must be freed by OPENSSL_free()
 829
 830     DEBUG_LOG ("WorldSocket::HandleAuthSession: (s,v) check s: %s v: %s",
 831                 sStr,
 832                 vStr);
 833
 834     OPENSSL_free ((void*) sStr);
 835     OPENSSL_free ((void*) vStr);
 836
 837     ///- Re-check ip locking (same check as in realmd).
 838     if (fields[4].GetUInt8 () == 1) // if ip is locked
 839     {
 840         if (strcmp (fields[3].GetString (), GetRemoteAddress ().c_str ()))
 841         {
 842             packet.Initialize (SMSG_AUTH_RESPONSE, 1);
 843             packet << uint8 (AUTH_FAILED);
 844             SendPacket (packet);
 845
 846             delete result;
 847             sLog.outBasic ("WorldSocket::HandleAuthSession: Sent Auth Response (Account IP differs).");
 848             return -1;
 849         }
 850     }
 851
 852     id = fields[0].GetUInt32 ();
 853     security = fields[1].GetUInt16 ();
 854     if(security > SEC_ADMINISTRATOR)                        // prevent invalid security settings in DB
 855         security = SEC_ADMINISTRATOR;
 856
 857     K.SetHexStr (fields[2].GetString ());
 858
 859     time_t mutetime = time_t (fields[8].GetUInt64 ());
 860
 861     locale = LocaleConstant (fields[9].GetUInt8 ());
 862     if (locale >= MAX_LOCALE)
 863         locale = LOCALE_enUS;
 864
 865     delete result;
 866
 867     // Re-check account ban (same check as in realmd)
 868     QueryResult *banresult =
 869           loginDatabase.PQuery ("SELECT 1 FROM account_banned WHERE id = %u AND active = 1 AND (unbandate > UNIX_TIMESTAMP() OR unbandate = bandate)"
 870                                 "UNION "
 871                                 "SELECT 1 FROM ip_banned WHERE (unbandate = bandate OR unbandate > UNIX_TIMESTAMP()) AND ip = '%s'",
 872                                 id, GetRemoteAddress().c_str());
 873
 874     if (banresult) // if account banned
 875     {
 876         packet.Initialize (SMSG_AUTH_RESPONSE, 1);
 877         packet << uint8 (AUTH_BANNED);
 878         SendPacket (packet);
 879
 880         delete banresult;
 881
 882         sLog.outError ("WorldSocket::HandleAuthSession: Sent Auth Response (Account banned).");
 883         return -1;
 884     }
 885
 886     // Check locked state for server
 887     AccountTypes allowedAccountType = sWorld.GetPlayerSecurityLimit ();
 888
 889     if (allowedAccountType > SEC_PLAYER && AccountTypes(security) < allowedAccountType)
 890     {
 891         WorldPacket Packet (SMSG_AUTH_RESPONSE, 1);
 892         Packet << uint8 (AUTH_UNAVAILABLE);
 893
 894         SendPacket (packet);
 895
 896         sLog.outBasic ("WorldSocket::HandleAuthSession: User tries to login but his security level is not enough");
 897         return -1;
 898     }
 899
 900     // Check that Key and account name are the same on client and server
 901     Sha1Hash sha;
 902
 903     uint32 t = 0;
 904     uint32 seed = m_Seed;
 905
 906     sha.UpdateData (account);
 907     sha.UpdateData ((uint8 *) & t, 4);
 908     sha.UpdateData ((uint8 *) & clientSeed, 4);
 909     sha.UpdateData ((uint8 *) & seed, 4);
 910     sha.UpdateBigNumbers (&K, NULL);
 911     sha.Finalize ();
 912
 913     if (memcmp (sha.GetDigest (), digest, 20))
 914     {
 915         packet.Initialize (SMSG_AUTH_RESPONSE, 1);
 916         packet << uint8 (AUTH_FAILED);
 917
 918         SendPacket (packet);
 919
 920         sLog.outError ("WorldSocket::HandleAuthSession: Sent Auth Response (authentification failed).");
 921         return -1;
 922     }
 923
 924     std::string address = GetRemoteAddress ();
 925
 926     DEBUG_LOG ("WorldSocket::HandleAuthSession: Client '%s' authenticated successfully from %s.",
 927                 account.c_str (),
 928                 address.c_str ());
 929
 930     // Update the last_ip in the database
 931     // No SQL injection, username escaped.
 932     loginDatabase.escape_string (address);
 933
 934     loginDatabase.PExecute ("UPDATE account "
 935                             "SET last_ip = '%s' "
 936                             "WHERE username = '%s'",
 937                             address.c_str (),
 938                             safe_account.c_str ());
 939
 940     // NOTE ATM the socket is single-threaded, have this in mind ...
 941     ACE_NEW_RETURN (m_Session, WorldSession (id, this, AccountTypes(security), expansion, mutetime, locale), -1);
 942
 943     m_Crypt.Init(&K);
 944
 945     m_Session->LoadGlobalAccountData();
 946     m_Session->LoadTutorialsData();
 947     m_Session->ReadAddonsInfo(recvPacket);
 948
 949     // In case needed sometime the second arg is in microseconds 1 000 000 = 1 sec
 950     ACE_OS::sleep (ACE_Time_Value (0, 10000));
 951
 952     sWorld.AddSession (m_Session);
 953
 954     return 0;
 955 }
 956
 957 int WorldSocket::HandlePing (WorldPacket& recvPacket)
 958 {
 959     uint32 ping;
 960     uint32 latency;
 961
 962     // Get the ping packet content
 963     recvPacket >> ping;
 964     recvPacket >> latency;
 965
 966     if (m_LastPingTime == ACE_Time_Value::zero)
 967         m_LastPingTime = ACE_OS::gettimeofday (); // for 1st ping
 968     else
 969     {
 970         ACE_Time_Value cur_time = ACE_OS::gettimeofday ();
 971         ACE_Time_Value diff_time (cur_time);
 972         diff_time -= m_LastPingTime;
 973         m_LastPingTime = cur_time;
 974
 975         if (diff_time < ACE_Time_Value (27))
 976         {
 977             ++m_OverSpeedPings;
 978
 979             uint32 max_count = sWorld.getConfig (CONFIG_UINT32_MAX_OVERSPEED_PINGS);
 980
 981             if (max_count && m_OverSpeedPings > max_count)
 982             {
 983                 ACE_GUARD_RETURN (LockType, Guard, m_SessionLock, -1);
 984
 985                 if (m_Session && m_Session->GetSecurity () == SEC_PLAYER)
 986                 {
 987                     sLog.outError  ("WorldSocket::HandlePing: Player kicked for "
 988                                     "over-speed pings address = %s",
 989                                     GetRemoteAddress ().c_str ());
 990
 991                     return -1;
 992                 }
 993             }
 994         }
 995         else
 996             m_OverSpeedPings = 0;
 997     }
 998
 999     // critical section
1000     {
1001         ACE_GUARD_RETURN (LockType, Guard, m_SessionLock, -1);
1002
1003         if (m_Session)
1004             m_Session->SetLatency (latency);
1005         else
1006         {
1007             sLog.outError ("WorldSocket::HandlePing: peer sent CMSG_PING, "
1008                             "but is not authenticated or got recently kicked,"
1009                             " address = %s",
1010                             GetRemoteAddress ().c_str ());
1011              return -1;
1012         }
1013     }
1014
1015     WorldPacket packet (SMSG_PONG, 4);
1016     packet << ping;
1017     return SendPacket (packet);
1018 }