Files
wowdecomp/WoW/Source/Net/NetClient/NetClient.cpp
T
SatyandClaude Opus 5.5 3b76648777 Client bring-up: Lua stand-in ports, add-on loading, world map, combat log, locale fix
- Port hit-order Lua stand-ins (unit tokens, tooltips, combat log filters and
  current entry, bags/containers, quest POI, minimap, titles, world states,
  trade, group roles, runes, mirror timers, saved-variable registration, Quit)
- LoadAddOn: real add-on loading (Blizzard_CombatLog etc. now load)
- CombatLogEntry::PushEvent: COMBAT_LOG_EVENT arguments
- World map chain: SetMapToCurrentZone, SetMap, GetWorldPosition, landmarks,
  overlays, highlight, zones, dungeon levels, player position
- OpenArchives: locale index was off by one (enUS read the koKR DBC slot,
  leaving zone/map names empty)
- Zone/area sound chain, invisible units (spline mode read size), raid/bag
  crash fixes, stand-in console, waystone icon for all executables
- Coding-rule cleanups: statics/includes at the top, event enums, Lua
  _Scripts layout

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
2026-09-30 06:31:10 +02:00

809 lines
22 KiB
C++

#include "NetClient.h"
#include <cstdlib>
#include <cstring>
#include <new>
#include "Engine/Source/Base/Prop.h"
#include "Engine/Source/ConsoleBase/IConsole.h"
#include "Engine/Source/Event/Types.h"
#include "Engine/Source/Os/TimeManager.h"
#include "Engine/Source/Storm/H/storm.h"
#include "WoW/Source/Glue/CGlueMgr.h"
#include "_Triage/SHA1.h"
// STATIC: 0x00AD2ED0
static TSList<NETCLIENTNODE> s_clientList;
// STATIC: 0x00C5D624
static HPROPCONTEXT s_propContext;
// STATIC: 0x00C5D628
static uint32_t s_stats[6];
// STATIC: 0x00C5D640
static uint32_t s_initializeTime;
// STATIC: 0x00C5D644
static uint32_t s_idleStats[4];
// STATIC: 0x00C5D654
uint32_t NetClient::s_clientCount;
// VERIFY: 44b868cd manual
// OFFSET: 0x006321B0
static bool __stdcall ComputeProofOfWork(const SHA1_CONTEXT* context, uint32_t difficulty, uint64_t* proof) {
uint64_t nonce = 0;
while (true) {
SHA1_CONTEXT attempt;
memcpy(&attempt, context, sizeof(attempt));
SHA1_Update(&attempt, reinterpret_cast<const uint8_t*>(&nonce), sizeof(nonce));
uint8_t digest[20];
SHA1_Final(digest, &attempt);
uint8_t bits = 0;
int32_t i = 0;
while (!digest[i]) {
i++;
bits += 8;
if (i >= 20) {
break;
}
}
if (i < 20) {
for (uint8_t value = digest[i]; !(value & 1); value >>= 1) {
bits++;
}
}
if (bits >= difficulty) {
break;
}
if (++nonce == 0) {
return false;
}
}
*proof = nonce;
return true;
}
// VERIFY: 0b11eb2d auto
// OFFSET: 0x00633330
void NetClient::WCMessageReady(WowConnection* connection, uint32_t timeStamp, CDataStore* msg) {
uint32_t size = msg->m_size;
void* data;
msg->GetDataInSitu(data, size);
InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(&this->m_bytesReceived), msg->m_size);
msg->m_read = 0;
uint16_t msgId;
msg->Get(msgId);
switch (msgId) {
case SMSG_CONNECT_TO:
this->HandleRedirectClient(connection, msg);
return;
case SMSG_PONG:
this->HandlePong(connection, msg);
return;
case SMSG_AUTH_CHALLENGE:
this->HandleAuthChallenge(connection, msg);
return;
case SMSG_SUSPEND_COMMS:
this->HandleSuspendComms(connection, msg);
return;
case SMSG_RESUME_COMMS:
this->HandleResumeComms(connection, msg);
return;
default:
break;
}
if (connection == this->m_serverConnection && !this->m_suspended) {
msg->m_read = msg->m_size;
this->m_netEventQueue->AddEvent(EVENT_ID_NET_DATA, connection, this, data, size);
} else {
connection->Disconnect();
}
}
// VERIFY: 74c166be manual
// OFFSET: 0x00633440
NETEVENTQUEUE::NETEVENTQUEUE(NetClient* client) {
this->m_client = client;
}
// VERIFY: eb4e833d manual
// OFFSET: 0x006334F0
void NETEVENTQUEUE::Poll() {
this->m_critSect.Enter();
bool destroyed = false;
this->m_client->m_refCount.Increment();
for (NETEVENTQUEUENODE* node = this->m_eventQueue.Head(); node; node = this->m_eventQueue.Next(node)) {
NetClient* client = this->m_client;
if (!client->m_deleteMe) {
switch (node->m_eventId) {
case EVENT_ID_NET_DATA:
client->HandleData(node->m_timeReceived, node->m_data, node->m_dataSize);
break;
case EVENT_ID_NET_CONNECT:
client->HandleConnect();
break;
case EVENT_ID_NET_DISCONNECT:
client->HandleDisconnect();
break;
case EVENT_ID_NET_CANTCONNECT:
client->HandleCantConnect();
break;
case EVENT_ID_NET_DESTROY:
client->m_deleteMe = true;
destroyed = true;
break;
case EVENT_ID_NET_AUTH_CHALLENGE:
client->HandleAuthChallenge(static_cast<AuthenticationChallenge*>(node->m_data));
break;
default:
break;
}
}
client = this->m_client;
if (client->m_refCount.Decrement() == 0 && client->m_deleteMe) {
delete client;
}
}
if (!destroyed) {
this->m_client->HandleIdle();
}
NetClient* client = this->m_client;
if (client->m_refCount.Decrement() == 0 && client->m_deleteMe) {
delete client;
}
this->m_eventQueue.Clear();
this->m_critSect.Leave();
}
// VERIFY: dd90b2c3 auto
// OFFSET: 0x00631D10
static void InitializePropContext() {
if (PropGetSelectedContext() != s_propContext) {
PropSelectContext(s_propContext);
}
}
// VERIFY: 8093d1d7 manual
// OFFSET: 0x00631D30
int32_t NetClient::Initialize() {
if (!NetClient::s_clientCount) {
s_propContext = PropGetSelectedContext();
int32_t result = WowConnection::InitOsNet(nullptr, InitializePropContext, 1, false);
if (!result) {
return result;
}
}
NetClient::s_clientCount++;
this->m_netEventQueue = new (SMemAlloc(sizeof(NETEVENTQUEUE), __FILE__, __LINE__, 0)) NETEVENTQUEUE(this);
memset(this->m_handlers, 0, sizeof(this->m_handlers));
memset(this->m_handlerParams, 0, sizeof(this->m_handlerParams));
this->m_serverConnection = new (SMemAlloc(sizeof(WowConnection), __FILE__, __LINE__, 0)) WowConnection(this, nullptr);
this->m_netState = NS_INITIALIZED;
s_initializeTime = OsGetAsyncTimeMs();
return 1;
}
// VERIFY: 22bd59ed auto
// OFFSET: 0x00631E10
int32_t NetClient::ConnectInternal(const char* host, uint16_t port) {
if (this->m_netState != NS_INITIALIZED) {
SErrDisplayAppFatal("Expected (m_netState == NS_INITIALIZED), got %d", this->m_netState);
}
this->m_netState = NS_CONNECTING;
this->m_serverConnection->Connect(host, port, -1);
if (this->m_redirectConnection) {
this->m_redirectConnection->SetResponse(nullptr, false);
this->m_redirectConnection->Disconnect();
this->m_redirectConnection->Release();
this->m_redirectConnection = nullptr;
}
return 1;
}
// VERIFY: 0454197e auto
// OFFSET: 0x00631F70
void NetClient::SetLoginData(LoginData* loginData) {
memcpy(&this->m_loginData, loginData, sizeof(this->m_loginData));
}
// VERIFY: f1080d7c auto
// OFFSET: 0x00631FA0
void NetClient::SetMessageHandler(NETMESSAGE msgId, MESSAGE_HANDLER handler, void* param) {
this->m_handlers[msgId] = handler;
this->m_handlerParams[msgId] = param;
}
// VERIFY: acb4d340 auto
// OFFSET: 0x00631FC0
void NetClient::ResetHandler(NETMESSAGE msgId) {
this->m_handlers[msgId] = nullptr;
this->m_handlerParams[msgId] = nullptr;
}
// VERIFY: 59f00590 auto
// OFFSET: 0x00631FE0
int32_t NetClient::ProcessMessage(uint32_t timeReceived, CDataStore* msg, int32_t a4) {
s_stats[4]++;
uint16_t msgId;
msg->Get(msgId);
this->ValidateMessageId(msgId);
if (msgId < NUM_MSG_TYPES && this->m_handlers[msgId]) {
return this->m_handlers[msgId](this->m_handlerParams[msgId], static_cast<NETMESSAGE>(msgId), timeReceived, msg);
}
msg->Reset();
return 0;
}
void NetClient::ValidateMessageId(uint32_t msgId) {
}
// VERIFY: eb4bad4d auto
// OFFSET: 0x00632060
void NetClient::WCConnected(WowConnection* connection, WowConnection* inbound, uint32_t timeStamp, const NETCONNADDR* addr) {
if (connection != this->m_serverConnection) {
return;
}
this->m_pingLock.Enter();
this->m_connectedTimestamp = timeStamp;
this->m_bytesReceived = 0;
this->m_bytesSent = 0;
this->m_latencyStart = 0;
this->m_latencyEnd = 0;
this->m_pingSent = OsGetAsyncTimeMs();
this->m_pingLock.Leave();
this->m_netEventQueue->AddEvent(EVENT_ID_NET_CONNECT, connection, this, nullptr, 0);
}
// VERIFY: d632b494 manual
// OFFSET: 0x006320D0
void NetClient::GetNetStats(float& bytesIn, float& bytesOut, uint32_t& latency) {
this->m_pingLock.Enter();
double elapsed = (OsGetAsyncTimeMs() - this->m_connectedTimestamp) * 0.001;
bytesIn = this->m_bytesReceived * 0.0009765625 / elapsed;
bytesOut = 0.0009765625 * this->m_bytesSent / elapsed;
uint32_t count = 0;
uint32_t total = 0;
uint32_t index = this->m_latencyStart;
uint32_t end = this->m_latencyEnd;
while (index != end) {
if (index >= 16) {
index = 0;
if (!end) {
break;
}
}
total += this->m_latency[index++];
count++;
}
latency = count ? total / count : 0;
this->m_pingLock.Leave();
}
// VERIFY: 2549c452 auto
// OFFSET: 0x006321A0
void NetClient::PollEventQueue() {
this->m_netEventQueue->Poll();
}
// VERIFY: 1eecebd5 auto
// OFFSET: 0x006323C0
int32_t NetClient::Connect(const char* address) {
if (this->m_netState != NS_INITIALIZED) {
SErrDisplayAppFatal("Expected (m_netState == NS_INITIALIZED), got %d", this->m_netState);
}
uint16_t port = 9090;
char host[1024];
SStrCopy(host, address, sizeof(host));
char* separator = SStrChr(host, ':');
if (separator) {
*separator = '\0';
port = atol(separator + 1);
}
this->m_serverConnection->SetEncryption(false);
this->m_netState = NS_INITIALIZED;
return this->ConnectInternal(host, port);
}
// VERIFY: f0345188 manual
// OFFSET: 0x00632460
int32_t NetClient::HandleData(uint32_t timeReceived, void* data, int32_t size) {
if (this->m_objMgr) {
NetClient::PushObjMgr(this->m_objMgr);
}
s_stats[3] += size + 2;
if (this->m_netState == NS_CONNECTED) {
CDataStore msg(static_cast<uint8_t*>(data), size);
this->ProcessMessage(timeReceived, &msg, 0);
}
NetClient::PopObjMgr();
return 1;
}
// VERIFY: 72928567 auto
// OFFSET: 0x00632510
int32_t NetClient::HandleConnect() {
if (this->m_objMgr) {
NetClient::PushObjMgr(this->m_objMgr);
}
this->m_netState = NS_CONNECTED;
NetClient::PopObjMgr();
return 1;
}
// VERIFY: df419859 auto
// OFFSET: 0x00632540
int32_t NetClient::HandleDisconnect() {
if (this->m_objMgr) {
NetClient::PushObjMgr(this->m_objMgr);
}
this->m_netState = NS_INITIALIZED;
ConsolePrintf("NetClient::HandleDisconnect()");
CGlueMgr::NetDisconnectHandler(this);
NetClient::PopObjMgr();
return 1;
}
// VERIFY: 251c34c2 auto
// OFFSET: 0x00632590
int32_t NetClient::HandleCantConnect() {
if (this->m_objMgr) {
NetClient::PushObjMgr(this->m_objMgr);
}
this->m_netState = NS_INITIALIZED;
NetClient::PopObjMgr();
return 1;
}
// VERIFY: 5652082f auto
// OFFSET: 0x006325C0
void NetClient::HandlePong(WowConnection* connection, CDataStore* msg) {
if (connection != this->m_serverConnection || this->m_suspended) {
connection->Disconnect();
return;
}
this->m_pingLock.Enter();
uint32_t sequence;
msg->Get(sequence);
if (sequence != this->m_pingSequence) {
ConsolePrintf("Received pong with old sequence");
this->m_pingLock.Leave();
return;
}
this->m_latency[this->m_latencyEnd++] = OsGetAsyncTimeMs() - this->m_pingSent;
if (this->m_latencyEnd >= 16) {
this->m_latencyEnd = 0;
}
if (this->m_latencyEnd == this->m_latencyStart) {
if (++this->m_latencyStart >= 16) {
this->m_latencyStart = 0;
}
}
this->m_pingLock.Leave();
}
// VERIFY: 1421ef4d manual
// OFFSET: 0x00632690
void NetClient::EnableEncryption(WowConnection* connection, const uint8_t* seed, uint8_t seedLength) {
connection->SetEncryptionKey(this->m_loginData.m_sessionKey, sizeof(this->m_loginData.m_sessionKey), 1, seed, seedLength);
connection->m_uint375 = 4;
connection->m_uint376 = 2;
connection->SetEncryption(true);
}
// VERIFY: 08d8deb0 auto
// OFFSET: 0x006326D0
void NetClient::WCDisconnected(WowConnection* connection, uint32_t timeStamp, const NETCONNADDR* addr) {
this->m_pingLock.Enter();
OsGetAsyncTimeMs();
float bytesIn;
float bytesOut;
uint32_t latency;
this->GetNetStats(bytesIn, bytesOut, latency);
this->m_pingLock.Leave();
if (this->m_netEventQueue) {
this->m_netEventQueue->AddEvent(EVENT_ID_NET_DISCONNECT, connection, this, nullptr, 0);
}
}
// VERIFY: 4a65a25e manual
// OFFSET: 0x00632730
void NetClient::HandleAuthChallenge(WowConnection* connection, CDataStore* msg) {
AuthenticationChallenge* challenge = static_cast<AuthenticationChallenge*>(SMemAlloc(sizeof(AuthenticationChallenge), __FILE__, __LINE__, 0));
uint32_t difficulty;
msg->Get(difficulty);
msg->Get(challenge->m_serverSeed);
uint32_t seeds[8];
for (int32_t i = 0; i < 8; i++) {
msg->Get(seeds[i]);
}
SHA1_CONTEXT context;
SHA1_Init(&context);
SHA1_Update(&context, reinterpret_cast<const uint8_t*>(this->m_loginData.m_account), SStrLen(this->m_loginData.m_account));
for (int32_t i = 0; i < 8; i++) {
SHA1_Update(&context, reinterpret_cast<const uint8_t*>(&seeds[i]), sizeof(seeds[i]));
}
if (!ComputeProofOfWork(&context, difficulty, &challenge->m_proof)) {
connection->Disconnect();
} else if (connection == this->m_serverConnection) {
this->m_netEventQueue->AddEvent(EVENT_ID_NET_AUTH_CHALLENGE, connection, this, challenge, sizeof(AuthenticationChallenge));
} else if (connection == this->m_redirectConnection) {
CDataStore reply;
reply.Put(static_cast<uint32_t>(CMSG_AUTH_CONTINUED_SESSION));
reply.PutString(this->m_loginData.m_account);
reply.Put(challenge->m_proof);
SHA1_Init(&context);
SHA1_Update(&context, reinterpret_cast<const uint8_t*>(this->m_loginData.m_account), SStrLen(this->m_loginData.m_account));
SHA1_Update(&context, this->m_loginData.m_sessionKey, sizeof(this->m_loginData.m_sessionKey));
SHA1_Update(&context, reinterpret_cast<const uint8_t*>(&challenge->m_serverSeed), sizeof(challenge->m_serverSeed));
uint8_t digest[20];
SHA1_Final(digest, &context);
reply.PutData(digest, sizeof(digest));
reply.Finalize();
this->m_redirectConnection->SendPacket(&reply, 0);
WowConnection* redirect = this->m_redirectConnection;
redirect->SetEncryptionKey(this->m_loginData.m_sessionKey, sizeof(this->m_loginData.m_sessionKey), 1, reinterpret_cast<const uint8_t*>(seeds), sizeof(seeds));
redirect->m_uint375 = 4;
redirect->m_uint376 = 2;
redirect->SetEncryption(true);
} else {
connection->Disconnect();
}
if (challenge) {
SMemFree(challenge, "delete", SLOG_FUNCTION, 0);
}
}
// VERIFY: 1f76bddf manual
// OFFSET: 0x00632A40
NetClient::NetClient() {
this->m_netState = NS_UNINITIALIZED;
this->m_netEventQueue = nullptr;
this->m_serverConnection = nullptr;
this->m_redirectConnection = nullptr;
this->m_suspended = false;
this->m_refCount.m_value = 0;
this->m_deleteMe = false;
this->m_pingSent = 0;
this->m_pingSequence = 0;
this->m_bytesSent = 0;
this->m_bytesReceived = 0;
this->m_connectedTimestamp = 0;
this->m_objMgr = nullptr;
NETCLIENTNODE* node = s_clientList.NewNode(2, 0, 0);
node->m_client = this;
}
// VERIFY: 3e4c9045 manual
// OFFSET: 0x00632B50
void NetClient::Send(CDataStore* msg) {
if (this->m_netState != NS_CONNECTED) {
return;
}
uint32_t size = msg->m_size - msg->m_read;
if (!size) {
return;
}
if (this->m_suspended) {
NetClient::HELDMESSAGE* held = this->m_heldMessages.NewNode(2, 0, 0);
uint32_t bytes = msg->m_size - msg->m_read;
void* data;
msg->GetDataInSitu(data, bytes);
held->m_msg.PutData(data, bytes);
held->m_msg.Finalize();
return;
}
this->m_serverConnection->SendPacket(msg, 0);
WowConnection* connection = this->m_serverConnection;
s_stats[0] += size;
s_stats[1]++;
this->m_bytesSent += size;
if (!connection->m_encrypt) {
this->EnableEncryption(connection, nullptr, 0);
}
}
// VERIFY: 8b86ade7 manual
// OFFSET: 0x00632C10
void NetClient::WCCantConnect(WowConnection* connection, uint32_t timeStamp, const NETCONNADDR* addr) {
if (connection == this->m_redirectConnection) {
CDataStore msg;
msg.Put(static_cast<uint32_t>(CMSG_CONNECT_TO_FAILED));
msg.Put(this->unk_2E40);
msg.Finalize();
this->Send(&msg);
this->m_redirectConnection->Release();
this->m_redirectConnection = nullptr;
} else if (connection == this->m_serverConnection) {
this->m_netEventQueue->AddEvent(EVENT_ID_NET_CANTCONNECT, connection, this, nullptr, 0);
}
}
// VERIFY: af338d14 manual
// OFFSET: 0x00632CD0
void NetClient::Ping() {
if (!this->m_serverConnection->m_encrypt) {
return;
}
CDataStore msg;
this->m_pingLock.Enter();
this->m_pingSent = OsGetAsyncTimeMs();
msg.Put(static_cast<uint32_t>(CMSG_PING));
msg.Put(++this->m_pingSequence);
if (this->m_netState == NS_CONNECTED) {
if (this->m_latencyEnd) {
msg.Put(this->m_latency[this->m_latencyEnd - 1]);
} else {
msg.Put(static_cast<uint32_t>(0));
}
}
this->m_pingLock.Leave();
msg.Finalize();
this->Send(&msg);
}
// VERIFY: 55fb6d51 auto
// OFFSET: 0x00632DB0
void NetClient::HandleIdle() {
s_idleStats[0] = s_stats[0];
s_idleStats[1] = s_stats[3];
s_idleStats[2] = s_stats[1];
s_idleStats[3] = s_stats[4];
if (static_cast<int32_t>(OsGetAsyncTimeMs() - this->m_pingSent - 30000) >= 0) {
this->Ping();
}
}
// VERIFY: 4b27bdaa manual
// OFFSET: 0x00631EA0
void NetClient::Disconnect() {
if (this->m_redirectConnection) {
this->m_redirectConnection->SetResponse(nullptr, false);
this->m_redirectConnection->Disconnect();
this->m_redirectConnection->Release();
this->m_redirectConnection = nullptr;
}
if (this->m_netState == NS_CONNECTED) {
this->m_netState = NS_UNK_6;
this->m_serverConnection->Disconnect();
return;
}
this->m_serverConnection->SetResponse(nullptr, false);
this->m_serverConnection->Disconnect();
this->m_netEventQueue->Clear();
this->m_serverConnection->Release();
this->m_serverConnection = new (SMemAlloc(sizeof(WowConnection), __FILE__, __LINE__, 0)) WowConnection(this, nullptr);
this->m_netState = NS_INITIALIZED;
}
// VERIFY: 7891283c manual
// OFFSET: 0x006322A0
void NetClient::Destroy() {
if (this->m_netState == NS_UNINITIALIZED) {
return;
}
this->Disconnect();
this->m_serverConnection->SetResponse(nullptr, false);
this->m_serverConnection->Release();
this->m_serverConnection = nullptr;
memset(this->m_handlers, 0, sizeof(this->m_handlers));
memset(this->m_handlerParams, 0, sizeof(this->m_handlerParams));
delete this->m_netEventQueue;
this->m_netEventQueue = nullptr;
if (--NetClient::s_clientCount == 0) {
OsSleep(1);
WowConnection::DestroyOsNet();
}
this->m_netState = NS_UNINITIALIZED;
if (!NetClient::s_clientCount) {
ConsolePrintf("Client net stats: %Lu bytes sent, %Lu bytes received, %Lu msec elapsed", s_stats[0], s_stats[3], OsGetAsyncTimeMs() - s_initializeTime);
}
}
// VERIFY: a5e5149c manual
// OFFSET: 0x006331B0
NetClient::~NetClient() {
this->Destroy();
for (NETCLIENTNODE* node = s_clientList.Head(); node; node = s_clientList.Next(node)) {
if (node->m_client == this) {
s_clientList.DeleteNode(node);
break;
}
}
}
// VERIFY: 4136bd3d auto
// OFFSET: 0x00633630
void NETEVENTQUEUE::Clear() {
this->m_critSect.Enter();
this->m_eventQueue.Clear();
this->m_critSect.Leave();
}
// VERIFY: 796de75c manual
// OFFSET: 0x00633650
void NETEVENTQUEUE::AddEvent(EVENTID eventId, void* connection, NetClient* client, const void* data, uint32_t size) {
this->m_critSect.Enter();
NETEVENTQUEUENODE* node = this->m_eventQueue.NewNode(2, 0, 8);
node->m_eventId = eventId;
if (size) {
node->m_data = SMemAlloc(size, __FILE__, __LINE__, 0);
memcpy(node->m_data, data, size);
node->m_dataSize = size;
} else {
node->m_data = nullptr;
node->m_dataSize = 0;
}
node->m_timeReceived = OsGetAsyncTimeMs();
client->m_refCount.Increment();
this->m_critSect.Leave();
}
// VERIFY: 4d2c7b3d manual
// OFFSET: 0x00633730
NETEVENTQUEUE::~NETEVENTQUEUE() {
this->m_critSect.Enter();
this->m_eventQueue.Clear();
this->m_critSect.Leave();
}
// VERIFY: 75864678 auto
// OFFSET: 0x00633020
void NetClient::HandleSuspendComms(WowConnection* connection, CDataStore* msg) {
if (connection != this->m_serverConnection || this->m_suspended || !this->m_redirectConnection) {
connection->Disconnect();
return;
}
uint32_t serial = 0;
msg->Get(serial);
if (!msg->IsRead() || msg->m_read > msg->m_size) {
connection->Disconnect();
return;
}
CDataStore ack;
ack.Put(static_cast<uint32_t>(CMSG_SUSPEND_COMMS_ACK));
ack.Put(serial);
ack.Finalize();
this->Send(&ack);
this->m_suspended = 1;
}
// VERIFY: 5dad1904 manual
// OFFSET: 0x00633250
void NetClient::HandleResumeComms(WowConnection* connection, CDataStore* msg) {
if (connection == this->m_redirectConnection) {
WowConnection* old = this->m_serverConnection;
this->m_serverConnection = this->m_redirectConnection;
this->m_redirectConnection = nullptr;
old->SetResponse(nullptr, false);
old->Disconnect();
old->Release();
} else {
this->m_redirectConnection->SetResponse(nullptr, false);
this->m_redirectConnection->Disconnect();
this->m_redirectConnection->Release();
this->m_redirectConnection = nullptr;
}
this->m_suspended = 0;
for (NetClient::HELDMESSAGE* held = this->m_heldMessages.Head(); held; held = this->m_heldMessages.DeleteNode(held)) {
this->Send(&held->m_msg);
}
}