pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2026-05-16 18:52:22 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Add crazy logging to daybreak class

Browse Source
This commit is contained in:
KimLS
2017-02-16 00:02:17 -08:00
parent d8d77d88f2
commit d774de3a1b
4 changed files with 231 additions and 152 deletions
Download Patch File Download Diff File Expand all files Collapse all files
common/net/daybreak_connection.cpp
+123 -45
View File
@@ -65,6 +65,13 @@ void EQ::Net::DaybreakConnectionManager::Attach(uv_loop_t *loop)
char endpoint[16];
uv_ip4_name((const sockaddr_in*)addr, endpoint, 16);
auto port = ntohs(((const sockaddr_in*)addr)->sin_port);
//raw data in
if(nread > 0) {
EQ::Net::StaticPacket wire((void*)buf->base, (uint64_t)nread);
Log.OutF(Logs::Detail, Logs::Netcode, "Raw Packet in\n{0}", wire.ToString());
}
c->ProcessPacket(endpoint, port, buf->base, nread);
delete[] buf->base;
});
@@ -176,9 +183,10 @@ void EQ::Net::DaybreakConnectionManager::ProcessResend()
}
}
void EQ::Net::DaybreakConnectionManager::ProcessPacket(const std::string &endpoint, int port, const char *data, size_t size)
void EQ::Net::DaybreakConnectionManager::ProcessPacket(const std::string &endpoint, int port, const char *data, uint64_t size)
{
if (m_options.simulated_in_packet_loss && m_options.simulated_in_packet_loss >= m_rand.Int(0, 100)) {
Log.OutF(Logs::Detail, Logs::Netcode, "Dropped a packet from {0}:{1} because of simulated packet loss", endpoint, port);
return;
}
@@ -208,6 +216,7 @@ void EQ::Net::DaybreakConnectionManager::ProcessPacket(const std::string &endpoi
connection->ProcessPacket(p);
}
else if(data[1] != OP_OutOfSession) {
Log.OutF(Logs::Detail, Logs::Netcode, "Recv {0:#x} from {1}:{2} but there is no identified connection from this address.", data[1], endpoint, port);
SendDisconnect(endpoint, port);
}
}
@@ -243,10 +252,13 @@ void EQ::Net::DaybreakConnectionManager::SendDisconnect(const std::string &addr,
uv_ip4_addr(addr.c_str(), port, &send_addr);
uv_buf_t send_buffers[1];
char *data = new char[out.Length()];
memcpy(data, out.Data(), out.Length());
send_buffers[0] = uv_buf_init(data, out.Length());
char *data = new char[(size_t)out.Length()];
memcpy(data, out.Data(), (size_t)out.Length());
send_buffers[0] = uv_buf_init(data, (unsigned int)out.Length());
send_req->data = send_buffers[0].base;
Log.OutF(Logs::Detail, Logs::Netcode, "Sending disconnect to {0}:{1}", addr, port);
int ret = uv_udp_send(send_req, &m_socket, send_buffers, 1, (sockaddr*)&send_addr,
[](uv_udp_send_t* req, int status) {
delete[] (char*)req->data;
@@ -265,7 +277,7 @@ EQ::Net::DaybreakConnection::DaybreakConnection(DaybreakConnectionManager *owner
m_port = port;
m_connect_code = NetworkToHost(connect.connect_code);
m_encode_key = m_owner->m_rand.Int(std::numeric_limits<uint32_t>::min(), std::numeric_limits<uint32_t>::max());
m_max_packet_size = (uint32_t)std::min(owner->m_options.max_packet_size, (size_t)NetworkToHost(connect.max_packet_size));
m_max_packet_size = (uint32_t)std::min((uint32_t)owner->m_options.max_packet_size, (uint32_t)NetworkToHost(connect.max_packet_size));
m_crc_bytes = (uint32_t)owner->m_options.crc_length;
m_encode_passes[0] = owner->m_options.encode_passes[0];
m_encode_passes[1] = owner->m_options.encode_passes[1];
@@ -277,6 +289,7 @@ EQ::Net::DaybreakConnection::DaybreakConnection(DaybreakConnectionManager *owner
m_combined[0] = 0;
m_combined[1] = OP_Combined;
m_last_session_stats = Clock::now();
m_last_stats = Clock::now();
}
//new connection made as client
@@ -300,6 +313,7 @@ EQ::Net::DaybreakConnection::DaybreakConnection(DaybreakConnectionManager *owner
m_combined[0] = 0;
m_combined[1] = OP_Combined;
m_last_session_stats = Clock::now();
m_last_stats = Clock::now();
}
EQ::Net::DaybreakConnection::~DaybreakConnection()
@@ -308,6 +322,7 @@ EQ::Net::DaybreakConnection::~DaybreakConnection()
void EQ::Net::DaybreakConnection::Close()
{
Log.OutF(Logs::Detail, Logs::Netcode, "Closing daybreak connection, status was {0}", (int)m_status);
if (m_status == StatusConnected) {
DaybreakDisconnect disconnect;
disconnect.zero = 0;
@@ -354,20 +369,20 @@ void EQ::Net::DaybreakConnection::ResetStats()
void EQ::Net::DaybreakConnection::Process()
{
try {
m_resend_delay = (size_t)(m_stats.last_stat_ping * m_owner->m_options.resend_delay_factor) + m_owner->m_options.resend_delay_ms;
m_resend_delay = (uint64_t)(m_stats.last_stat_ping * m_owner->m_options.resend_delay_factor) + m_owner->m_options.resend_delay_ms;
if (m_resend_delay > 1000) {
m_resend_delay = 1000;
}
auto now = Clock::now();
auto time_since_hold = (size_t)std::chrono::duration_cast<std::chrono::milliseconds>(now - m_hold_time).count();
auto time_since_hold = (uint64_t)std::chrono::duration_cast<std::chrono::milliseconds>(now - m_hold_time).count();
if (time_since_hold >= m_owner->m_options.hold_length_ms) {
FlushBuffer();
}
ProcessQueue();
auto time_since_stats = (size_t)std::chrono::duration_cast<std::chrono::milliseconds>(now - m_last_stats).count();
auto time_since_stats = (uint64_t)std::chrono::duration_cast<std::chrono::milliseconds>(now - m_last_stats).count();
if (m_owner->m_options.stats_delay_ms > 0 && time_since_stats >= m_owner->m_options.stats_delay_ms) {
SendStatSync();
m_last_stats = now;
@@ -385,6 +400,7 @@ void EQ::Net::DaybreakConnection::ProcessPacket(Packet &p)
m_stats.recv_bytes += p.Length();
if (p.Length() < 1) {
Log.OutF(Logs::Detail, Logs::Netcode, "Error parsing packet, length was < 1");
return;
}
@@ -395,6 +411,7 @@ void EQ::Net::DaybreakConnection::ProcessPacket(Packet &p)
auto opcode = p.GetInt8(1);
if (opcode == OP_KeepAlive || opcode == OP_OutboundPing) {
Log.OutF(Logs::Detail, Logs::Netcode, "Discard packet of type {0:#x}", opcode);
return;
}
@@ -474,18 +491,24 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p)
{
if (p.GetInt8(0) == 0) {
if (p.Length() < 2) {
Log.OutF(Logs::Detail, Logs::Netcode, "Failed to process decoded packet, length < 2\n{0}", p.ToString());
return;
}
Log.OutF(Logs::Detail, Logs::Netcode, "Processing decoded packet of type {0:#x}", p.GetInt8(1));
switch (p.GetInt8(1)) {
case OP_Combined: {
Log.OutF(Logs::Detail, Logs::Netcode, "Processing OP_Combined of length {0}", p.Length());
char *current = (char*)p.Data() + 2;
char *end = (char*)p.Data() + p.Length();
while (current < end) {
uint8_t subpacket_length = *(uint8_t*)current;
current += 1;
Log.OutF(Logs::Detail, Logs::Netcode, "Subpacket length {0}", subpacket_length);
if (end < current + subpacket_length) {
Log.OutF(Logs::Detail, Logs::Netcode, "Subpacket length out of range, bailing");
return;
}
@@ -497,6 +520,7 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p)
case OP_AppCombined:
{
Log.OutF(Logs::Detail, Logs::Netcode, "Processing OP_AppCombined of length {0}", p.Length());
uint8_t *current = (uint8_t*)p.Data() + 2;
uint8_t *end = (uint8_t*)p.Data() + p.Length();
@@ -505,11 +529,13 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p)
if (*current == 0xFF)
{
if (end < current + 3) {
Log.OutF(Logs::Detail, Logs::Netcode, "Error in OP_AppCombined, end < current + 3");
throw std::out_of_range("Error in OP_AppCombined, end < current + 3");
}
if (*(current + 1) == 0xFF && *(current + 2) == 0xFF) {
if (end < current + 7) {
Log.OutF(Logs::Detail, Logs::Netcode, "Error in OP_AppCombined, end < current + 7");
throw std::out_of_range("Error in OP_AppCombined, end < current + 7");
}
@@ -534,6 +560,7 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p)
current += 1;
}
Log.OutF(Logs::Detail, Logs::Netcode, "Processing subpacket of length {0}", subpacket_length);
ProcessDecodedPacket(StaticPacket(current, subpacket_length));
current += subpacket_length;
}
@@ -541,6 +568,7 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p)
case OP_SessionRequest:
{
Log.OutF(Logs::Detail, Logs::Netcode, "OP_SessionRequest recieved current status is {0}", m_status);
if (m_status == StatusConnected) {
auto request = p.GetSerialize<DaybreakConnect>(0);
@@ -567,6 +595,7 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p)
case OP_SessionResponse:
{
Log.OutF(Logs::Detail, Logs::Netcode, "OP_SessionResponse recieved current status is {0}", m_status);
if (m_status == StatusConnecting) {
auto reply = p.GetSerialize<DaybreakConnectReply>(0);
@@ -592,15 +621,20 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p)
auto stream_id = header.opcode - OP_Packet;
auto stream = &m_streams[stream_id];
Log.OutF(Logs::Detail, Logs::Netcode, "Recv Reliable Packet for stream {0} with sequence {1}", stream_id, sequence);
auto order = CompareSequence(stream->sequence_in, sequence);
if (order == SequenceFuture) {
Log.OutF(Logs::Detail, Logs::Netcode, "Reliable packet resolved to be a future packet, adding to the packet queue");
SendOutOfOrderAck(stream_id, sequence);
AddToQueue(stream_id, sequence, p);
}
else if (order == SequencePast) {
Log.OutF(Logs::Detail, Logs::Netcode, "Reliable packet resolved to be a past packet, sending an ack");
SendAck(stream_id, stream->sequence_in - 1);
}
else {
Log.OutF(Logs::Detail, Logs::Netcode, "Reliable packet is the one we want, removing it from queue and processing it.");
RemoveFromQueue(stream_id, sequence);
SendAck(stream_id, stream->sequence_in);
stream->sequence_in++;
@@ -621,16 +655,21 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p)
auto stream_id = header.opcode - OP_Fragment;
auto stream = &m_streams[stream_id];
Log.OutF(Logs::Detail, Logs::Netcode, "Recv Reliable Fragment Packet for stream {0} with sequence {1}", stream_id, sequence);
auto order = CompareSequence(stream->sequence_in, sequence);
if (order == SequenceFuture) {
Log.OutF(Logs::Detail, Logs::Netcode, "Reliable fragment packet resolved to be a future packet, adding to the packet queue");
SendOutOfOrderAck(stream_id, sequence);
AddToQueue(stream_id, sequence, p);
}
else if (order == SequencePast) {
Log.OutF(Logs::Detail, Logs::Netcode, "Reliable fragment packet resolved to be a past packet, sending an ack");
SendAck(stream_id, stream->sequence_in - 1);
}
else {
Log.OutF(Logs::Detail, Logs::Netcode, "Reliable fragment packet is the one we want, removing it from queue and processing it.");
RemoveFromQueue(stream_id, sequence);
SendAck(stream_id, stream->sequence_in);
stream->sequence_in++;
@@ -645,6 +684,8 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p)
(char*)p.Data() + DaybreakReliableFragmentHeader::size(), p.Length() - DaybreakReliableFragmentHeader::size());
stream->fragment_current_bytes += (uint32_t)(p.Length() - DaybreakReliableFragmentHeader::size());
Log.OutF(Logs::Detail, Logs::Netcode, "Fragment packet created {0}/{1} bytes", stream->fragment_current_bytes, stream->fragment_total_bytes);
}
else {
stream->fragment_packet.PutData(
@@ -659,6 +700,8 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p)
stream->fragment_total_bytes = 0;
stream->fragment_current_bytes = 0;
}
Log.OutF(Logs::Detail, Logs::Netcode, "Fragment packet accumulated {0}/{1} bytes", stream->fragment_current_bytes, stream->fragment_total_bytes);
}
}
@@ -673,6 +716,8 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p)
auto header = p.GetSerialize<DaybreakReliableHeader>(0);
auto sequence = NetworkToHost(header.sequence);
auto stream_id = header.opcode - OP_Ack;
Log.OutF(Logs::Detail, Logs::Netcode, "Ack recv for stream {0} and sequence {1}", stream_id, sequence);
Ack(stream_id, sequence);
break;
}
@@ -685,12 +730,15 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p)
auto header = p.GetSerialize<DaybreakReliableHeader>(0);
auto sequence = NetworkToHost(header.sequence);
auto stream_id = header.opcode - OP_OutOfOrderAck;
Log.OutF(Logs::Detail, Logs::Netcode, "Out of Order Ack recv for stream {0} and sequence {1}", stream_id, sequence);
OutOfOrderAck(stream_id, sequence);
break;
}
case OP_SessionDisconnect:
{
Log.OutF(Logs::Detail, Logs::Netcode, "OP_SessionDisconnect recieved current status is {0}", m_status);
if (m_status == StatusConnected || m_status == StatusDisconnecting) {
DaybreakDisconnect disconnect;
disconnect.zero = 0;
@@ -707,6 +755,7 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p)
case OP_Padding:
{
Log.OutF(Logs::Detail, Logs::Netcode, "OP_Padding recv, processing packet");
auto self = m_self.lock();
if (m_owner->m_on_packet_recv && self) {
m_owner->m_on_packet_recv(self, StaticPacket((char*)p.Data() + 1, p.Length() - 1));
@@ -715,13 +764,14 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p)
}
case OP_SessionStatRequest:
{
Log.OutF(Logs::Detail, Logs::Netcode, "OP_SessionStatRequest recv");
auto request = p.GetSerialize<DaybreakSessionStatRequest>(0);
DaybreakSessionStatResponse response;
response.zero = 0;
response.opcode = OP_SessionStatResponse;
response.timestamp = request.timestamp;
response.our_timestamp = EQ::Net::HostToNetwork(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count());
response.our_timestamp = (uint32_t)EQ::Net::HostToNetwork(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count());
response.client_sent = request.packets_sent;
response.client_recv = request.packets_recv;
response.server_sent = EQ::Net::HostToNetwork(m_stats.sent_packets);
@@ -732,6 +782,7 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p)
break;
}
case OP_SessionStatResponse:
Log.OutF(Logs::Detail, Logs::Netcode, "OP_SessionStatResponse recv, not yet implemented.");
break;
default:
Log.OutF(Logs::Detail, Logs::Netcode, "Unhandled opcode {0:#x}", p.GetInt8(1));
@@ -739,6 +790,7 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p)
}
}
else {
Log.OutF(Logs::Detail, Logs::Netcode, "Recv raw app packet, processing");
auto self = m_self.lock();
if (m_owner->m_on_packet_recv && self) {
m_owner->m_on_packet_recv(self, p);
@@ -752,7 +804,7 @@ bool EQ::Net::DaybreakConnection::ValidateCRC(Packet &p)
return true;
}
if (p.Length() < (size_t)m_crc_bytes) {
if (p.Length() < (uint64_t)m_crc_bytes) {
return false;
}
@@ -761,12 +813,12 @@ bool EQ::Net::DaybreakConnection::ValidateCRC(Packet &p)
int actual = 0;
switch (m_crc_bytes) {
case 2:
actual = NetworkToHost(*(int16_t*)&data[p.Length() - (size_t)m_crc_bytes]) & 0xffff;
calculated = Crc32(data, (int)(p.Length() - (size_t)m_crc_bytes), m_encode_key) & 0xffff;
actual = NetworkToHost(*(int16_t*)&data[p.Length() - (uint64_t)m_crc_bytes]) & 0xffff;
calculated = Crc32(data, (int)(p.Length() - (uint64_t)m_crc_bytes), m_encode_key) & 0xffff;
break;
case 4:
actual = NetworkToHost(*(int32_t*)&data[p.Length() - (size_t)m_crc_bytes]);
calculated = Crc32(data, (int)(p.Length() - (size_t)m_crc_bytes), m_encode_key);
actual = NetworkToHost(*(int32_t*)&data[p.Length() - (uint64_t)m_crc_bytes]);
calculated = Crc32(data, (int)(p.Length() - (uint64_t)m_crc_bytes), m_encode_key);
break;
default:
return false;
@@ -806,6 +858,7 @@ void EQ::Net::DaybreakConnection::ChangeStatus(DbProtocolStatus new_status)
}
}
Log.OutF(Logs::Detail, Logs::Netcode, "Status changed from {0} to {1}", (int)m_status, (int)new_status);
m_status = new_status;
}
@@ -823,12 +876,12 @@ bool EQ::Net::DaybreakConnection::PacketCanBeEncoded(Packet &p) const
return true;
}
void EQ::Net::DaybreakConnection::Decode(Packet &p, size_t offset, size_t length)
void EQ::Net::DaybreakConnection::Decode(Packet &p, uint64_t offset, uint64_t length)
{
int key = m_encode_key;
char *buffer = (char*)p.Data() + offset;
size_t i = 0;
uint64_t i = 0;
for (i = 0; i + 4 <= length; i += 4)
{
int pt = (*(int*)&buffer[i]) ^ (key);
@@ -843,12 +896,12 @@ void EQ::Net::DaybreakConnection::Decode(Packet &p, size_t offset, size_t length
}
}
void EQ::Net::DaybreakConnection::Encode(Packet &p, size_t offset, size_t length)
void EQ::Net::DaybreakConnection::Encode(Packet &p, uint64_t offset, uint64_t length)
{
int key = m_encode_key;
char *buffer = (char*)p.Data() + offset;
size_t i = 0;
uint64_t i = 0;
for (i = 0; i + 4 <= length; i += 4)
{
int pt = (*(int*)&buffer[i]) ^ (key);
@@ -932,7 +985,7 @@ uint32_t Deflate(const uint8_t* in, uint32_t in_len, uint8_t* out, uint32_t out_
}
}
void EQ::Net::DaybreakConnection::Decompress(Packet &p, size_t offset, size_t length)
void EQ::Net::DaybreakConnection::Decompress(Packet &p, uint64_t offset, uint64_t length)
{
if (length < 2) {
return;
@@ -946,7 +999,7 @@ void EQ::Net::DaybreakConnection::Decompress(Packet &p, size_t offset, size_t le
new_length = Inflate(buffer + 1, (uint32_t)length - 1, new_buffer, 4096);
}
else if (buffer[0] == 0xa5) {
memcpy(new_buffer, buffer + 1, length - 1);
memcpy(new_buffer, buffer + 1, (size_t)length - 1);
new_length = (uint32_t)length - 1;
}
else {
@@ -957,7 +1010,7 @@ void EQ::Net::DaybreakConnection::Decompress(Packet &p, size_t offset, size_t le
p.PutData(offset, new_buffer, new_length);
}
void EQ::Net::DaybreakConnection::Compress(Packet &p, size_t offset, size_t length)
void EQ::Net::DaybreakConnection::Compress(Packet &p, uint64_t offset, uint64_t length)
{
uint8_t new_buffer[2048] = { 0 };
uint8_t *buffer = (uint8_t*)p.Data() + offset;
@@ -968,9 +1021,9 @@ void EQ::Net::DaybreakConnection::Compress(Packet &p, size_t offset, size_t leng
new_buffer[0] = 0x5a;
}
else {
memcpy(new_buffer + 1, buffer, length);
memcpy(new_buffer + 1, buffer, (size_t)length);
new_buffer[0] = 0xa5;
new_length = length + 1;
new_length = (size_t)length + 1;
}
p.Resize(offset);
@@ -991,14 +1044,16 @@ void EQ::Net::DaybreakConnection::ProcessResend(int stream)
for (auto &entry : s->sent_packets) {
auto time_since_last_send = std::chrono::duration_cast<std::chrono::milliseconds>(now - entry.second.last_sent);
if(entry.second.times_resent == 0) {
if ((size_t)time_since_last_send.count() > m_resend_delay) {
if ((uint64_t)time_since_last_send.count() > m_resend_delay) {
Log.OutF(Logs::Detail, Logs::Netcode, "Resending reliable packet\n{0}", entry.second.packet.ToString());
InternalBufferedSend(entry.second.packet);
entry.second.last_sent = now;
entry.second.times_resent++;
}
}
else {
if ((size_t)time_since_last_send.count() > std::min(m_resend_delay / (entry.second.times_resent + 1), (size_t)5ULL)) {
if ((uint64_t)time_since_last_send.count() > std::min(m_resend_delay / (entry.second.times_resent + 1), (uint64_t)50ULL)) {
Log.OutF(Logs::Detail, Logs::Netcode, "Resending reliable packet\n{0}", entry.second.packet.ToString());
InternalBufferedSend(entry.second.packet);
entry.second.last_sent = now;
entry.second.times_resent++;
@@ -1075,19 +1130,22 @@ void EQ::Net::DaybreakConnection::SendStatSync()
DaybreakSessionStatRequest request;
request.zero = 0;
request.opcode = OP_SessionStatRequest;
request.timestamp = EQ::Net::HostToNetwork(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count() & 0xFFFFLL);
request.stat_ping = m_stats.last_stat_ping;
request.timestamp = (uint32_t)EQ::Net::HostToNetwork(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count() & 0xFFFFLL);
request.stat_ping = (uint32_t)m_stats.last_stat_ping;
if (m_stats.total_stat_count > 0)
request.avg_ping = m_stats.total_stat_ping / m_stats.total_stat_count;
request.avg_ping = (uint32)(m_stats.total_stat_ping / m_stats.total_stat_count);
else
request.avg_ping = 0;
request.min_ping = m_stats.min_stat_ping;
request.max_ping = m_stats.max_stat_ping;
request.last_ping = m_stats.last_stat_ping;
request.packets_sent = m_stats.sent_packets + 1;
request.packets_recv = m_stats.recv_packets;
request.min_ping = (uint32_t)m_stats.min_stat_ping;
request.max_ping = (uint32_t)m_stats.max_stat_ping;
request.last_ping = (uint32_t)m_stats.last_stat_ping;
request.packets_sent = (uint32_t)m_stats.sent_packets + 1;
request.packets_recv = (uint32_t)m_stats.recv_packets;
m_last_session_stats = Clock::now();
//InternalSend()
EQ::Net::DynamicPacket p;
p.PutSerialize(0, request);
InternalSend(p);
}
void EQ::Net::DaybreakConnection::InternalBufferedSend(Packet &p)
@@ -1099,7 +1157,7 @@ void EQ::Net::DaybreakConnection::InternalBufferedSend(Packet &p)
}
//we could add this packet to a combined
size_t raw_size = DaybreakHeader::size() + (size_t)m_crc_bytes + m_buffered_packets_length + m_buffered_packets.size() + 1 + p.Length();
uint64_t raw_size = DaybreakHeader::size() + (uint64_t)m_crc_bytes + m_buffered_packets_length + m_buffered_packets.size() + 1 + p.Length();
if (raw_size > m_max_packet_size) {
FlushBuffer();
}
@@ -1175,9 +1233,9 @@ void EQ::Net::DaybreakConnection::InternalSend(Packet &p)
uv_ip4_addr(m_endpoint.c_str(), m_port, &send_addr);
uv_buf_t send_buffers[1];
char *data = new char[out.Length()];
memcpy(data, out.Data(), out.Length());
send_buffers[0] = uv_buf_init(data, out.Length());
char *data = new char[(size_t)out.Length()];
memcpy(data, out.Data(), (size_t)out.Length());
send_buffers[0] = uv_buf_init(data, (size_t)out.Length());
send_req->data = send_buffers[0].base;
m_stats.sent_bytes += out.Length();
@@ -1197,14 +1255,16 @@ void EQ::Net::DaybreakConnection::InternalSend(Packet &p)
uv_ip4_addr(m_endpoint.c_str(), m_port, &send_addr);
uv_buf_t send_buffers[1];
char *data = new char[p.Length()];
memcpy(data, p.Data(), p.Length());
send_buffers[0] = uv_buf_init(data, p.Length());
char *data = new char[(size_t)p.Length()];
memcpy(data, p.Data(), (size_t)p.Length());
send_buffers[0] = uv_buf_init(data, (size_t)p.Length());
send_req->data = send_buffers[0].base;
m_stats.sent_bytes += p.Length();
m_stats.sent_packets++;
Log.OutF(Logs::Detail, Logs::Netcode, "Sending reliable packet\n{0}", p.ToString());
if (m_owner->m_options.simulated_out_packet_loss && m_owner->m_options.simulated_out_packet_loss >= m_owner->m_rand.Int(0, 100)) {
delete[] (char*)send_req->data;
delete send_req;
@@ -1217,18 +1277,24 @@ void EQ::Net::DaybreakConnection::InternalSend(Packet &p)
void EQ::Net::DaybreakConnection::InternalQueuePacket(Packet &p, int stream_id, bool reliable)
{
if (!reliable) {
Log.OutF(Logs::Detail, Logs::Netcode, "Queue non-reliable packet for stream {0}\n{1}", p.ToString());
auto max_raw_size = m_max_packet_size - m_crc_bytes;
if (p.Length() > max_raw_size) {
InternalQueuePacket(p, stream_id, true);
return;
}
Log.OutF(Logs::Detail, Logs::Netcode, "Non-reliable packet was too large, queuing as a reliable");
InternalBufferedSend(p);
return;
}
Log.OutF(Logs::Detail, Logs::Netcode, "Queue reliable packet for stream {0}\n{1}", p.ToString());
auto stream = &m_streams[stream_id];
auto max_raw_size = m_max_packet_size - m_crc_bytes - DaybreakReliableHeader::size();
size_t length = p.Length();
uint64_t length = p.Length();
if (length > max_raw_size) {
DaybreakReliableFragmentHeader first_header;
first_header.reliable.zero = 0;
@@ -1236,8 +1302,10 @@ void EQ::Net::DaybreakConnection::InternalQueuePacket(Packet &p, int stream_id,
first_header.reliable.sequence = HostToNetwork(stream->sequence_out);
first_header.total_size = (uint32_t)HostToNetwork((uint32_t)length);
size_t used = 0;
size_t sublen = m_max_packet_size - m_crc_bytes - DaybreakReliableFragmentHeader::size();
Log.OutF(Logs::Detail, Logs::Netcode, "Packet too large, fragmenting {0} total size", first_header.total_size);
uint64_t used = 0;
uint64_t sublen = m_max_packet_size - m_crc_bytes - DaybreakReliableFragmentHeader::size();
DynamicPacket first_packet;
first_packet.PutSerialize(0, first_header);
first_packet.PutData(DaybreakReliableFragmentHeader::size(), (char*)p.Data() + used, sublen);
@@ -1251,6 +1319,8 @@ void EQ::Net::DaybreakConnection::InternalQueuePacket(Packet &p, int stream_id,
stream->sent_packets.insert(std::make_pair(stream->sequence_out, sent));
stream->sequence_out++;
Log.OutF(Logs::Detail, Logs::Netcode, "Fragmented packet {0}/{1}", used, first_header.total_size);
InternalBufferedSend(first_packet);
while (used < length) {
@@ -1279,6 +1349,8 @@ void EQ::Net::DaybreakConnection::InternalQueuePacket(Packet &p, int stream_id,
stream->sent_packets.insert(std::make_pair(stream->sequence_out, sent));
stream->sequence_out++;
Log.OutF(Logs::Detail, Logs::Netcode, "Fragmented packet {0}/{1}", used, first_header.total_size);
InternalBufferedSend(packet);
}
}
@@ -1299,6 +1371,8 @@ void EQ::Net::DaybreakConnection::InternalQueuePacket(Packet &p, int stream_id,
stream->sent_packets.insert(std::make_pair(stream->sequence_out, sent));
stream->sequence_out++;
Log.OutF(Logs::Detail, Logs::Netcode, "Reliable packet was able to be sent without fragmenting");
InternalBufferedSend(packet);
}
}
@@ -1310,8 +1384,10 @@ void EQ::Net::DaybreakConnection::FlushBuffer()
}
if (m_buffered_packets.size() > 1) {
Log.OutF(Logs::Detail, Logs::Netcode, "Flushing buffer of size {0} packets and {1} bytes", m_buffered_packets.size(), m_buffered_packets_length);
StaticPacket out(m_combined.get(), 512);
size_t length = 2;
uint64_t length = 2;
for (auto &p : m_buffered_packets) {
out.PutUInt8(length, (uint8_t)p.Length());
out.PutPacket(length + 1, p);
@@ -1322,6 +1398,8 @@ void EQ::Net::DaybreakConnection::FlushBuffer()
InternalSend(out);
}
else {
Log.OutF(Logs::Detail, Logs::Netcode, "Flushing buffer of size 1 packet and {0} bytes", m_buffered_packets_length);
auto &front = m_buffered_packets.front();
InternalSend(front);
}