pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2026-03-27 10:32:26 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Adjust switch case formatting in daybreak_connection.cpp

Browse Source
This commit is contained in:
Akkadius 2017-07-12 22:01:59 -05:00
parent 45b29aedf3
commit c8b20ecb1a
1 changed files with 298 additions and 298 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

596
common/net/daybreak_connection.cpp
View File

@ -135,26 +135,26 @@ void EQ::Net::DaybreakConnectionManager::Process()
switch (status) switch (status)
{ {
case StatusConnecting: { case StatusConnecting: {
auto time_since_last_send = std::chrono::duration_cast<std::chrono::milliseconds>(now - connection->m_last_send);
if ((size_t)time_since_last_send.count() > m_options.connect_delay_ms) {
connection->SendConnect();
}
}
break;
case StatusConnected: {
if (m_options.keepalive_delay_ms != 0) {
auto time_since_last_send = std::chrono::duration_cast<std::chrono::milliseconds>(now - connection->m_last_send); auto time_since_last_send = std::chrono::duration_cast<std::chrono::milliseconds>(now - connection->m_last_send);
if ((size_t)time_since_last_send.count() > m_options.keepalive_delay_ms) { if ((size_t)time_since_last_send.count() > m_options.connect_delay_ms) {
connection->SendKeepAlive(); connection->SendConnect();
}
break;
}
case StatusConnected: {
if (m_options.keepalive_delay_ms != 0) {
auto time_since_last_send = std::chrono::duration_cast<std::chrono::milliseconds>(now - connection->m_last_send);
if ((size_t)time_since_last_send.count() > m_options.keepalive_delay_ms) {
connection->SendKeepAlive();
}
} }
} }
} case StatusDisconnecting:
case StatusDisconnecting: connection->Process();
connection->Process(); break;
break; default:
default: break;
break;
} }
iter++; iter++;
@ -170,12 +170,12 @@ void EQ::Net::DaybreakConnectionManager::ProcessResend()
switch (status) switch (status)
{ {
case StatusConnected: case StatusConnected:
case StatusDisconnecting: case StatusDisconnecting:
connection->ProcessResend(); connection->ProcessResend();
break; break;
default: default:
break; break;
} }
iter++; iter++;
@ -406,14 +406,14 @@ void EQ::Net::DaybreakConnection::ProcessPacket(Packet &p)
for (int i = 1; i >= 0; --i) { for (int i = 1; i >= 0; --i) {
switch (m_encode_passes[i]) { switch (m_encode_passes[i]) {
case EncodeCompression: case EncodeCompression:
Decompress(temp, DaybreakHeader::size(), temp.Length() - DaybreakHeader::size()); Decompress(temp, DaybreakHeader::size(), temp.Length() - DaybreakHeader::size());
break; break;
case EncodeXOR: case EncodeXOR:
Decode(temp, DaybreakHeader::size(), temp.Length() - DaybreakHeader::size()); Decode(temp, DaybreakHeader::size(), temp.Length() - DaybreakHeader::size());
break; break;
default: default:
break; break;
} }
} }
@ -424,11 +424,11 @@ void EQ::Net::DaybreakConnection::ProcessPacket(Packet &p)
for (int i = 1; i >= 0; --i) { for (int i = 1; i >= 0; --i) {
switch (m_encode_passes[i]) { switch (m_encode_passes[i]) {
case EncodeXOR: case EncodeXOR:
Decode(temp, DaybreakHeader::size(), temp.Length() - DaybreakHeader::size()); Decode(temp, DaybreakHeader::size(), temp.Length() - DaybreakHeader::size());
break; break;
default: default:
break; break;
} }
} }
@ -490,274 +490,274 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p)
} }
switch (p.GetInt8(1)) { switch (p.GetInt8(1)) {
case OP_Combined: { case OP_Combined: {
if (m_status == StatusDisconnecting) { if (m_status == StatusDisconnecting) {
SendDisconnect(); SendDisconnect();
return;
}
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;
if (end < current + subpacket_length) {
return; return;
} }
ProcessDecodedPacket(StaticPacket(current, subpacket_length)); char *current = (char*)p.Data() + 2;
current += subpacket_length; char *end = (char*)p.Data() + p.Length();
} while (current < end) {
break; uint8_t subpacket_length = *(uint8_t*)current;
} current += 1;
case OP_AppCombined: if (end < current + subpacket_length) {
{ return;
if (m_status == StatusDisconnecting) {
SendDisconnect();
return;
}
uint8_t *current = (uint8_t*)p.Data() + 2;
uint8_t *end = (uint8_t*)p.Data() + p.Length();
while (current < end) {
uint32_t subpacket_length = 0;
if (*current == 0xFF)
{
if (end < current + 3) {
throw std::out_of_range("Error in OP_AppCombined, end < current + 3");
} }
if (*(current + 1) == 0xFF && *(current + 2) == 0xFF) { ProcessDecodedPacket(StaticPacket(current, subpacket_length));
if (end < current + 7) { current += subpacket_length;
throw std::out_of_range("Error in OP_AppCombined, end < current + 7"); }
break;
}
case OP_AppCombined:
{
if (m_status == StatusDisconnecting) {
SendDisconnect();
return;
}
uint8_t *current = (uint8_t*)p.Data() + 2;
uint8_t *end = (uint8_t*)p.Data() + p.Length();
while (current < end) {
uint32_t subpacket_length = 0;
if (*current == 0xFF)
{
if (end < current + 3) {
throw std::out_of_range("Error in OP_AppCombined, end < current + 3");
} }
subpacket_length = (uint32_t)( if (*(current + 1) == 0xFF && *(current + 2) == 0xFF) {
(*(current + 3) << 24) | if (end < current + 7) {
(*(current + 4) << 16) | throw std::out_of_range("Error in OP_AppCombined, end < current + 7");
(*(current + 5) << 8) | }
(*(current + 6))
); subpacket_length = (uint32_t)(
current += 7; (*(current + 3) << 24) |
(*(current + 4) << 16) |
(*(current + 5) << 8) |
(*(current + 6))
);
current += 7;
}
else {
subpacket_length = (uint32_t)(
(*(current + 1) << 8) |
(*(current + 2))
);
current += 3;
}
} }
else { else {
subpacket_length = (uint32_t)( subpacket_length = (uint32_t)((*(current + 0)));
(*(current + 1) << 8) | current += 1;
(*(current + 2)) }
);
current += 3; ProcessDecodedPacket(StaticPacket(current, subpacket_length));
current += subpacket_length;
}
}
case OP_SessionRequest:
{
if (m_status == StatusConnected) {
auto request = p.GetSerialize<DaybreakConnect>(0);
if (NetworkToHost(request.connect_code) != m_connect_code) {
return;
}
DaybreakConnectReply reply;
reply.zero = 0;
reply.opcode = OP_SessionResponse;
reply.connect_code = HostToNetwork(m_connect_code);
reply.encode_key = HostToNetwork(m_encode_key);
reply.crc_bytes = m_crc_bytes;
reply.max_packet_size = HostToNetwork(m_max_packet_size);
reply.encode_pass1 = m_encode_passes[0];
reply.encode_pass2 = m_encode_passes[1];
DynamicPacket p;
p.PutSerialize(0, reply);
InternalSend(p);
}
break;
}
case OP_SessionResponse:
{
if (m_status == StatusConnecting) {
auto reply = p.GetSerialize<DaybreakConnectReply>(0);
if (m_connect_code == reply.connect_code) {
m_encode_key = reply.encode_key;
m_crc_bytes = reply.crc_bytes;
m_encode_passes[0] = (DaybreakEncodeType)reply.encode_pass1;
m_encode_passes[1] = (DaybreakEncodeType)reply.encode_pass2;
m_max_packet_size = reply.max_packet_size;
ChangeStatus(StatusConnected);
} }
} }
else { break;
subpacket_length = (uint32_t)((*(current + 0)));
current += 1;
}
ProcessDecodedPacket(StaticPacket(current, subpacket_length));
current += subpacket_length;
} }
}
case OP_SessionRequest: case OP_Packet:
{ case OP_Packet2:
if (m_status == StatusConnected) { case OP_Packet3:
auto request = p.GetSerialize<DaybreakConnect>(0); case OP_Packet4:
{
if (NetworkToHost(request.connect_code) != m_connect_code) { if (m_status == StatusDisconnecting) {
SendDisconnect();
return; return;
} }
DaybreakConnectReply reply; auto header = p.GetSerialize<DaybreakReliableHeader>(0);
reply.zero = 0; auto sequence = NetworkToHost(header.sequence);
reply.opcode = OP_SessionResponse; auto stream_id = header.opcode - OP_Packet;
reply.connect_code = HostToNetwork(m_connect_code); auto stream = &m_streams[stream_id];
reply.encode_key = HostToNetwork(m_encode_key);
reply.crc_bytes = m_crc_bytes;
reply.max_packet_size = HostToNetwork(m_max_packet_size);
reply.encode_pass1 = m_encode_passes[0];
reply.encode_pass2 = m_encode_passes[1];
DynamicPacket p;
p.PutSerialize(0, reply);
InternalSend(p);
}
break; auto order = CompareSequence(stream->sequence_in, sequence);
} if (order == SequenceFuture) {
SendOutOfOrderAck(stream_id, sequence);
case OP_SessionResponse: AddToQueue(stream_id, sequence, p);
{
if (m_status == StatusConnecting) {
auto reply = p.GetSerialize<DaybreakConnectReply>(0);
if (m_connect_code == reply.connect_code) {
m_encode_key = reply.encode_key;
m_crc_bytes = reply.crc_bytes;
m_encode_passes[0] = (DaybreakEncodeType)reply.encode_pass1;
m_encode_passes[1] = (DaybreakEncodeType)reply.encode_pass2;
m_max_packet_size = reply.max_packet_size;
ChangeStatus(StatusConnected);
} }
} else if (order == SequencePast) {
break; SendAck(stream_id, stream->sequence_in - 1);
}
case OP_Packet:
case OP_Packet2:
case OP_Packet3:
case OP_Packet4:
{
if (m_status == StatusDisconnecting) {
SendDisconnect();
return;
}
auto header = p.GetSerialize<DaybreakReliableHeader>(0);
auto sequence = NetworkToHost(header.sequence);
auto stream_id = header.opcode - OP_Packet;
auto stream = &m_streams[stream_id];
auto order = CompareSequence(stream->sequence_in, sequence);
if (order == SequenceFuture) {
SendOutOfOrderAck(stream_id, sequence);
AddToQueue(stream_id, sequence, p);
}
else if (order == SequencePast) {
SendAck(stream_id, stream->sequence_in - 1);
}
else {
RemoveFromQueue(stream_id, sequence);
SendAck(stream_id, stream->sequence_in);
stream->sequence_in++;
StaticPacket next((char*)p.Data() + DaybreakReliableHeader::size(), p.Length() - DaybreakReliableHeader::size());
ProcessDecodedPacket(next);
}
break;
}
case OP_Fragment:
case OP_Fragment2:
case OP_Fragment3:
case OP_Fragment4:
{
auto header = p.GetSerialize<DaybreakReliableHeader>(0);
auto sequence = NetworkToHost(header.sequence);
auto stream_id = header.opcode - OP_Fragment;
auto stream = &m_streams[stream_id];
auto order = CompareSequence(stream->sequence_in, sequence);
if (order == SequenceFuture) {
SendOutOfOrderAck(stream_id, sequence);
AddToQueue(stream_id, sequence, p);
}
else if (order == SequencePast) {
SendAck(stream_id, stream->sequence_in - 1);
}
else {
RemoveFromQueue(stream_id, sequence);
SendAck(stream_id, stream->sequence_in);
stream->sequence_in++;
if (stream->fragment_total_bytes == 0) {
auto fragheader = p.GetSerialize<DaybreakReliableFragmentHeader>(0);
stream->fragment_total_bytes = NetworkToHost(fragheader.total_size);
stream->fragment_current_bytes = 0;
stream->fragment_packet.Reserve(stream->fragment_total_bytes);
stream->fragment_packet.PutData(
stream->fragment_current_bytes,
(char*)p.Data() + DaybreakReliableFragmentHeader::size(), p.Length() - DaybreakReliableFragmentHeader::size());
stream->fragment_current_bytes += (uint32_t)(p.Length() - DaybreakReliableFragmentHeader::size());
} }
else { else {
stream->fragment_packet.PutData( RemoveFromQueue(stream_id, sequence);
stream->fragment_current_bytes, SendAck(stream_id, stream->sequence_in);
(char*)p.Data() + DaybreakReliableHeader::size(), p.Length() - DaybreakReliableHeader::size()); stream->sequence_in++;
StaticPacket next((char*)p.Data() + DaybreakReliableHeader::size(), p.Length() - DaybreakReliableHeader::size());
ProcessDecodedPacket(next);
}
stream->fragment_current_bytes += (uint32_t)(p.Length() - DaybreakReliableHeader::size()); break;
}
if (stream->fragment_current_bytes >= stream->fragment_total_bytes) { case OP_Fragment:
ProcessDecodedPacket(stream->fragment_packet); case OP_Fragment2:
stream->fragment_packet.Clear(); case OP_Fragment3:
stream->fragment_total_bytes = 0; case OP_Fragment4:
{
auto header = p.GetSerialize<DaybreakReliableHeader>(0);
auto sequence = NetworkToHost(header.sequence);
auto stream_id = header.opcode - OP_Fragment;
auto stream = &m_streams[stream_id];
auto order = CompareSequence(stream->sequence_in, sequence);
if (order == SequenceFuture) {
SendOutOfOrderAck(stream_id, sequence);
AddToQueue(stream_id, sequence, p);
}
else if (order == SequencePast) {
SendAck(stream_id, stream->sequence_in - 1);
}
else {
RemoveFromQueue(stream_id, sequence);
SendAck(stream_id, stream->sequence_in);
stream->sequence_in++;
if (stream->fragment_total_bytes == 0) {
auto fragheader = p.GetSerialize<DaybreakReliableFragmentHeader>(0);
stream->fragment_total_bytes = NetworkToHost(fragheader.total_size);
stream->fragment_current_bytes = 0; stream->fragment_current_bytes = 0;
stream->fragment_packet.Reserve(stream->fragment_total_bytes);
stream->fragment_packet.PutData(
stream->fragment_current_bytes,
(char*)p.Data() + DaybreakReliableFragmentHeader::size(), p.Length() - DaybreakReliableFragmentHeader::size());
stream->fragment_current_bytes += (uint32_t)(p.Length() - DaybreakReliableFragmentHeader::size());
}
else {
stream->fragment_packet.PutData(
stream->fragment_current_bytes,
(char*)p.Data() + DaybreakReliableHeader::size(), p.Length() - DaybreakReliableHeader::size());
stream->fragment_current_bytes += (uint32_t)(p.Length() - DaybreakReliableHeader::size());
if (stream->fragment_current_bytes >= stream->fragment_total_bytes) {
ProcessDecodedPacket(stream->fragment_packet);
stream->fragment_packet.Clear();
stream->fragment_total_bytes = 0;
stream->fragment_current_bytes = 0;
}
} }
} }
break;
} }
break; case OP_Ack:
} case OP_Ack2:
case OP_Ack3:
case OP_Ack: case OP_Ack4:
case OP_Ack2: {
case OP_Ack3: auto header = p.GetSerialize<DaybreakReliableHeader>(0);
case OP_Ack4: auto sequence = NetworkToHost(header.sequence);
{ auto stream_id = header.opcode - OP_Ack;
auto header = p.GetSerialize<DaybreakReliableHeader>(0); Ack(stream_id, sequence);
auto sequence = NetworkToHost(header.sequence); break;
auto stream_id = header.opcode - OP_Ack;
Ack(stream_id, sequence);
break;
}
case OP_OutOfOrderAck:
case OP_OutOfOrderAck2:
case OP_OutOfOrderAck3:
case OP_OutOfOrderAck4:
{
auto header = p.GetSerialize<DaybreakReliableHeader>(0);
auto sequence = NetworkToHost(header.sequence);
auto stream_id = header.opcode - OP_OutOfOrderAck;
OutOfOrderAck(stream_id, sequence);
break;
}
case OP_SessionDisconnect:
{
if (m_status == StatusConnected || m_status == StatusDisconnecting) {
FlushBuffer();
SendDisconnect();
} }
ChangeStatus(StatusDisconnecting); case OP_OutOfOrderAck:
break; case OP_OutOfOrderAck2:
} case OP_OutOfOrderAck3:
case OP_OutOfOrderAck4:
case OP_Padding: {
{ auto header = p.GetSerialize<DaybreakReliableHeader>(0);
auto self = m_self.lock(); auto sequence = NetworkToHost(header.sequence);
if (m_owner->m_on_packet_recv && self) { auto stream_id = header.opcode - OP_OutOfOrderAck;
m_owner->m_on_packet_recv(self, StaticPacket((char*)p.Data() + 1, p.Length() - 1)); OutOfOrderAck(stream_id, sequence);
break;
} }
break;
}
case OP_SessionStatRequest:
{
auto request = p.GetSerialize<DaybreakSessionStatRequest>(0);
DaybreakSessionStatResponse response; case OP_SessionDisconnect:
response.zero = 0; {
response.opcode = OP_SessionStatResponse; if (m_status == StatusConnected || m_status == StatusDisconnecting) {
response.timestamp = request.timestamp; FlushBuffer();
response.our_timestamp = EQ::Net::HostToNetwork(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count()); SendDisconnect();
response.client_sent = request.packets_sent; }
response.client_recv = request.packets_recv;
response.server_sent = EQ::Net::HostToNetwork(m_stats.sent_packets); ChangeStatus(StatusDisconnecting);
response.server_recv = EQ::Net::HostToNetwork(m_stats.recv_packets); break;
DynamicPacket out; }
out.PutSerialize(0, response);
InternalSend(out); case OP_Padding:
break; {
} auto self = m_self.lock();
case OP_SessionStatResponse: if (m_owner->m_on_packet_recv && self) {
break; m_owner->m_on_packet_recv(self, StaticPacket((char*)p.Data() + 1, p.Length() - 1));
default: }
LogF(Logs::Detail, Logs::Netcode, "Unhandled opcode {0:#x}", p.GetInt8(1)); break;
break; }
case OP_SessionStatRequest:
{
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::high_resolution_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);
response.server_recv = EQ::Net::HostToNetwork(m_stats.recv_packets);
DynamicPacket out;
out.PutSerialize(0, response);
InternalSend(out);
break;
}
case OP_SessionStatResponse:
break;
default:
LogF(Logs::Detail, Logs::Netcode, "Unhandled opcode {0:#x}", p.GetInt8(1));
break;
} }
} }
else { else {
@ -782,16 +782,16 @@ bool EQ::Net::DaybreakConnection::ValidateCRC(Packet &p)
int calculated = 0; int calculated = 0;
int actual = 0; int actual = 0;
switch (m_crc_bytes) { switch (m_crc_bytes) {
case 2: case 2:
actual = NetworkToHost(*(int16_t*)&data[p.Length() - (size_t)m_crc_bytes]) & 0xffff; 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; calculated = Crc32(data, (int)(p.Length() - (size_t)m_crc_bytes), m_encode_key) & 0xffff;
break; break;
case 4: case 4:
actual = NetworkToHost(*(int32_t*)&data[p.Length() - (size_t)m_crc_bytes]); 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); calculated = Crc32(data, (int)(p.Length() - (size_t)m_crc_bytes), m_encode_key);
break; break;
default: default:
return false; return false;
} }
if (actual == calculated) { if (actual == calculated) {
@ -809,14 +809,14 @@ void EQ::Net::DaybreakConnection::AppendCRC(Packet &p)
int calculated = 0; int calculated = 0;
switch (m_crc_bytes) { switch (m_crc_bytes) {
case 2: case 2:
calculated = Crc32(p.Data(), (int)p.Length(), m_encode_key) & 0xffff; calculated = Crc32(p.Data(), (int)p.Length(), m_encode_key) & 0xffff;
p.PutInt16(p.Length(), EQ::Net::HostToNetwork((int16_t)calculated)); p.PutInt16(p.Length(), EQ::Net::HostToNetwork((int16_t)calculated));
break; break;
case 4: case 4:
calculated = Crc32(p.Data(), (int)p.Length(), m_encode_key); calculated = Crc32(p.Data(), (int)p.Length(), m_encode_key);
p.PutInt32(p.Length(), EQ::Net::HostToNetwork(calculated)); p.PutInt32(p.Length(), EQ::Net::HostToNetwork(calculated));
break; break;
} }
} }
@ -1200,14 +1200,14 @@ void EQ::Net::DaybreakConnection::InternalSend(Packet &p)
for (int i = 0; i < 2; ++i) { for (int i = 0; i < 2; ++i) {
switch (m_encode_passes[i]) { switch (m_encode_passes[i]) {
case EncodeCompression: case EncodeCompression:
Compress(out, DaybreakHeader::size(), out.Length() - DaybreakHeader::size()); Compress(out, DaybreakHeader::size(), out.Length() - DaybreakHeader::size());
break; break;
case EncodeXOR: case EncodeXOR:
Encode(out, DaybreakHeader::size(), out.Length() - DaybreakHeader::size()); Encode(out, DaybreakHeader::size(), out.Length() - DaybreakHeader::size());
break; break;
default: default:
break; break;
} }
} }