src/game/WorldSession.cpp

   1 /*
   2  * Copyright (C) 2005-2009 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 /** \file
  20     \ingroup u2w
  21 */
  22
  23 #include "WorldSocket.h"                                    // must be first to make ACE happy with ACE includes in it
  24 #include "Common.h"
  25 #include "Database/DatabaseEnv.h"
  26 #include "Log.h"
  27 #include "Opcodes.h"
  28 #include "WorldPacket.h"
  29 #include "WorldSession.h"
  30 #include "Player.h"
  31 #include "ObjectMgr.h"
  32 #include "Group.h"
  33 #include "Guild.h"
  34 #include "World.h"
  35 #include "ObjectAccessor.h"
  36 #include "BattleGroundMgr.h"
  37 #include "SocialMgr.h"
  38 #include "zlib/zlib.h"
  39
  40 /// WorldSession constructor
  41 WorldSession::WorldSession(uint32 id, WorldSocket *sock, AccountTypes sec, uint8 expansion, time_t mute_time, LocaleConstant locale) :
  42 LookingForGroup_auto_join(false), LookingForGroup_auto_add(false), m_muteTime(mute_time),
  43 _player(NULL), m_Socket(sock),_security(sec), _accountId(id), m_expansion(expansion),
  44 m_sessionDbcLocale(sWorld.GetAvailableDbcLocale(locale)), m_sessionDbLocaleIndex(objmgr.GetIndexForLocale(locale)),
  45 _logoutTime(0), m_inQueue(false), m_playerLoading(false), m_playerLogout(false), m_playerRecentlyLogout(false), m_latency(0)
  46 {
  47     if (sock)
  48     {
  49         m_Address = sock->GetRemoteAddress ();
  50         sock->AddReference ();
  51     }
  52 }
  53
  54 /// WorldSession destructor
  55 WorldSession::~WorldSession()
  56 {
  57     ///- unload player if not unloaded
  58     if (_player)
  59         LogoutPlayer (true);
  60
  61     /// - If have unclosed socket, close it
  62     if (m_Socket)
  63     {
  64         m_Socket->CloseSocket ();
  65         m_Socket->RemoveReference ();
  66         m_Socket = NULL;
  67     }
  68
  69     ///- empty incoming packet queue
  70     while(!_recvQueue.empty())
  71     {
  72         WorldPacket *packet = _recvQueue.next ();
  73         delete packet;
  74     }
  75 }
  76
  77 void WorldSession::SizeError(WorldPacket const& packet, uint32 size) const
  78 {
  79     sLog.outError("Client (account %u) send packet %s (%u) with size %u but expected %u (attempt crash server?), skipped",
  80         GetAccountId(),LookupOpcodeName(packet.GetOpcode()),packet.GetOpcode(),packet.size(),size);
  81 }
  82
  83 /// Get the player name
  84 char const* WorldSession::GetPlayerName() const
  85 {
  86     return GetPlayer() ? GetPlayer()->GetName() : "<none>";
  87 }
  88
  89 /// Send a packet to the client
  90 void WorldSession::SendPacket(WorldPacket const* packet)
  91 {
  92     if (!m_Socket)
  93         return;
  94
  95     #ifdef MANGOS_DEBUG
  96
  97     // Code for network use statistic
  98     static uint64 sendPacketCount = 0;
  99     static uint64 sendPacketBytes = 0;
 100
 101     static time_t firstTime = time(NULL);
 102     static time_t lastTime = firstTime;                     // next 60 secs start time
 103
 104     static uint64 sendLastPacketCount = 0;
 105     static uint64 sendLastPacketBytes = 0;
 106
 107     time_t cur_time = time(NULL);
 108
 109     if((cur_time - lastTime) < 60)
 110     {
 111         sendPacketCount+=1;
 112         sendPacketBytes+=packet->size();
 113
 114         sendLastPacketCount+=1;
 115         sendLastPacketBytes+=packet->size();
 116     }
 117     else
 118     {
 119         uint64 minTime = uint64(cur_time - lastTime);
 120         uint64 fullTime = uint64(lastTime - firstTime);
 121         sLog.outDetail("Send all time packets count: " UI64FMTD " bytes: " UI64FMTD " avr.count/sec: %f avr.bytes/sec: %f time: %u",sendPacketCount,sendPacketBytes,float(sendPacketCount)/fullTime,float(sendPacketBytes)/fullTime,uint32(fullTime));
 122         sLog.outDetail("Send last min packets count: " UI64FMTD " bytes: " UI64FMTD " avr.count/sec: %f avr.bytes/sec: %f",sendLastPacketCount,sendLastPacketBytes,float(sendLastPacketCount)/minTime,float(sendLastPacketBytes)/minTime);
 123
 124         lastTime = cur_time;
 125         sendLastPacketCount = 1;
 126         sendLastPacketBytes = packet->wpos();               // wpos is real written size
 127     }
 128
 129     #endif                                                  // !MANGOS_DEBUG
 130
 131     if (m_Socket->SendPacket (*packet) == -1)
 132         m_Socket->CloseSocket ();
 133 }
 134
 135 /// Add an incoming packet to the queue
 136 void WorldSession::QueuePacket(WorldPacket* new_packet)
 137 {
 138     _recvQueue.add(new_packet);
 139 }
 140
 141 /// Logging helper for unexpected opcodes
 142 void WorldSession::logUnexpectedOpcode(WorldPacket* packet, const char *reason)
 143 {
 144     sLog.outError( "SESSION: received unexpected opcode %s (0x%.4X) %s",
 145         LookupOpcodeName(packet->GetOpcode()),
 146         packet->GetOpcode(),
 147         reason);
 148 }
 149
 150 /// Update the WorldSession (triggered by World update)
 151 bool WorldSession::Update(uint32 /*diff*/)
 152 {
 153     ///- Retrieve packets from the receive queue and call the appropriate handlers
 154     /// not proccess packets if socket already closed
 155     while (!_recvQueue.empty() && m_Socket && !m_Socket->IsClosed ())
 156     {
 157         WorldPacket *packet = _recvQueue.next();
 158
 159         /*#if 1
 160         sLog.outError( "MOEP: %s (0x%.4X)",
 161                         LookupOpcodeName(packet->GetOpcode()),
 162                         packet->GetOpcode());
 163         #endif*/
 164
 165         if(packet->GetOpcode() >= NUM_MSG_TYPES)
 166         {
 167             sLog.outError( "SESSION: received non-existed opcode %s (0x%.4X)",
 168                 LookupOpcodeName(packet->GetOpcode()),
 169                 packet->GetOpcode());
 170         }
 171         else
 172         {
 173             OpcodeHandler& opHandle = opcodeTable[packet->GetOpcode()];
 174             switch (opHandle.status)
 175             {
 176                 case STATUS_LOGGEDIN:
 177                     if(!_player)
 178                     {
 179                         // skip STATUS_LOGGEDIN opcode unexpected errors if player logout sometime ago - this can be network lag delayed packets
 180                         if(!m_playerRecentlyLogout)
 181                             logUnexpectedOpcode(packet, "the player has not logged in yet");
 182                     }
 183                     else if(_player->IsInWorld())
 184                         (this->*opHandle.handler)(*packet);
 185                     // lag can cause STATUS_LOGGEDIN opcodes to arrive after the player started a transfer
 186                     break;
 187                 case STATUS_TRANSFER:
 188                     if(!_player)
 189                         logUnexpectedOpcode(packet, "the player has not logged in yet");
 190                     else if(_player->IsInWorld())
 191                         logUnexpectedOpcode(packet, "the player is still in world");
 192                     else
 193                         (this->*opHandle.handler)(*packet);
 194                     break;
 195                 case STATUS_AUTHED:
 196                     // prevent cheating with skip queue wait
 197                     if(m_inQueue)
 198                     {
 199                         logUnexpectedOpcode(packet, "the player not pass queue yet");
 200                         break;
 201                     }
 202
 203                     m_playerRecentlyLogout = false;
 204                     (this->*opHandle.handler)(*packet);
 205                     break;
 206                 case STATUS_NEVER:
 207                     sLog.outError( "SESSION: received not allowed opcode %s (0x%.4X)",
 208                         LookupOpcodeName(packet->GetOpcode()),
 209                         packet->GetOpcode());
 210                     break;
 211             }
 212         }
 213
 214         delete packet;
 215     }
 216
 217     ///- Cleanup socket pointer if need
 218     if (m_Socket && m_Socket->IsClosed ())
 219     {
 220         m_Socket->RemoveReference ();
 221         m_Socket = NULL;
 222     }
 223
 224     ///- If necessary, log the player out
 225     time_t currTime = time(NULL);
 226     if (!m_Socket || (ShouldLogOut(currTime) && !m_playerLoading))
 227         LogoutPlayer(true);
 228
 229     if (!m_Socket)
 230         return false;                                       //Will remove this session from the world session map
 231
 232     return true;
 233 }
 234
 235 /// %Log the player out
 236 void WorldSession::LogoutPlayer(bool Save)
 237 {
 238     // finish pending transfers before starting the logout
 239     while(_player && _player->IsBeingTeleportedFar())
 240         HandleMoveWorldportAckOpcode();
 241
 242     m_playerLogout = true;
 243
 244     if (_player)
 245     {
 246         if (uint64 lguid = GetPlayer()->GetLootGUID())
 247             DoLootRelease(lguid);
 248
 249         ///- If the player just died before logging out, make him appear as a ghost
 250         //FIXME: logout must be delayed in case lost connection with client in time of combat
 251         if (_player->GetDeathTimer())
 252         {
 253             _player->getHostilRefManager().deleteReferences();
 254             _player->BuildPlayerRepop();
 255             _player->RepopAtGraveyard();
 256         }
 257         else if (!_player->getAttackers().empty())
 258         {
 259             _player->CombatStop();
 260             _player->getHostilRefManager().setOnlineOfflineState(false);
 261             _player->RemoveAllAurasOnDeath();
 262
 263             // build set of player who attack _player or who have pet attacking of _player
 264             std::set<Player*> aset;
 265             for(Unit::AttackerSet::const_iterator itr = _player->getAttackers().begin(); itr != _player->getAttackers().end(); ++itr)
 266             {
 267                 Unit* owner = (*itr)->GetOwner();           // including player controlled case
 268                 if(owner)
 269                 {
 270                     if(owner->GetTypeId()==TYPEID_PLAYER)
 271                         aset.insert((Player*)owner);
 272                 }
 273                 else
 274                 if((*itr)->GetTypeId()==TYPEID_PLAYER)
 275                     aset.insert((Player*)(*itr));
 276             }
 277
 278             _player->SetPvPDeath(!aset.empty());
 279             _player->KillPlayer();
 280             _player->BuildPlayerRepop();
 281             _player->RepopAtGraveyard();
 282
 283             // give honor to all attackers from set like group case
 284             for(std::set<Player*>::const_iterator itr = aset.begin(); itr != aset.end(); ++itr)
 285                 (*itr)->RewardHonor(_player,aset.size());
 286
 287             // give bg rewards and update counters like kill by first from attackers
 288             // this can't be called for all attackers.
 289             if(!aset.empty())
 290                 if(BattleGround *bg = _player->GetBattleGround())
 291                     bg->HandleKillPlayer(_player,*aset.begin());
 292         }
 293         else if(_player->HasAuraType(SPELL_AURA_SPIRIT_OF_REDEMPTION))
 294         {
 295             // this will kill character by SPELL_AURA_SPIRIT_OF_REDEMPTION
 296             _player->RemoveSpellsCausingAura(SPELL_AURA_MOD_SHAPESHIFT);
 297             //_player->SetDeathPvP(*); set at SPELL_AURA_SPIRIT_OF_REDEMPTION apply time
 298             _player->KillPlayer();
 299             _player->BuildPlayerRepop();
 300             _player->RepopAtGraveyard();
 301         }
 302         //drop a flag if player is carrying it
 303         if(BattleGround *bg = _player->GetBattleGround())
 304             bg->EventPlayerLoggedOut(_player);
 305
 306         ///- Teleport to home if the player is in an invalid instance
 307         if(!_player->m_InstanceValid && !_player->isGameMaster())
 308             _player->TeleportTo(_player->m_homebindMapId, _player->m_homebindX, _player->m_homebindY, _player->m_homebindZ, _player->GetOrientation());
 309
 310         for (int i=0; i < PLAYER_MAX_BATTLEGROUND_QUEUES; ++i)
 311         {
 312             if(BattleGroundQueueTypeId bgQueueTypeId = _player->GetBattleGroundQueueTypeId(i))
 313             {
 314                 _player->RemoveBattleGroundQueueId(bgQueueTypeId);
 315                 sBattleGroundMgr.m_BattleGroundQueues[ bgQueueTypeId ].RemovePlayer(_player->GetGUID(), true);
 316             }
 317         }
 318
 319         ///- Reset the online field in the account table
 320         // no point resetting online in character table here as Player::SaveToDB() will set it to 1 since player has not been removed from world at this stage
 321         //No SQL injection as AccountID is uint32
 322         loginDatabase.PExecute("UPDATE account SET online = 0 WHERE id = '%u'", GetAccountId());
 323
 324         ///- If the player is in a guild, update the guild roster and broadcast a logout message to other guild members
 325         Guild *guild = objmgr.GetGuildById(_player->GetGuildId());
 326         if(guild)
 327         {
 328             guild->LoadPlayerStatsByGuid(_player->GetGUID());
 329             guild->UpdateLogoutTime(_player->GetGUID());
 330
 331             WorldPacket data(SMSG_GUILD_EVENT, (1+1+12+8)); // name limited to 12 in character table.
 332             data<<(uint8)GE_SIGNED_OFF;
 333             data<<(uint8)1;
 334             data<<_player->GetName();
 335             data<<_player->GetGUID();
 336             guild->BroadcastPacket(&data);
 337         }
 338
 339         ///- Remove pet
 340         _player->RemovePet(NULL,PET_SAVE_AS_CURRENT, true);
 341
 342         ///- empty buyback items and save the player in the database
 343         // some save parts only correctly work in case player present in map/player_lists (pets, etc)
 344         if(Save)
 345         {
 346             uint32 eslot;
 347             for(int j = BUYBACK_SLOT_START; j < BUYBACK_SLOT_END; ++j)
 348             {
 349                 eslot = j - BUYBACK_SLOT_START;
 350                 _player->SetUInt64Value(PLAYER_FIELD_VENDORBUYBACK_SLOT_1 + (eslot * 2), 0);
 351                 _player->SetUInt32Value(PLAYER_FIELD_BUYBACK_PRICE_1 + eslot, 0);
 352                 _player->SetUInt32Value(PLAYER_FIELD_BUYBACK_TIMESTAMP_1 + eslot, 0);
 353             }
 354             _player->SaveToDB();
 355         }
 356
 357         ///- Leave all channels before player delete...
 358         _player->CleanupChannels();
 359
 360         ///- If the player is in a group (or invited), remove him. If the group if then only 1 person, disband the group.
 361         _player->UninviteFromGroup();
 362
 363         // remove player from the group if he is:
 364         // a) in group; b) not in raid group; c) logging out normally (not being kicked or disconnected)
 365         if(_player->GetGroup() && !_player->GetGroup()->isRaidGroup() && m_Socket)
 366             _player->RemoveFromGroup();
 367
 368         ///- Remove the player from the world
 369         // the player may not be in the world when logging out
 370         // e.g if he got disconnected during a transfer to another map
 371         // calls to GetMap in this case may cause crashes
 372         if(_player->IsInWorld()) _player->GetMap()->Remove(_player, false);
 373         // RemoveFromWorld does cleanup that requires the player to be in the accessor
 374         ObjectAccessor::Instance().RemoveObject(_player);
 375
 376         ///- Send update to group
 377         if(_player->GetGroup())
 378             _player->GetGroup()->SendUpdate();
 379
 380         ///- Broadcast a logout message to the player's friends
 381         sSocialMgr.SendFriendStatus(_player, FRIEND_OFFLINE, _player->GetGUIDLow(), true);
 382
 383         ///- Delete the player object
 384         _player->CleanupsBeforeDelete();                    // do some cleanup before deleting to prevent crash at crossreferences to already deleted data
 385
 386         sSocialMgr.RemovePlayerSocial (_player->GetGUIDLow ());
 387         delete _player;
 388         _player = NULL;
 389
 390         ///- Send the 'logout complete' packet to the client
 391         WorldPacket data( SMSG_LOGOUT_COMPLETE, 0 );
 392         SendPacket( &data );
 393
 394         ///- Since each account can only have one online character at any given time, ensure all characters for active account are marked as offline
 395         //No SQL injection as AccountId is uint32
 396         CharacterDatabase.PExecute("UPDATE characters SET online = 0 WHERE account = '%u'",
 397             GetAccountId());
 398         sLog.outDebug( "SESSION: Sent SMSG_LOGOUT_COMPLETE Message" );
 399     }
 400
 401     m_playerLogout = false;
 402     m_playerRecentlyLogout = true;
 403     LogoutRequest(0);
 404 }
 405
 406 /// Kick a player out of the World
 407 void WorldSession::KickPlayer()
 408 {
 409     if (m_Socket)
 410         m_Socket->CloseSocket ();
 411 }
 412
 413 /// Cancel channeling handler
 414
 415 void WorldSession::SendAreaTriggerMessage(const char* Text, ...)
 416 {
 417     va_list ap;
 418     char szStr [1024];
 419     szStr[0] = '\0';
 420
 421     va_start(ap, Text);
 422     vsnprintf( szStr, 1024, Text, ap );
 423     va_end(ap);
 424
 425     uint32 length = strlen(szStr)+1;
 426     WorldPacket data(SMSG_AREA_TRIGGER_MESSAGE, 4+length);
 427     data << length;
 428     data << szStr;
 429     SendPacket(&data);
 430 }
 431
 432 void WorldSession::SendNotification(const char *format,...)
 433 {
 434     if(format)
 435     {
 436         va_list ap;
 437         char szStr [1024];
 438         szStr[0] = '\0';
 439         va_start(ap, format);
 440         vsnprintf( szStr, 1024, format, ap );
 441         va_end(ap);
 442
 443         WorldPacket data(SMSG_NOTIFICATION, (strlen(szStr)+1));
 444         data << szStr;
 445         SendPacket(&data);
 446     }
 447 }
 448
 449 void WorldSession::SendNotification(int32 string_id,...)
 450 {
 451     char const* format = GetMangosString(string_id);
 452     if(format)
 453     {
 454         va_list ap;
 455         char szStr [1024];
 456         szStr[0] = '\0';
 457         va_start(ap, string_id);
 458         vsnprintf( szStr, 1024, format, ap );
 459         va_end(ap);
 460
 461         WorldPacket data(SMSG_NOTIFICATION, (strlen(szStr)+1));
 462         data << szStr;
 463         SendPacket(&data);
 464     }
 465 }
 466
 467 void WorldSession::SendSetPhaseShift(uint32 PhaseShift)
 468 {
 469     WorldPacket data(SMSG_SET_PHASE_SHIFT, 4);
 470     data << uint32(PhaseShift);
 471     SendPacket(&data);
 472 }
 473
 474 const char * WorldSession::GetMangosString( int32 entry ) const
 475 {
 476     return objmgr.GetMangosString(entry,GetSessionDbLocaleIndex());
 477 }
 478
 479 void WorldSession::Handle_NULL( WorldPacket& recvPacket )
 480 {
 481     sLog.outError( "SESSION: received unhandled opcode %s (0x%.4X)",
 482         LookupOpcodeName(recvPacket.GetOpcode()),
 483         recvPacket.GetOpcode());
 484 }
 485
 486 void WorldSession::Handle_EarlyProccess( WorldPacket& recvPacket )
 487 {
 488     sLog.outError( "SESSION: received opcode %s (0x%.4X) that must be processed in WorldSocket::OnRead",
 489         LookupOpcodeName(recvPacket.GetOpcode()),
 490         recvPacket.GetOpcode());
 491 }
 492
 493 void WorldSession::Handle_ServerSide( WorldPacket& recvPacket )
 494 {
 495     sLog.outError( "SESSION: received server-side opcode %s (0x%.4X)",
 496         LookupOpcodeName(recvPacket.GetOpcode()),
 497         recvPacket.GetOpcode());
 498 }
 499
 500 void WorldSession::Handle_Deprecated( WorldPacket& recvPacket )
 501 {
 502     sLog.outError( "SESSION: received deprecated opcode %s (0x%.4X)",
 503         LookupOpcodeName(recvPacket.GetOpcode()),
 504         recvPacket.GetOpcode());
 505 }
 506
 507 void WorldSession::SendAuthWaitQue(uint32 position)
 508 {
 509     if(position == 0)
 510     {
 511         WorldPacket packet( SMSG_AUTH_RESPONSE, 1 );
 512         packet << uint8( AUTH_OK );
 513         SendPacket(&packet);
 514     }
 515     else
 516     {
 517         WorldPacket packet( SMSG_AUTH_RESPONSE, 5 );
 518         packet << uint8( AUTH_WAIT_QUEUE );
 519         packet << uint32 (position);
 520         SendPacket(&packet);
 521     }
 522 }
 523
 524 void WorldSession::LoadAccountData()
 525 {
 526     for (uint32 i = 0; i < NUM_ACCOUNT_DATA_TYPES; ++i)
 527     {
 528         AccountData data;
 529         m_accountData[i] = data;
 530     }
 531
 532     QueryResult *result = CharacterDatabase.PQuery("SELECT type, time, data FROM account_data WHERE account='%u'", GetAccountId());
 533
 534     if(!result)
 535         return;
 536
 537     do
 538     {
 539         Field *fields = result->Fetch();
 540
 541         uint32 type = fields[0].GetUInt32();
 542         if(type < NUM_ACCOUNT_DATA_TYPES)
 543         {
 544             m_accountData[type].Time = fields[1].GetUInt32();
 545             m_accountData[type].Data = fields[2].GetCppString();
 546         }
 547     } while (result->NextRow());
 548
 549     delete result;
 550 }
 551
 552 void WorldSession::SetAccountData(uint32 type, time_t time_, std::string data)
 553 {
 554     m_accountData[type].Time = time_;
 555     m_accountData[type].Data = data;
 556
 557     uint32 acc = GetAccountId();
 558
 559     CharacterDatabase.BeginTransaction ();
 560     CharacterDatabase.PExecute("DELETE FROM account_data WHERE account='%u' AND type='%u'", acc, type);
 561     CharacterDatabase.escape_string(data);
 562     CharacterDatabase.PExecute("INSERT INTO account_data VALUES ('%u','%u','%u','%s')", acc, type, (uint32)time_, data.c_str());
 563     CharacterDatabase.CommitTransaction ();
 564 }
 565
 566 void WorldSession::ReadMovementInfo(WorldPacket &data, MovementInfo *mi)
 567 {
 568     CHECK_PACKET_SIZE(data, data.rpos()+4+2+4+4+4+4+4);
 569     data >> mi->flags;
 570     data >> mi->unk1;
 571     data >> mi->time;
 572     data >> mi->x;
 573     data >> mi->y;
 574     data >> mi->z;
 575     data >> mi->o;
 576
 577     if(mi->flags & MOVEMENTFLAG_ONTRANSPORT)
 578     {
 579         CHECK_PACKET_SIZE(data, data.rpos()+8+4+4+4+4+4+1);
 580         data >> mi->t_guid;
 581         data >> mi->t_x;
 582         data >> mi->t_y;
 583         data >> mi->t_z;
 584         data >> mi->t_o;
 585         data >> mi->t_time;
 586         data >> mi->t_seat;
 587     }
 588
 589     if((mi->flags & (MOVEMENTFLAG_SWIMMING | MOVEMENTFLAG_FLYING2)) || (mi->unk1 & 0x20))
 590     {
 591         CHECK_PACKET_SIZE(data, data.rpos()+4);
 592         data >> mi->s_pitch;
 593     }
 594
 595     CHECK_PACKET_SIZE(data, data.rpos()+4);
 596     data >> mi->fallTime;
 597
 598     if(mi->flags & MOVEMENTFLAG_JUMPING)
 599     {
 600         CHECK_PACKET_SIZE(data, data.rpos()+4+4+4+4);
 601         data >> mi->j_unk;
 602         data >> mi->j_sinAngle;
 603         data >> mi->j_cosAngle;
 604         data >> mi->j_xyspeed;
 605     }
 606
 607     if(mi->flags & MOVEMENTFLAG_SPLINE)
 608     {
 609         CHECK_PACKET_SIZE(data, data.rpos()+4);
 610         data >> mi->u_unk1;
 611     }
 612 }
 613
 614 void WorldSession::ReadAddonsInfo(WorldPacket &data)
 615 {
 616     if (data.rpos() + 4 > data.size())
 617         return;
 618     uint32 size;
 619     data >> size;
 620
 621     if(!size)
 622         return;
 623
 624     uLongf uSize = size;
 625
 626     uint32 pos = data.rpos();
 627
 628     ByteBuffer addonInfo;
 629     addonInfo.resize(size);
 630
 631     if (uncompress(const_cast<uint8*>(addonInfo.contents()), &uSize, const_cast<uint8*>(data.contents() + pos), data.size() - pos) == Z_OK)
 632     {
 633         uint32 addonsCount;
 634         addonInfo >> addonsCount;                         // addons count
 635
 636         for(uint32 i = 0; i < addonsCount; ++i)
 637         {
 638             std::string addonName;
 639             uint8 enabled;
 640             uint32 crc, unk1;
 641
 642             // check next addon data format correctness
 643             if(addonInfo.rpos()+1 > addonInfo.size())
 644                 return;
 645
 646             addonInfo >> addonName;
 647
 648             // recheck next addon data format correctness
 649             if(addonInfo.rpos()+1+4+4 > addonInfo.size())
 650                 return;
 651
 652             addonInfo >> enabled >> crc >> unk1;
 653
 654             sLog.outDebug("ADDON: Name: %s, Enabled: 0x%x, CRC: 0x%x, Unknown2: 0x%x", addonName.c_str(), enabled, crc, unk1);
 655
 656             m_addonsList.push_back(AddonInfo(addonName, enabled, crc));
 657         }
 658
 659         uint32 unk2;
 660         addonInfo >> unk2;
 661
 662         if(addonInfo.rpos() != addonInfo.size())
 663             sLog.outDebug("packet under read!");
 664     }
 665     else
 666         sLog.outError("Addon packet uncompress error!");
 667 }
 668
 669 void WorldSession::SendAddonsInfo()
 670 {
 671     unsigned char tdata[256] =
 672     {
 673         0xC3, 0x5B, 0x50, 0x84, 0xB9, 0x3E, 0x32, 0x42, 0x8C, 0xD0, 0xC7, 0x48, 0xFA, 0x0E, 0x5D, 0x54,
 674         0x5A, 0xA3, 0x0E, 0x14, 0xBA, 0x9E, 0x0D, 0xB9, 0x5D, 0x8B, 0xEE, 0xB6, 0x84, 0x93, 0x45, 0x75,
 675         0xFF, 0x31, 0xFE, 0x2F, 0x64, 0x3F, 0x3D, 0x6D, 0x07, 0xD9, 0x44, 0x9B, 0x40, 0x85, 0x59, 0x34,
 676         0x4E, 0x10, 0xE1, 0xE7, 0x43, 0x69, 0xEF, 0x7C, 0x16, 0xFC, 0xB4, 0xED, 0x1B, 0x95, 0x28, 0xA8,
 677         0x23, 0x76, 0x51, 0x31, 0x57, 0x30, 0x2B, 0x79, 0x08, 0x50, 0x10, 0x1C, 0x4A, 0x1A, 0x2C, 0xC8,
 678         0x8B, 0x8F, 0x05, 0x2D, 0x22, 0x3D, 0xDB, 0x5A, 0x24, 0x7A, 0x0F, 0x13, 0x50, 0x37, 0x8F, 0x5A,
 679         0xCC, 0x9E, 0x04, 0x44, 0x0E, 0x87, 0x01, 0xD4, 0xA3, 0x15, 0x94, 0x16, 0x34, 0xC6, 0xC2, 0xC3,
 680         0xFB, 0x49, 0xFE, 0xE1, 0xF9, 0xDA, 0x8C, 0x50, 0x3C, 0xBE, 0x2C, 0xBB, 0x57, 0xED, 0x46, 0xB9,
 681         0xAD, 0x8B, 0xC6, 0xDF, 0x0E, 0xD6, 0x0F, 0xBE, 0x80, 0xB3, 0x8B, 0x1E, 0x77, 0xCF, 0xAD, 0x22,
 682         0xCF, 0xB7, 0x4B, 0xCF, 0xFB, 0xF0, 0x6B, 0x11, 0x45, 0x2D, 0x7A, 0x81, 0x18, 0xF2, 0x92, 0x7E,
 683         0x98, 0x56, 0x5D, 0x5E, 0x69, 0x72, 0x0A, 0x0D, 0x03, 0x0A, 0x85, 0xA2, 0x85, 0x9C, 0xCB, 0xFB,
 684         0x56, 0x6E, 0x8F, 0x44, 0xBB, 0x8F, 0x02, 0x22, 0x68, 0x63, 0x97, 0xBC, 0x85, 0xBA, 0xA8, 0xF7,
 685         0xB5, 0x40, 0x68, 0x3C, 0x77, 0x86, 0x6F, 0x4B, 0xD7, 0x88, 0xCA, 0x8A, 0xD7, 0xCE, 0x36, 0xF0,
 686         0x45, 0x6E, 0xD5, 0x64, 0x79, 0x0F, 0x17, 0xFC, 0x64, 0xDD, 0x10, 0x6F, 0xF3, 0xF5, 0xE0, 0xA6,
 687         0xC3, 0xFB, 0x1B, 0x8C, 0x29, 0xEF, 0x8E, 0xE5, 0x34, 0xCB, 0xD1, 0x2A, 0xCE, 0x79, 0xC3, 0x9A,
 688         0x0D, 0x36, 0xEA, 0x01, 0xE0, 0xAA, 0x91, 0x20, 0x54, 0xF0, 0x72, 0xD8, 0x1E, 0xC7, 0x89, 0xD2
 689     };
 690
 691     WorldPacket data(SMSG_ADDON_INFO, 4);
 692
 693     for(AddonsList::iterator itr = m_addonsList.begin(); itr != m_addonsList.end(); ++itr)
 694     {
 695         uint8 state = 2;                                    // 2 is sent here
 696         data << uint8(state);
 697
 698         uint8 unk1 = 1;                                     // 1 is sent here
 699         data << uint8(unk1);
 700         if (unk1)
 701         {
 702             uint8 unk2 = (itr->CRC != 0x4c1c776d);          // If addon is Standard addon CRC
 703             data << uint8(unk2);
 704             if (unk2)                                       // if CRC is wrong, add public key (client need it)
 705                 data.append(tdata, sizeof(tdata));
 706
 707             data << uint32(0);
 708         }
 709
 710         uint8 unk3 = 0;                                     // 0 is sent here
 711         data << uint8(unk3);
 712         if (unk3)
 713         {
 714             // String, 256 (null terminated?)
 715             data << uint8(0);
 716         }
 717     }
 718
 719     m_addonsList.clear();
 720
 721     uint32 count = 0;
 722     data << uint32(count);
 723     /*for(uint32 i = 0; i < count; ++i)
 724     {
 725         uint32
 726         string (16 bytes)
 727         string (16 bytes)
 728         uint32
 729     }*/
 730
 731     SendPacket(&data);
 732 }