diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt index 0921cec5f..2a3c3ad72 100644 --- a/common/CMakeLists.txt +++ b/common/CMakeLists.txt @@ -104,9 +104,9 @@ SET(common_sources net/console_server.cpp net/console_server_connection.cpp net/crc32.cpp - net/daybreak_connection.cpp net/eqstream.cpp net/packet.cpp + net/reliable_stream_connection.cpp net/servertalk_client_connection.cpp net/servertalk_legacy_client_connection.cpp net/servertalk_server.cpp @@ -671,13 +671,13 @@ SET(common_headers net/console_server.h net/console_server_connection.h net/crc32.h - net/daybreak_connection.h - net/daybreak_pooling.h - net/daybreak_structs.h net/dns.h net/endian.h net/eqstream.h net/packet.h + net/reliable_stream_connection.h + net/reliable_stream_pooling.h + net/reliable_stream_structs.h net/servertalk_client_connection.h net/servertalk_legacy_client_connection.h net/servertalk_common.h @@ -743,10 +743,6 @@ SOURCE_GROUP(Net FILES net/console_server_connection.h net/crc32.cpp net/crc32.h - net/daybreak_connection.cpp - net/daybreak_connection.h - net/daybreak_pooling.h - net/daybreak_structs.h net/dns.h net/endian.h net/eqmq.cpp @@ -755,6 +751,10 @@ SOURCE_GROUP(Net FILES net/eqstream.h net/packet.cpp net/packet.h + net/reliable_stream_connection.cpp + net/reliable_stream_connection.h + net/reliable_stream_pooling.h + net/reliable_stream_structs.h net/servertalk_client_connection.cpp net/servertalk_client_connection.h net/servertalk_legacy_client_connection.cpp diff --git a/common/eq_stream_intf.h b/common/eq_stream_intf.h index e2b7b21c7..5b2d24c82 100644 --- a/common/eq_stream_intf.h +++ b/common/eq_stream_intf.h @@ -6,7 +6,7 @@ #include #include "emu_versions.h" #include "eq_packet.h" -#include "net/daybreak_connection.h" +#include "net/reliable_stream_connection.h" typedef enum { ESTABLISHED, @@ -33,18 +33,18 @@ struct EQStreamManagerInterfaceOptions //Login I had trouble getting to recognize compression at all //but that might be because it was still a bit buggy when i was testing that. if (compressed) { - daybreak_options.encode_passes[0] = EQ::Net::EncodeCompression; + reliable_stream_options.encode_passes[0] = EQ::Net::EncodeCompression; } else if (encoded) { - daybreak_options.encode_passes[0] = EQ::Net::EncodeXOR; + reliable_stream_options.encode_passes[0] = EQ::Net::EncodeXOR; } - daybreak_options.port = port; + reliable_stream_options.port = port; } int opcode_size; bool track_opcode_stats; - EQ::Net::DaybreakConnectionManagerOptions daybreak_options; + EQ::Net::ReliableStreamConnectionManagerOptions reliable_stream_options; }; class EQStreamManagerInterface @@ -80,7 +80,7 @@ public: struct Stats { - EQ::Net::DaybreakConnectionStats DaybreakStats; + EQ::Net::ReliableStreamConnectionStats ReliableStreamStats; int RecvCount[_maxEmuOpcode]; int SentCount[_maxEmuOpcode]; }; diff --git a/common/net/eqstream.cpp b/common/net/eqstream.cpp index 0e3c671d7..633dea4c9 100644 --- a/common/net/eqstream.cpp +++ b/common/net/eqstream.cpp @@ -1,11 +1,11 @@ #include "eqstream.h" #include "../eqemu_logsys.h" -EQ::Net::EQStreamManager::EQStreamManager(const EQStreamManagerInterfaceOptions &options) : EQStreamManagerInterface(options), m_daybreak(options.daybreak_options) +EQ::Net::EQStreamManager::EQStreamManager(const EQStreamManagerInterfaceOptions &options) : EQStreamManagerInterface(options), m_reliable_stream(options.reliable_stream_options) { - m_daybreak.OnNewConnection(std::bind(&EQStreamManager::DaybreakNewConnection, this, std::placeholders::_1)); - m_daybreak.OnConnectionStateChange(std::bind(&EQStreamManager::DaybreakConnectionStateChange, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)); - m_daybreak.OnPacketRecv(std::bind(&EQStreamManager::DaybreakPacketRecv, this, std::placeholders::_1, std::placeholders::_2)); + m_reliable_stream.OnNewConnection(std::bind(&EQStreamManager::ReliableStreamNewConnection, this, std::placeholders::_1)); + m_reliable_stream.OnConnectionStateChange(std::bind(&EQStreamManager::ReliableStreamConnectionStateChange, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)); + m_reliable_stream.OnPacketRecv(std::bind(&EQStreamManager::ReliableStreamPacketRecv, this, std::placeholders::_1, std::placeholders::_2)); } EQ::Net::EQStreamManager::~EQStreamManager() @@ -15,11 +15,11 @@ EQ::Net::EQStreamManager::~EQStreamManager() void EQ::Net::EQStreamManager::SetOptions(const EQStreamManagerInterfaceOptions &options) { m_options = options; - auto &opts = m_daybreak.GetOptions(); - opts = options.daybreak_options; + auto &opts = m_reliable_stream.GetOptions(); + opts = options.reliable_stream_options; } -void EQ::Net::EQStreamManager::DaybreakNewConnection(std::shared_ptr connection) +void EQ::Net::EQStreamManager::ReliableStreamNewConnection(std::shared_ptr connection) { std::shared_ptr stream(new EQStream(this, connection)); m_streams.emplace(std::make_pair(connection, stream)); @@ -28,7 +28,7 @@ void EQ::Net::EQStreamManager::DaybreakNewConnection(std::shared_ptr connection, DbProtocolStatus from, DbProtocolStatus to) +void EQ::Net::EQStreamManager::ReliableStreamConnectionStateChange(std::shared_ptr connection, DbProtocolStatus from, DbProtocolStatus to) { auto iter = m_streams.find(connection); if (iter != m_streams.end()) { @@ -42,7 +42,7 @@ void EQ::Net::EQStreamManager::DaybreakConnectionStateChange(std::shared_ptr connection, const Packet &p) +void EQ::Net::EQStreamManager::ReliableStreamPacketRecv(std::shared_ptr connection, const Packet &p) { auto iter = m_streams.find(connection); if (iter != m_streams.end()) { @@ -53,7 +53,7 @@ void EQ::Net::EQStreamManager::DaybreakPacketRecv(std::shared_ptr connection) +EQ::Net::EQStream::EQStream(EQStreamManagerInterface *owner, std::shared_ptr connection) { m_owner = owner; m_connection = connection; @@ -235,7 +235,7 @@ EQStreamState EQ::Net::EQStream::GetState() { EQ::Net::EQStream::Stats EQ::Net::EQStream::GetStats() const { Stats ret; - ret.DaybreakStats = m_connection->GetStats(); + ret.ReliableStreamStats = m_connection->GetStats(); for (int i = 0; i < _maxEmuOpcode; ++i) { ret.RecvCount[i] = 0; diff --git a/common/net/eqstream.h b/common/net/eqstream.h index a87c6ec0b..4a8e6ddd9 100644 --- a/common/net/eqstream.h +++ b/common/net/eqstream.h @@ -3,7 +3,7 @@ #include "../eq_packet.h" #include "../eq_stream_intf.h" #include "../opcodemgr.h" -#include "daybreak_connection.h" +#include "reliable_stream_connection.h" #include #include #include @@ -23,21 +23,21 @@ namespace EQ void OnNewConnection(std::function)> func) { m_on_new_connection = func; } void OnConnectionStateChange(std::function, DbProtocolStatus, DbProtocolStatus)> func) { m_on_connection_state_change = func; } private: - DaybreakConnectionManager m_daybreak; + ReliableStreamConnectionManager m_reliable_stream; std::function)> m_on_new_connection; std::function, DbProtocolStatus, DbProtocolStatus)> m_on_connection_state_change; - std::map, std::shared_ptr> m_streams; + std::map, std::shared_ptr> m_streams; - void DaybreakNewConnection(std::shared_ptr connection); - void DaybreakConnectionStateChange(std::shared_ptr connection, DbProtocolStatus from, DbProtocolStatus to); - void DaybreakPacketRecv(std::shared_ptr connection, const Packet &p); + void ReliableStreamNewConnection(std::shared_ptr connection); + void ReliableStreamConnectionStateChange(std::shared_ptr connection, DbProtocolStatus from, DbProtocolStatus to); + void ReliableStreamPacketRecv(std::shared_ptr connection, const Packet &p); friend class EQStream; }; class EQStream : public EQStreamInterface { public: - EQStream(EQStreamManagerInterface *parent, std::shared_ptr connection); + EQStream(EQStreamManagerInterface *parent, std::shared_ptr connection); ~EQStream(); virtual void QueuePacket(const EQApplicationPacket *p, bool ack_req = true); @@ -67,7 +67,7 @@ namespace EQ virtual EQStreamManagerInterface* GetManager() const; private: EQStreamManagerInterface *m_owner; - std::shared_ptr m_connection; + std::shared_ptr m_connection; OpcodeManager **m_opcode_manager; std::deque> m_packet_queue; std::unordered_map m_packet_recv_count; diff --git a/common/net/daybreak_connection.cpp b/common/net/reliable_stream_connection.cpp similarity index 82% rename from common/net/daybreak_connection.cpp rename to common/net/reliable_stream_connection.cpp index 9d40eadb8..e1101f452 100644 --- a/common/net/daybreak_connection.cpp +++ b/common/net/reliable_stream_connection.cpp @@ -1,4 +1,4 @@ -#include "daybreak_connection.h" +#include "reliable_stream_connection.h" #include "../event/event_loop.h" #include "../data_verification.h" #include "crc32.h" @@ -12,7 +12,7 @@ constexpr size_t MAX_CLIENT_RECV_BYTES_PER_WINDOW = 140 * 1024; // buffer pools SendBufferPool send_buffer_pool; -EQ::Net::DaybreakConnectionManager::DaybreakConnectionManager() +EQ::Net::ReliableStreamConnectionManager::ReliableStreamConnectionManager() { m_attached = nullptr; memset(&m_timer, 0, sizeof(uv_timer_t)); @@ -21,7 +21,7 @@ EQ::Net::DaybreakConnectionManager::DaybreakConnectionManager() Attach(EQ::EventLoop::Get().Handle()); } -EQ::Net::DaybreakConnectionManager::DaybreakConnectionManager(const DaybreakConnectionManagerOptions &opts) +EQ::Net::ReliableStreamConnectionManager::ReliableStreamConnectionManager(const ReliableStreamConnectionManagerOptions &opts) { m_attached = nullptr; m_options = opts; @@ -31,12 +31,12 @@ EQ::Net::DaybreakConnectionManager::DaybreakConnectionManager(const DaybreakConn Attach(EQ::EventLoop::Get().Handle()); } -EQ::Net::DaybreakConnectionManager::~DaybreakConnectionManager() +EQ::Net::ReliableStreamConnectionManager::~ReliableStreamConnectionManager() { Detach(); } -void EQ::Net::DaybreakConnectionManager::Attach(uv_loop_t *loop) +void EQ::Net::ReliableStreamConnectionManager::Attach(uv_loop_t *loop) { if (!m_attached) { uv_timer_init(loop, &m_timer); @@ -45,7 +45,7 @@ void EQ::Net::DaybreakConnectionManager::Attach(uv_loop_t *loop) auto update_rate = (uint64_t)(1000.0 / m_options.tic_rate_hertz); uv_timer_start(&m_timer, [](uv_timer_t *handle) { - DaybreakConnectionManager *c = (DaybreakConnectionManager*)handle->data; + ReliableStreamConnectionManager *c = (ReliableStreamConnectionManager*)handle->data; c->UpdateDataBudget(); c->Process(); c->ProcessResend(); @@ -71,7 +71,7 @@ void EQ::Net::DaybreakConnectionManager::Attach(uv_loop_t *loop) buf->len = 65536; }, [](uv_udp_t* handle, ssize_t nread, const uv_buf_t* buf, const struct sockaddr* addr, unsigned flags) { - DaybreakConnectionManager *c = (DaybreakConnectionManager*)handle->data; + ReliableStreamConnectionManager *c = (ReliableStreamConnectionManager*)handle->data; if (nread < 0 || addr == nullptr) { return; } @@ -90,7 +90,7 @@ void EQ::Net::DaybreakConnectionManager::Attach(uv_loop_t *loop) } } -void EQ::Net::DaybreakConnectionManager::Detach() +void EQ::Net::ReliableStreamConnectionManager::Detach() { if (m_attached) { uv_udp_recv_stop(&m_socket); @@ -99,11 +99,11 @@ void EQ::Net::DaybreakConnectionManager::Detach() } } -void EQ::Net::DaybreakConnectionManager::Connect(const std::string &addr, int port) +void EQ::Net::ReliableStreamConnectionManager::Connect(const std::string &addr, int port) { //todo dns resolution - auto connection = std::shared_ptr(new DaybreakConnection(this, addr, port)); + auto connection = std::shared_ptr(new ReliableStreamConnection(this, addr, port)); connection->m_self = connection; if (m_on_new_connection) { @@ -113,7 +113,7 @@ void EQ::Net::DaybreakConnectionManager::Connect(const std::string &addr, int po m_connections.emplace(std::make_pair(std::make_pair(addr, port), connection)); } -void EQ::Net::DaybreakConnectionManager::Process() +void EQ::Net::ReliableStreamConnectionManager::Process() { auto now = Clock::now(); auto iter = m_connections.begin(); @@ -177,7 +177,7 @@ void EQ::Net::DaybreakConnectionManager::Process() } } -void EQ::Net::DaybreakConnectionManager::UpdateDataBudget() +void EQ::Net::ReliableStreamConnectionManager::UpdateDataBudget() { auto outgoing_data_rate = m_options.outgoing_data_rate; if (outgoing_data_rate <= 0.0) { @@ -196,7 +196,7 @@ void EQ::Net::DaybreakConnectionManager::UpdateDataBudget() } } -void EQ::Net::DaybreakConnectionManager::ProcessResend() +void EQ::Net::ReliableStreamConnectionManager::ProcessResend() { auto iter = m_connections.begin(); while (iter != m_connections.end()) { @@ -217,15 +217,15 @@ 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::ReliableStreamConnectionManager::ProcessPacket(const std::string &endpoint, int port, const char *data, size_t size) { if (m_options.simulated_in_packet_loss && m_options.simulated_in_packet_loss >= m_rand.Int(0, 100)) { return; } - if (size < DaybreakHeader::size()) { + if (size < ReliableStreamHeader::size()) { if (m_on_error_message) { - m_on_error_message(fmt::format("Packet of size {0} which is less than {1}", size, DaybreakHeader::size())); + m_on_error_message(fmt::format("Packet of size {0} which is less than {1}", size, ReliableStreamHeader::size())); } return; } @@ -239,9 +239,9 @@ void EQ::Net::DaybreakConnectionManager::ProcessPacket(const std::string &endpoi else { if (data[0] == 0 && data[1] == OP_SessionRequest) { StaticPacket p((void*)data, size); - auto request = p.GetSerialize(0); + auto request = p.GetSerialize(0); - connection = std::shared_ptr(new DaybreakConnection(this, request, endpoint, port)); + connection = std::shared_ptr(new ReliableStreamConnection(this, request, endpoint, port)); connection->m_self = connection; if (m_on_new_connection) { @@ -262,7 +262,7 @@ void EQ::Net::DaybreakConnectionManager::ProcessPacket(const std::string &endpoi } } -std::shared_ptr EQ::Net::DaybreakConnectionManager::FindConnectionByEndpoint(std::string addr, int port) +std::shared_ptr EQ::Net::ReliableStreamConnectionManager::FindConnectionByEndpoint(std::string addr, int port) { auto p = std::make_pair(addr, port); auto iter = m_connections.find(p); @@ -273,9 +273,9 @@ std::shared_ptr EQ::Net::DaybreakConnectionManager: return nullptr; } -void EQ::Net::DaybreakConnectionManager::SendDisconnect(const std::string &addr, int port) +void EQ::Net::ReliableStreamConnectionManager::SendDisconnect(const std::string &addr, int port) { - DaybreakDisconnect header; + ReliableStreamDisconnect header; header.zero = 0; header.opcode = OP_OutOfSession; header.connect_code = 0; @@ -300,7 +300,7 @@ void EQ::Net::DaybreakConnectionManager::SendDisconnect(const std::string &addr, } //new connection made as server -EQ::Net::DaybreakConnection::DaybreakConnection(DaybreakConnectionManager *owner, const DaybreakConnect &connect, const std::string &endpoint, int port) +EQ::Net::ReliableStreamConnection::ReliableStreamConnection(ReliableStreamConnectionManager *owner, const ReliableStreamConnect &connect, const std::string &endpoint, int port) { m_owner = owner; m_last_send = Clock::now(); @@ -327,7 +327,7 @@ EQ::Net::DaybreakConnection::DaybreakConnection(DaybreakConnectionManager *owner } //new connection made as client -EQ::Net::DaybreakConnection::DaybreakConnection(DaybreakConnectionManager *owner, const std::string &endpoint, int port) +EQ::Net::ReliableStreamConnection::ReliableStreamConnection(ReliableStreamConnectionManager *owner, const std::string &endpoint, int port) { m_owner = owner; m_last_send = Clock::now(); @@ -349,11 +349,11 @@ EQ::Net::DaybreakConnection::DaybreakConnection(DaybreakConnectionManager *owner m_outgoing_budget = owner->m_options.outgoing_data_rate; } -EQ::Net::DaybreakConnection::~DaybreakConnection() +EQ::Net::ReliableStreamConnection::~ReliableStreamConnection() { } -void EQ::Net::DaybreakConnection::Close() +void EQ::Net::ReliableStreamConnection::Close() { if (m_status != StatusDisconnected && m_status != StatusDisconnecting) { FlushBuffer(); @@ -367,17 +367,17 @@ void EQ::Net::DaybreakConnection::Close() ChangeStatus(StatusDisconnecting); } -void EQ::Net::DaybreakConnection::QueuePacket(Packet &p) +void EQ::Net::ReliableStreamConnection::QueuePacket(Packet &p) { QueuePacket(p, 0, true); } -void EQ::Net::DaybreakConnection::QueuePacket(Packet &p, int stream) +void EQ::Net::ReliableStreamConnection::QueuePacket(Packet &p, int stream) { QueuePacket(p, stream, true); } -void EQ::Net::DaybreakConnection::QueuePacket(Packet &p, int stream, bool reliable) +void EQ::Net::ReliableStreamConnection::QueuePacket(Packet &p, int stream, bool reliable) { if (*(char*)p.Data() == 0) { DynamicPacket packet; @@ -390,21 +390,21 @@ void EQ::Net::DaybreakConnection::QueuePacket(Packet &p, int stream, bool reliab InternalQueuePacket(p, stream, reliable); } -EQ::Net::DaybreakConnectionStats EQ::Net::DaybreakConnection::GetStats() +EQ::Net::ReliableStreamConnectionStats EQ::Net::ReliableStreamConnection::GetStats() { - EQ::Net::DaybreakConnectionStats ret = m_stats; + EQ::Net::ReliableStreamConnectionStats ret = m_stats; ret.datarate_remaining = m_outgoing_budget; ret.avg_ping = m_rolling_ping; return ret; } -void EQ::Net::DaybreakConnection::ResetStats() +void EQ::Net::ReliableStreamConnection::ResetStats() { m_stats.Reset(); } -void EQ::Net::DaybreakConnection::Process() +void EQ::Net::ReliableStreamConnection::Process() { try { auto now = Clock::now(); @@ -422,7 +422,7 @@ void EQ::Net::DaybreakConnection::Process() } } -void EQ::Net::DaybreakConnection::ProcessPacket(Packet &p) +void EQ::Net::ReliableStreamConnection::ProcessPacket(Packet &p) { m_last_recv = Clock::now(); m_stats.recv_packets++; @@ -458,13 +458,13 @@ void EQ::Net::DaybreakConnection::ProcessPacket(Packet &p) switch (m_encode_passes[i]) { case EncodeCompression: if(temp.GetInt8(0) == 0) - Decompress(temp, DaybreakHeader::size(), temp.Length() - DaybreakHeader::size()); + Decompress(temp, ReliableStreamHeader::size(), temp.Length() - ReliableStreamHeader::size()); else Decompress(temp, 1, temp.Length() - 1); break; case EncodeXOR: if (temp.GetInt8(0) == 0) - Decode(temp, DaybreakHeader::size(), temp.Length() - DaybreakHeader::size()); + Decode(temp, ReliableStreamHeader::size(), temp.Length() - ReliableStreamHeader::size()); else Decode(temp, 1, temp.Length() - 1); break; @@ -483,7 +483,7 @@ void EQ::Net::DaybreakConnection::ProcessPacket(Packet &p) switch (m_encode_passes[i]) { case EncodeXOR: if (temp.GetInt8(0) == 0) - Decode(temp, DaybreakHeader::size(), temp.Length() - DaybreakHeader::size()); + Decode(temp, ReliableStreamHeader::size(), temp.Length() - ReliableStreamHeader::size()); else Decode(temp, 1, temp.Length() - 1); break; @@ -502,7 +502,7 @@ void EQ::Net::DaybreakConnection::ProcessPacket(Packet &p) } } -void EQ::Net::DaybreakConnection::ProcessQueue() +void EQ::Net::ReliableStreamConnection::ProcessQueue() { for (int i = 0; i < 4; ++i) { auto stream = &m_streams[i]; @@ -521,7 +521,7 @@ void EQ::Net::DaybreakConnection::ProcessQueue() } } -void EQ::Net::DaybreakConnection::RemoveFromQueue(int stream, uint16_t seq) +void EQ::Net::ReliableStreamConnection::RemoveFromQueue(int stream, uint16_t seq) { auto s = &m_streams[stream]; auto iter = s->packet_queue.find(seq); @@ -532,7 +532,7 @@ void EQ::Net::DaybreakConnection::RemoveFromQueue(int stream, uint16_t seq) } } -void EQ::Net::DaybreakConnection::AddToQueue(int stream, uint16_t seq, const Packet &p) +void EQ::Net::ReliableStreamConnection::AddToQueue(int stream, uint16_t seq, const Packet &p) { auto s = &m_streams[stream]; auto iter = s->packet_queue.find(seq); @@ -544,7 +544,7 @@ void EQ::Net::DaybreakConnection::AddToQueue(int stream, uint16_t seq, const Pac } } -void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p) +void EQ::Net::ReliableStreamConnection::ProcessDecodedPacket(const Packet &p) { if (p.GetInt8(0) == 0) { if (p.Length() < 2) { @@ -628,13 +628,13 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p) case OP_SessionRequest: { if (m_status == StatusConnected) { - auto request = p.GetSerialize(0); + auto request = p.GetSerialize(0); if (NetworkToHost(request.connect_code) != m_connect_code) { return; } - DaybreakConnectReply reply; + ReliableStreamConnectReply reply; reply.zero = 0; reply.opcode = OP_SessionResponse; reply.connect_code = HostToNetwork(m_connect_code); @@ -656,13 +656,13 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p) case OP_SessionResponse: { if (m_status == StatusConnecting) { - auto reply = p.GetSerialize(0); + auto reply = p.GetSerialize(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_encode_passes[0] = (ReliableStreamEncodeType)reply.encode_pass1; + m_encode_passes[1] = (ReliableStreamEncodeType)reply.encode_pass2; m_max_packet_size = reply.max_packet_size; ChangeStatus(StatusConnected); @@ -686,7 +686,7 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p) return; } - auto header = p.GetSerialize(0); + auto header = p.GetSerialize(0); auto sequence = NetworkToHost(header.sequence); auto stream_id = header.opcode - OP_Packet; auto stream = &m_streams[stream_id]; @@ -703,7 +703,7 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p) RemoveFromQueue(stream_id, sequence); SendAck(stream_id, stream->sequence_in); stream->sequence_in++; - StaticPacket next((char*)p.Data() + DaybreakReliableHeader::size(), p.Length() - DaybreakReliableHeader::size()); + StaticPacket next((char*)p.Data() + ReliableStreamReliableHeader::size(), p.Length() - ReliableStreamReliableHeader::size()); ProcessDecodedPacket(next); } @@ -715,7 +715,7 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p) case OP_Fragment3: case OP_Fragment4: { - auto header = p.GetSerialize(0); + auto header = p.GetSerialize(0); auto sequence = NetworkToHost(header.sequence); auto stream_id = header.opcode - OP_Fragment; auto stream = &m_streams[stream_id]; @@ -735,22 +735,22 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p) stream->sequence_in++; if (stream->fragment_total_bytes == 0) { - auto fragheader = p.GetSerialize(0); + auto fragheader = p.GetSerialize(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()); + (char*)p.Data() + ReliableStreamReliableFragmentHeader::size(), p.Length() - ReliableStreamReliableFragmentHeader::size()); - stream->fragment_current_bytes += (uint32_t)(p.Length() - DaybreakReliableFragmentHeader::size()); + stream->fragment_current_bytes += (uint32_t)(p.Length() - ReliableStreamReliableFragmentHeader::size()); } else { stream->fragment_packet.PutData( stream->fragment_current_bytes, - (char*)p.Data() + DaybreakReliableHeader::size(), p.Length() - DaybreakReliableHeader::size()); + (char*)p.Data() + ReliableStreamReliableHeader::size(), p.Length() - ReliableStreamReliableHeader::size()); - stream->fragment_current_bytes += (uint32_t)(p.Length() - DaybreakReliableHeader::size()); + stream->fragment_current_bytes += (uint32_t)(p.Length() - ReliableStreamReliableHeader::size()); if (stream->fragment_current_bytes >= stream->fragment_total_bytes) { ProcessDecodedPacket(stream->fragment_packet); @@ -769,7 +769,7 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p) case OP_Ack3: case OP_Ack4: { - auto header = p.GetSerialize(0); + auto header = p.GetSerialize(0); auto sequence = NetworkToHost(header.sequence); auto stream_id = header.opcode - OP_Ack; Ack(stream_id, sequence); @@ -781,7 +781,7 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p) case OP_OutOfOrderAck3: case OP_OutOfOrderAck4: { - auto header = p.GetSerialize(0); + auto header = p.GetSerialize(0); auto sequence = NetworkToHost(header.sequence); auto stream_id = header.opcode - OP_OutOfOrderAck; OutOfOrderAck(stream_id, sequence); @@ -815,13 +815,13 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p) } case OP_SessionStatRequest: { - auto request = p.GetSerialize(0); + auto request = p.GetSerialize(0); m_stats.sync_remote_sent_packets = EQ::Net::NetworkToHost(request.packets_sent); m_stats.sync_remote_recv_packets = EQ::Net::NetworkToHost(request.packets_recv); m_stats.sync_sent_packets = m_stats.sent_packets; m_stats.sync_recv_packets = m_stats.recv_packets; - DaybreakSessionStatResponse response; + ReliableStreamSessionStatResponse response; response.zero = 0; response.opcode = OP_SessionStatResponse; response.timestamp = request.timestamp; @@ -836,7 +836,7 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p) break; } case OP_SessionStatResponse: { - auto response = p.GetSerialize(0); + auto response = p.GetSerialize(0); m_stats.sync_remote_sent_packets = EQ::Net::NetworkToHost(response.server_sent); m_stats.sync_remote_recv_packets = EQ::Net::NetworkToHost(response.server_recv); m_stats.sync_sent_packets = m_stats.sent_packets; @@ -858,7 +858,7 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p) } } -bool EQ::Net::DaybreakConnection::ValidateCRC(Packet &p) +bool EQ::Net::ReliableStreamConnection::ValidateCRC(Packet &p) { if (m_crc_bytes == 0U) { return true; @@ -892,7 +892,7 @@ bool EQ::Net::DaybreakConnection::ValidateCRC(Packet &p) return false; } -void EQ::Net::DaybreakConnection::AppendCRC(Packet &p) +void EQ::Net::ReliableStreamConnection::AppendCRC(Packet &p) { if (m_crc_bytes == 0U) { return; @@ -911,7 +911,7 @@ void EQ::Net::DaybreakConnection::AppendCRC(Packet &p) } } -void EQ::Net::DaybreakConnection::ChangeStatus(DbProtocolStatus new_status) +void EQ::Net::ReliableStreamConnection::ChangeStatus(DbProtocolStatus new_status) { if (m_owner->m_on_connection_state_change) { if (auto self = m_self.lock()) { @@ -922,7 +922,7 @@ void EQ::Net::DaybreakConnection::ChangeStatus(DbProtocolStatus new_status) m_status = new_status; } -bool EQ::Net::DaybreakConnection::PacketCanBeEncoded(Packet &p) const +bool EQ::Net::ReliableStreamConnection::PacketCanBeEncoded(Packet &p) const { if (p.Length() < 2) { return false; @@ -941,7 +941,7 @@ 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::ReliableStreamConnection::Decode(Packet &p, size_t offset, size_t length) { int key = m_encode_key; char *buffer = (char*)p.Data() + offset; @@ -961,7 +961,7 @@ 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::ReliableStreamConnection::Encode(Packet &p, size_t offset, size_t length) { int key = m_encode_key; char *buffer = (char*)p.Data() + offset; @@ -1050,7 +1050,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::ReliableStreamConnection::Decompress(Packet &p, size_t offset, size_t length) { if (length < 2) { return; @@ -1075,7 +1075,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::ReliableStreamConnection::Compress(Packet &p, size_t offset, size_t length) { static thread_local uint8_t new_buffer[2048] = { 0 }; uint8_t *buffer = (uint8_t*)p.Data() + offset; @@ -1097,14 +1097,14 @@ void EQ::Net::DaybreakConnection::Compress(Packet &p, size_t offset, size_t leng p.PutData(offset, new_buffer, new_length); } -void EQ::Net::DaybreakConnection::ProcessResend() +void EQ::Net::ReliableStreamConnection::ProcessResend() { for (int i = 0; i < 4; ++i) { ProcessResend(i); } } -void EQ::Net::DaybreakConnection::ProcessResend(int stream) +void EQ::Net::ReliableStreamConnection::ProcessResend(int stream) { if (m_status == DbProtocolStatus::StatusDisconnected) { return; @@ -1201,7 +1201,7 @@ void EQ::Net::DaybreakConnection::ProcessResend(int stream) auto &sp = e.second; auto &p = sp.packet; - if (p.Length() >= DaybreakHeader::size()) { + if (p.Length() >= ReliableStreamHeader::size()) { if (p.GetInt8(0) == 0 && p.GetInt8(1) >= OP_Fragment && p.GetInt8(1) <= OP_Fragment4) { m_stats.resent_fragments++; } @@ -1232,7 +1232,7 @@ void EQ::Net::DaybreakConnection::ProcessResend(int stream) m_last_ack = now; } -void EQ::Net::DaybreakConnection::Ack(int stream, uint16_t seq) +void EQ::Net::ReliableStreamConnection::Ack(int stream, uint16_t seq) { auto now = Clock::now(); auto s = &m_streams[stream]; @@ -1259,7 +1259,7 @@ void EQ::Net::DaybreakConnection::Ack(int stream, uint16_t seq) m_last_ack = now; } -void EQ::Net::DaybreakConnection::OutOfOrderAck(int stream, uint16_t seq) +void EQ::Net::ReliableStreamConnection::OutOfOrderAck(int stream, uint16_t seq) { auto now = Clock::now(); auto s = &m_streams[stream]; @@ -1279,15 +1279,15 @@ void EQ::Net::DaybreakConnection::OutOfOrderAck(int stream, uint16_t seq) m_last_ack = now; } -void EQ::Net::DaybreakConnection::UpdateDataBudget(double budget_add) +void EQ::Net::ReliableStreamConnection::UpdateDataBudget(double budget_add) { auto outgoing_data_rate = m_owner->m_options.outgoing_data_rate; m_outgoing_budget = EQ::ClampUpper(m_outgoing_budget + budget_add, outgoing_data_rate); } -void EQ::Net::DaybreakConnection::SendAck(int stream_id, uint16_t seq) +void EQ::Net::ReliableStreamConnection::SendAck(int stream_id, uint16_t seq) { - DaybreakReliableHeader ack; + ReliableStreamReliableHeader ack; ack.zero = 0; ack.opcode = OP_Ack + stream_id; ack.sequence = HostToNetwork(seq); @@ -1298,9 +1298,9 @@ void EQ::Net::DaybreakConnection::SendAck(int stream_id, uint16_t seq) InternalBufferedSend(p); } -void EQ::Net::DaybreakConnection::SendOutOfOrderAck(int stream_id, uint16_t seq) +void EQ::Net::ReliableStreamConnection::SendOutOfOrderAck(int stream_id, uint16_t seq) { - DaybreakReliableHeader ack; + ReliableStreamReliableHeader ack; ack.zero = 0; ack.opcode = OP_OutOfOrderAck + stream_id; ack.sequence = HostToNetwork(seq); @@ -1311,9 +1311,9 @@ void EQ::Net::DaybreakConnection::SendOutOfOrderAck(int stream_id, uint16_t seq) InternalBufferedSend(p); } -void EQ::Net::DaybreakConnection::SendDisconnect() +void EQ::Net::ReliableStreamConnection::SendDisconnect() { - DaybreakDisconnect disconnect; + ReliableStreamDisconnect disconnect; disconnect.zero = 0; disconnect.opcode = OP_SessionDisconnect; disconnect.connect_code = HostToNetwork(m_connect_code); @@ -1322,7 +1322,7 @@ void EQ::Net::DaybreakConnection::SendDisconnect() InternalSend(out); } -void EQ::Net::DaybreakConnection::InternalBufferedSend(Packet &p) +void EQ::Net::ReliableStreamConnection::InternalBufferedSend(Packet &p) { if (p.Length() > 0xFFU) { FlushBuffer(); @@ -1331,7 +1331,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(); + size_t raw_size = ReliableStreamHeader::size() + (size_t)m_crc_bytes + m_buffered_packets_length + m_buffered_packets.size() + 1 + p.Length(); if (raw_size > m_max_packet_size) { FlushBuffer(); } @@ -1346,9 +1346,9 @@ void EQ::Net::DaybreakConnection::InternalBufferedSend(Packet &p) } } -void EQ::Net::DaybreakConnection::SendConnect() +void EQ::Net::ReliableStreamConnection::SendConnect() { - DaybreakConnect connect; + ReliableStreamConnect connect; connect.zero = 0; connect.opcode = OP_SessionRequest; connect.protocol_version = HostToNetwork(3U); @@ -1361,9 +1361,9 @@ void EQ::Net::DaybreakConnection::SendConnect() InternalSend(p); } -void EQ::Net::DaybreakConnection::SendKeepAlive() +void EQ::Net::ReliableStreamConnection::SendKeepAlive() { - DaybreakHeader keep_alive; + ReliableStreamHeader keep_alive; keep_alive.zero = 0; keep_alive.opcode = OP_KeepAlive; @@ -1373,7 +1373,7 @@ void EQ::Net::DaybreakConnection::SendKeepAlive() InternalSend(p); } -void EQ::Net::DaybreakConnection::InternalSend(Packet &p) { +void EQ::Net::ReliableStreamConnection::InternalSend(Packet &p) { if (m_owner->m_options.outgoing_data_rate > 0.0) { auto new_budget = m_outgoing_budget - (p.Length() / 1024.0); if (new_budget <= 0.0) { @@ -1409,14 +1409,14 @@ void EQ::Net::DaybreakConnection::InternalSend(Packet &p) { switch (m_encode_passe) { case EncodeCompression: if (out.GetInt8(0) == 0) { - Compress(out, DaybreakHeader::size(), out.Length() - DaybreakHeader::size()); + Compress(out, ReliableStreamHeader::size(), out.Length() - ReliableStreamHeader::size()); } else { Compress(out, 1, out.Length() - 1); } break; case EncodeXOR: if (out.GetInt8(0) == 0) { - Encode(out, DaybreakHeader::size(), out.Length() - DaybreakHeader::size()); + Encode(out, ReliableStreamHeader::size(), out.Length() - ReliableStreamHeader::size()); } else { Encode(out, 1, out.Length() - 1); } @@ -1466,7 +1466,7 @@ void EQ::Net::DaybreakConnection::InternalSend(Packet &p) { } } -void EQ::Net::DaybreakConnection::InternalQueuePacket(Packet &p, int stream_id, bool reliable) +void EQ::Net::ReliableStreamConnection::InternalQueuePacket(Packet &p, int stream_id, bool reliable) { if (!reliable) { auto max_raw_size = 0xFFU - m_crc_bytes; @@ -1480,23 +1480,23 @@ void EQ::Net::DaybreakConnection::InternalQueuePacket(Packet &p, int stream_id, } auto stream = &m_streams[stream_id]; - auto max_raw_size = m_max_packet_size - m_crc_bytes - DaybreakReliableHeader::size() - 1; // -1 for compress flag + auto max_raw_size = m_max_packet_size - m_crc_bytes - ReliableStreamReliableHeader::size() - 1; // -1 for compress flag size_t length = p.Length(); if (length > max_raw_size) { - DaybreakReliableFragmentHeader first_header; + ReliableStreamReliableFragmentHeader first_header; first_header.reliable.zero = 0; first_header.reliable.opcode = OP_Fragment + 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() - 1; // -1 for compress flag + size_t sublen = m_max_packet_size - m_crc_bytes - ReliableStreamReliableFragmentHeader::size() - 1; // -1 for compress flag DynamicPacket first_packet; first_packet.PutSerialize(0, first_header); - first_packet.PutData(DaybreakReliableFragmentHeader::size(), (char*)p.Data() + used, sublen); + first_packet.PutData(ReliableStreamReliableFragmentHeader::size(), (char*)p.Data() + used, sublen); used += sublen; - DaybreakSentPacket sent; + ReliableStreamSentPacket sent; sent.packet.PutPacket(0, first_packet); sent.last_sent = Clock::now(); sent.first_sent = Clock::now(); @@ -1513,22 +1513,22 @@ void EQ::Net::DaybreakConnection::InternalQueuePacket(Packet &p, int stream_id, while (used < length) { auto left = length - used; DynamicPacket packet; - DaybreakReliableHeader header; + ReliableStreamReliableHeader header; header.zero = 0; header.opcode = OP_Fragment + stream_id; header.sequence = HostToNetwork(stream->sequence_out); packet.PutSerialize(0, header); if (left > max_raw_size) { - packet.PutData(DaybreakReliableHeader::size(), (char*)p.Data() + used, max_raw_size); + packet.PutData(ReliableStreamReliableHeader::size(), (char*)p.Data() + used, max_raw_size); used += max_raw_size; } else { - packet.PutData(DaybreakReliableHeader::size(), (char*)p.Data() + used, left); + packet.PutData(ReliableStreamReliableHeader::size(), (char*)p.Data() + used, left); used += left; } - DaybreakSentPacket sent; + ReliableStreamSentPacket sent; sent.packet.PutPacket(0, packet); sent.last_sent = Clock::now(); sent.first_sent = Clock::now(); @@ -1545,14 +1545,14 @@ void EQ::Net::DaybreakConnection::InternalQueuePacket(Packet &p, int stream_id, } else { DynamicPacket packet; - DaybreakReliableHeader header; + ReliableStreamReliableHeader header; header.zero = 0; header.opcode = OP_Packet + stream_id; header.sequence = HostToNetwork(stream->sequence_out); packet.PutSerialize(0, header); - packet.PutPacket(DaybreakReliableHeader::size(), p); + packet.PutPacket(ReliableStreamReliableHeader::size(), p); - DaybreakSentPacket sent; + ReliableStreamSentPacket sent; sent.packet.PutPacket(0, packet); sent.last_sent = Clock::now(); sent.first_sent = Clock::now(); @@ -1568,7 +1568,7 @@ void EQ::Net::DaybreakConnection::InternalQueuePacket(Packet &p, int stream_id, } } -void EQ::Net::DaybreakConnection::FlushBuffer() +void EQ::Net::ReliableStreamConnection::FlushBuffer() { if (m_buffered_packets.empty()) { return; @@ -1595,7 +1595,7 @@ void EQ::Net::DaybreakConnection::FlushBuffer() m_buffered_packets_length = 0; } -EQ::Net::SequenceOrder EQ::Net::DaybreakConnection::CompareSequence(uint16_t expected, uint16_t actual) const +EQ::Net::SequenceOrder EQ::Net::ReliableStreamConnection::CompareSequence(uint16_t expected, uint16_t actual) const { int diff = (int)actual - (int)expected; diff --git a/common/net/daybreak_connection.h b/common/net/reliable_stream_connection.h similarity index 72% rename from common/net/daybreak_connection.h rename to common/net/reliable_stream_connection.h index 1fddc09c9..97e1982c7 100644 --- a/common/net/daybreak_connection.h +++ b/common/net/reliable_stream_connection.h @@ -2,8 +2,8 @@ #include "../random.h" #include "packet.h" -#include "daybreak_structs.h" -#include "daybreak_pooling.h" +#include "reliable_stream_structs.h" +#include "reliable_stream_pooling.h" #include #include #include @@ -16,7 +16,7 @@ namespace EQ { namespace Net { - enum DaybreakProtocolOpcode + enum ReliableStreamProtocolOpcode { OP_Padding = 0x00, OP_SessionRequest = 0x01, @@ -55,7 +55,7 @@ namespace EQ StatusDisconnected }; - enum DaybreakEncodeType + enum ReliableStreamEncodeType { EncodeNone = 0, EncodeCompression = 1, @@ -72,9 +72,9 @@ namespace EQ typedef std::chrono::steady_clock::time_point Timestamp; typedef std::chrono::steady_clock Clock; - struct DaybreakConnectionStats + struct ReliableStreamConnectionStats { - DaybreakConnectionStats() { + ReliableStreamConnectionStats() { recv_bytes = 0; sent_bytes = 0; recv_packets = 0; @@ -134,14 +134,14 @@ namespace EQ uint64_t bytes_before_encode; }; - class DaybreakConnectionManager; - class DaybreakConnection; - class DaybreakConnection + class ReliableStreamConnectionManager; + class ReliableStreamConnection; + class ReliableStreamConnection { public: - DaybreakConnection(DaybreakConnectionManager *owner, const DaybreakConnect &connect, const std::string &endpoint, int port); - DaybreakConnection(DaybreakConnectionManager *owner, const std::string &endpoint, int port); - ~DaybreakConnection(); + ReliableStreamConnection(ReliableStreamConnectionManager *owner, const ReliableStreamConnect &connect, const std::string &endpoint, int port); + ReliableStreamConnection(ReliableStreamConnectionManager *owner, const std::string &endpoint, int port); + ~ReliableStreamConnection(); const std::string& RemoteEndpoint() const { return m_endpoint; } int RemotePort() const { return m_port; } @@ -151,23 +151,23 @@ namespace EQ void QueuePacket(Packet &p, int stream); void QueuePacket(Packet &p, int stream, bool reliable); - DaybreakConnectionStats GetStats(); + ReliableStreamConnectionStats GetStats(); void ResetStats(); size_t GetRollingPing() const { return m_rolling_ping; } DbProtocolStatus GetStatus() const { return m_status; } - const DaybreakEncodeType* GetEncodePasses() const { return m_encode_passes; } - const DaybreakConnectionManager* GetManager() const { return m_owner; } - DaybreakConnectionManager* GetManager() { return m_owner; } + const ReliableStreamEncodeType* GetEncodePasses() const { return m_encode_passes; } + const ReliableStreamConnectionManager* GetManager() const { return m_owner; } + ReliableStreamConnectionManager* GetManager() { return m_owner; } private: - DaybreakConnectionManager *m_owner; + ReliableStreamConnectionManager *m_owner; std::string m_endpoint; int m_port; uint32_t m_connect_code; uint32_t m_encode_key; uint32_t m_max_packet_size; uint32_t m_crc_bytes; - DaybreakEncodeType m_encode_passes[2]; + ReliableStreamEncodeType m_encode_passes[2]; Timestamp m_last_send; Timestamp m_last_recv; @@ -176,7 +176,7 @@ namespace EQ std::list m_buffered_packets; size_t m_buffered_packets_length; std::unique_ptr m_combined; - DaybreakConnectionStats m_stats; + ReliableStreamConnectionStats m_stats; Timestamp m_last_session_stats; size_t m_rolling_ping; Timestamp m_close_time; @@ -188,7 +188,7 @@ namespace EQ bool m_acked_since_last_resend = false; Timestamp m_last_ack; - struct DaybreakSentPacket + struct ReliableStreamSentPacket { DynamicPacket packet; Timestamp last_sent; @@ -197,9 +197,9 @@ namespace EQ size_t resend_delay; }; - struct DaybreakStream + struct ReliableStream { - DaybreakStream() { + ReliableStream() { sequence_in = 0; sequence_out = 0; fragment_current_bytes = 0; @@ -214,11 +214,11 @@ namespace EQ uint32_t fragment_current_bytes; uint32_t fragment_total_bytes; - std::map sent_packets; + std::map sent_packets; }; - DaybreakStream m_streams[4]; - std::weak_ptr m_self; + ReliableStream m_streams[4]; + std::weak_ptr m_self; void Process(); void ProcessPacket(Packet &p); @@ -251,12 +251,12 @@ namespace EQ void FlushBuffer(); SequenceOrder CompareSequence(uint16_t expected, uint16_t actual) const; - friend class DaybreakConnectionManager; + friend class ReliableStreamConnectionManager; }; - struct DaybreakConnectionManagerOptions + struct ReliableStreamConnectionManagerOptions { - DaybreakConnectionManagerOptions() { + ReliableStreamConnectionManagerOptions() { max_connection_count = 0; keepalive_delay_ms = 9000; resend_delay_ms = 30; @@ -268,8 +268,8 @@ namespace EQ connect_stale_ms = 5000; crc_length = 2; max_packet_size = 512; - encode_passes[0] = DaybreakEncodeType::EncodeNone; - encode_passes[1] = DaybreakEncodeType::EncodeNone; + encode_passes[0] = ReliableStreamEncodeType::EncodeNone; + encode_passes[1] = ReliableStreamEncodeType::EncodeNone; port = 0; hold_size = 512; hold_length_ms = 50; @@ -299,28 +299,28 @@ namespace EQ double tic_rate_hertz; size_t resend_timeout; size_t connection_close_time; - DaybreakEncodeType encode_passes[2]; + ReliableStreamEncodeType encode_passes[2]; int port; double outgoing_data_rate; }; - class DaybreakConnectionManager + class ReliableStreamConnectionManager { public: - DaybreakConnectionManager(); - DaybreakConnectionManager(const DaybreakConnectionManagerOptions &opts); - ~DaybreakConnectionManager(); + ReliableStreamConnectionManager(); + ReliableStreamConnectionManager(const ReliableStreamConnectionManagerOptions &opts); + ~ReliableStreamConnectionManager(); void Connect(const std::string &addr, int port); void Process(); void UpdateDataBudget(); void ProcessResend(); - void OnNewConnection(std::function)> func) { m_on_new_connection = func; } - void OnConnectionStateChange(std::function, DbProtocolStatus, DbProtocolStatus)> func) { m_on_connection_state_change = func; } - void OnPacketRecv(std::function, const Packet &)> func) { m_on_packet_recv = func; } + void OnNewConnection(std::function)> func) { m_on_new_connection = func; } + void OnConnectionStateChange(std::function, DbProtocolStatus, DbProtocolStatus)> func) { m_on_connection_state_change = func; } + void OnPacketRecv(std::function, const Packet &)> func) { m_on_packet_recv = func; } void OnErrorMessage(std::function func) { m_on_error_message = func; } - DaybreakConnectionManagerOptions& GetOptions() { return m_options; } + ReliableStreamConnectionManagerOptions& GetOptions() { return m_options; } private: void Attach(uv_loop_t *loop); void Detach(); @@ -329,18 +329,18 @@ namespace EQ uv_timer_t m_timer; uv_udp_t m_socket; uv_loop_t *m_attached; - DaybreakConnectionManagerOptions m_options; - std::function)> m_on_new_connection; - std::function, DbProtocolStatus, DbProtocolStatus)> m_on_connection_state_change; - std::function, const Packet&)> m_on_packet_recv; + ReliableStreamConnectionManagerOptions m_options; + std::function)> m_on_new_connection; + std::function, DbProtocolStatus, DbProtocolStatus)> m_on_connection_state_change; + std::function, const Packet&)> m_on_packet_recv; std::function m_on_error_message; - std::map, std::shared_ptr> m_connections; + std::map, std::shared_ptr> m_connections; void ProcessPacket(const std::string &endpoint, int port, const char *data, size_t size); - std::shared_ptr FindConnectionByEndpoint(std::string addr, int port); + std::shared_ptr FindConnectionByEndpoint(std::string addr, int port); void SendDisconnect(const std::string &addr, int port); - friend class DaybreakConnection; + friend class ReliableStreamConnection; }; } } diff --git a/common/net/daybreak_pooling.h b/common/net/reliable_stream_pooling.h similarity index 100% rename from common/net/daybreak_pooling.h rename to common/net/reliable_stream_pooling.h diff --git a/common/net/daybreak_structs.h b/common/net/reliable_stream_structs.h similarity index 86% rename from common/net/daybreak_structs.h rename to common/net/reliable_stream_structs.h index 3047897b2..f48e1f9c3 100644 --- a/common/net/daybreak_structs.h +++ b/common/net/reliable_stream_structs.h @@ -8,7 +8,7 @@ namespace EQ { namespace Net { - struct DaybreakHeader + struct ReliableStreamHeader { static size_t size() { return 2; } uint8_t zero; @@ -22,7 +22,7 @@ namespace EQ } }; - struct DaybreakConnect + struct ReliableStreamConnect { static size_t size() { return 14; } uint8_t zero; @@ -42,7 +42,7 @@ namespace EQ } }; - struct DaybreakConnectReply + struct ReliableStreamConnectReply { static size_t size() { return 17; } uint8_t zero; @@ -68,7 +68,7 @@ namespace EQ } }; - struct DaybreakDisconnect + struct ReliableStreamDisconnect { static size_t size() { return 8; } uint8_t zero; @@ -84,7 +84,7 @@ namespace EQ } }; - struct DaybreakReliableHeader + struct ReliableStreamReliableHeader { static size_t size() { return 4; } uint8_t zero; @@ -100,10 +100,10 @@ namespace EQ } }; - struct DaybreakReliableFragmentHeader + struct ReliableStreamReliableFragmentHeader { - static size_t size() { return 4 + DaybreakReliableHeader::size(); } - DaybreakReliableHeader reliable; + static size_t size() { return 4 + ReliableStreamReliableHeader::size(); } + ReliableStreamReliableHeader reliable; uint32_t total_size; template @@ -114,7 +114,7 @@ namespace EQ } }; - struct DaybreakSessionStatRequest + struct ReliableStreamSessionStatRequest { static size_t size() { return 40; } uint8_t zero; @@ -144,7 +144,7 @@ namespace EQ } }; - struct DaybreakSessionStatResponse + struct ReliableStreamSessionStatResponse { static size_t size() { return 40; } uint8_t zero; diff --git a/common/spdat.h b/common/spdat.h index afc00f4dd..4cea6e098 100644 --- a/common/spdat.h +++ b/common/spdat.h @@ -1057,7 +1057,7 @@ typedef enum { } DmgShieldType; //Spell Effect IDs -// https://forums.daybreakgames.com/eq/index.php?threads/enumerated-spa-list.206288/ +// https://web.archive.org/web/20250816011656/https://forums.everquest.com/index.php?threads/enumerated-spa-list.206288/ // mirror: http://pastebin.com/MYeQqGwe #define SE_CurrentHP 0 // implemented - Heals and nukes, repeates every tic if in a buff #define SE_ArmorClass 1 // implemented diff --git a/hc/eq.cpp b/hc/eq.cpp index aab481e82..d8f2877d8 100644 --- a/hc/eq.cpp +++ b/hc/eq.cpp @@ -33,7 +33,7 @@ EverQuest::EverQuest(const std::string &host, int port, const std::string &user, } else { m_host = addr; - m_login_connection_manager.reset(new EQ::Net::DaybreakConnectionManager()); + m_login_connection_manager.reset(new EQ::Net::ReliableStreamConnectionManager()); m_login_connection_manager->OnNewConnection(std::bind(&EverQuest::LoginOnNewConnection, this, std::placeholders::_1)); m_login_connection_manager->OnConnectionStateChange(std::bind(&EverQuest::LoginOnStatusChangeReconnectEnabled, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)); @@ -48,13 +48,13 @@ EverQuest::~EverQuest() { } -void EverQuest::LoginOnNewConnection(std::shared_ptr connection) +void EverQuest::LoginOnNewConnection(std::shared_ptr connection) { m_login_connection = connection; Log.OutF(Logs::General, Logs::Headless_Client, "Connecting..."); } -void EverQuest::LoginOnStatusChangeReconnectEnabled(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to) +void EverQuest::LoginOnStatusChangeReconnectEnabled(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to) { if (to == EQ::Net::StatusConnected) { Log.OutF(Logs::General, Logs::Headless_Client, "Login connected."); @@ -70,14 +70,14 @@ void EverQuest::LoginOnStatusChangeReconnectEnabled(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to) +void EverQuest::LoginOnStatusChangeReconnectDisabled(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to) { if (to == EQ::Net::StatusDisconnected) { m_login_connection.reset(); } } -void EverQuest::LoginOnPacketRecv(std::shared_ptr conn, const EQ::Net::Packet & p) +void EverQuest::LoginOnPacketRecv(std::shared_ptr conn, const EQ::Net::Packet & p) { auto opcode = p.GetUInt16(0); switch (opcode) { @@ -251,20 +251,20 @@ void EverQuest::LoginDisableReconnect() void EverQuest::ConnectToWorld() { - m_world_connection_manager.reset(new EQ::Net::DaybreakConnectionManager()); + m_world_connection_manager.reset(new EQ::Net::ReliableStreamConnectionManager()); m_world_connection_manager->OnNewConnection(std::bind(&EverQuest::WorldOnNewConnection, this, std::placeholders::_1)); m_world_connection_manager->OnConnectionStateChange(std::bind(&EverQuest::WorldOnStatusChangeReconnectEnabled, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)); m_world_connection_manager->OnPacketRecv(std::bind(&EverQuest::WorldOnPacketRecv, this, std::placeholders::_1, std::placeholders::_2)); m_world_connection_manager->Connect(m_host, 9000); } -void EverQuest::WorldOnNewConnection(std::shared_ptr connection) +void EverQuest::WorldOnNewConnection(std::shared_ptr connection) { m_world_connection = connection; Log.OutF(Logs::General, Logs::Headless_Client, "Connecting to world..."); } -void EverQuest::WorldOnStatusChangeReconnectEnabled(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to) +void EverQuest::WorldOnStatusChangeReconnectEnabled(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to) { if (to == EQ::Net::StatusConnected) { Log.OutF(Logs::General, Logs::Headless_Client, "World connected."); @@ -278,14 +278,14 @@ void EverQuest::WorldOnStatusChangeReconnectEnabled(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to) +void EverQuest::WorldOnStatusChangeReconnectDisabled(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to) { if (to == EQ::Net::StatusDisconnected) { m_world_connection.reset(); } } -void EverQuest::WorldOnPacketRecv(std::shared_ptr conn, const EQ::Net::Packet & p) +void EverQuest::WorldOnPacketRecv(std::shared_ptr conn, const EQ::Net::Packet & p) { auto opcode = p.GetUInt16(0); switch (opcode) { diff --git a/hc/eq.h b/hc/eq.h index 7cdbfe1cd..63467b318 100644 --- a/hc/eq.h +++ b/hc/eq.h @@ -1,7 +1,7 @@ #pragma once #include "../common/eqemu_logsys.h" -#include "../common/net/daybreak_connection.h" +#include "../common/net/reliable_stream_connection.h" #include "../common/event/timer.h" #include #include @@ -26,10 +26,10 @@ public: private: //Login - void LoginOnNewConnection(std::shared_ptr connection); - void LoginOnStatusChangeReconnectEnabled(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to); - void LoginOnStatusChangeReconnectDisabled(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to); - void LoginOnPacketRecv(std::shared_ptr conn, const EQ::Net::Packet &p); + void LoginOnNewConnection(std::shared_ptr connection); + void LoginOnStatusChangeReconnectEnabled(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to); + void LoginOnStatusChangeReconnectDisabled(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to); + void LoginOnPacketRecv(std::shared_ptr conn, const EQ::Net::Packet &p); void LoginSendSessionReady(); void LoginSendLogin(); @@ -41,25 +41,25 @@ private: void LoginDisableReconnect(); - std::unique_ptr m_login_connection_manager; - std::shared_ptr m_login_connection; + std::unique_ptr m_login_connection_manager; + std::shared_ptr m_login_connection; std::map m_world_servers; //World void ConnectToWorld(); - void WorldOnNewConnection(std::shared_ptr connection); - void WorldOnStatusChangeReconnectEnabled(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to); - void WorldOnStatusChangeReconnectDisabled(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to); - void WorldOnPacketRecv(std::shared_ptr conn, const EQ::Net::Packet &p); + void WorldOnNewConnection(std::shared_ptr connection); + void WorldOnStatusChangeReconnectEnabled(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to); + void WorldOnStatusChangeReconnectDisabled(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to); + void WorldOnPacketRecv(std::shared_ptr conn, const EQ::Net::Packet &p); void WorldSendClientAuth(); void WorldSendEnterWorld(const std::string &character); void WorldProcessCharacterSelect(const EQ::Net::Packet &p); - std::unique_ptr m_world_connection_manager; - std::shared_ptr m_world_connection; + std::unique_ptr m_world_connection_manager; + std::shared_ptr m_world_connection; //Variables std::string m_host; diff --git a/hc/login.cpp b/hc/login.cpp index 170a32bf7..f6dca7c78 100644 --- a/hc/login.cpp +++ b/hc/login.cpp @@ -26,7 +26,7 @@ LoginConnection::LoginConnection(const std::string &username, const std::string m_host_port = host_port; m_server = server; - m_connection_manager.reset(new EQ::Net::DaybreakConnectionManager()); + m_connection_manager.reset(new EQ::Net::ReliableStreamConnectionManager()); m_connection_manager->OnNewConnection(std::bind(&LoginConnection::OnNewConnection, this, std::placeholders::_1)); m_connection_manager->OnConnectionStateChange(std::bind(&LoginConnection::OnStatusChangeActive, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)); @@ -39,13 +39,13 @@ LoginConnection::~LoginConnection() { } -void LoginConnection::OnNewConnection(std::shared_ptr connection) +void LoginConnection::OnNewConnection(std::shared_ptr connection) { m_connection = connection; Log.OutF(Logs::General, Logs::Headless_Client, "Connecting..."); } -void LoginConnection::OnStatusChangeActive(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to) +void LoginConnection::OnStatusChangeActive(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to) { if (to == EQ::Net::StatusConnected) { Log.OutF(Logs::General, Logs::Headless_Client, "Login connected."); @@ -61,7 +61,7 @@ void LoginConnection::OnStatusChangeActive(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to) +void LoginConnection::OnStatusChangeInactive(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to) { if (to == EQ::Net::StatusDisconnected) { m_key.clear(); @@ -70,7 +70,7 @@ void LoginConnection::OnStatusChangeInactive(std::shared_ptr conn, const EQ::Net::Packet &p) +void LoginConnection::OnPacketRecv(std::shared_ptr conn, const EQ::Net::Packet &p) { auto opcode = p.GetUInt16(0); switch (opcode) { diff --git a/hc/login.h b/hc/login.h index 31a448b70..bec7c3cdd 100644 --- a/hc/login.h +++ b/hc/login.h @@ -1,6 +1,6 @@ #pragma once -#include "../common/net/daybreak_connection.h" +#include "../common/net/reliable_stream_connection.h" #include "../common/event/timer.h" #include @@ -23,10 +23,10 @@ public: ~LoginConnection(); private: - void OnNewConnection(std::shared_ptr connection); - void OnStatusChangeActive(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to); - void OnStatusChangeInactive(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to); - void OnPacketRecv(std::shared_ptr conn, const EQ::Net::Packet &p); + void OnNewConnection(std::shared_ptr connection); + void OnStatusChangeActive(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to); + void OnStatusChangeInactive(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to); + void OnPacketRecv(std::shared_ptr conn, const EQ::Net::Packet &p); void Kill(); void Start(); @@ -38,8 +38,8 @@ private: void ProcessServerPacketList(const EQ::Net::Packet &p); void ProcessServerPlayResponse(const EQ::Net::Packet &p); - std::unique_ptr m_connection_manager; - std::shared_ptr m_connection; + std::unique_ptr m_connection_manager; + std::shared_ptr m_connection; bool m_connecting; std::unique_ptr m_connect_timer; diff --git a/hc/world.cpp b/hc/world.cpp index 7be7cecb4..c9d690f62 100644 --- a/hc/world.cpp +++ b/hc/world.cpp @@ -8,7 +8,7 @@ WorldConnection::WorldConnection(const std::string &key, uint32_t dbid, const st m_key = key; m_dbid = dbid; - m_connection_manager.reset(new EQ::Net::DaybreakConnectionManager()); + m_connection_manager.reset(new EQ::Net::ReliableStreamConnectionManager()); m_connection_manager->OnNewConnection(std::bind(&WorldConnection::OnNewConnection, this, std::placeholders::_1)); m_connection_manager->OnConnectionStateChange(std::bind(&WorldConnection::OnStatusChangeActive, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)); m_connection_manager->OnPacketRecv(std::bind(&WorldConnection::OnPacketRecv, this, std::placeholders::_1, std::placeholders::_2)); @@ -18,13 +18,13 @@ WorldConnection::WorldConnection(const std::string &key, uint32_t dbid, const st WorldConnection::~WorldConnection() { } -void WorldConnection::OnNewConnection(std::shared_ptr connection) +void WorldConnection::OnNewConnection(std::shared_ptr connection) { m_connection = connection; Log.OutF(Logs::General, Logs::Headless_Client, "Connecting to world..."); } -void WorldConnection::OnStatusChangeActive(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to) +void WorldConnection::OnStatusChangeActive(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to) { if (to == EQ::Net::StatusConnected) { Log.OutF(Logs::General, Logs::Headless_Client, "World connected."); @@ -38,14 +38,14 @@ void WorldConnection::OnStatusChangeActive(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to) +void WorldConnection::OnStatusChangeInactive(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to) { if (to == EQ::Net::StatusDisconnected) { m_connection.reset(); } } -void WorldConnection::OnPacketRecv(std::shared_ptr conn, const EQ::Net::Packet &p) +void WorldConnection::OnPacketRecv(std::shared_ptr conn, const EQ::Net::Packet &p) { auto opcode = p.GetUInt16(0); Log.OutF(Logs::General, Logs::Headless_Client, "Packet in:\n{0}", p.ToString()); diff --git a/hc/world.h b/hc/world.h index 7ca0e96d7..b1df83894 100644 --- a/hc/world.h +++ b/hc/world.h @@ -1,6 +1,6 @@ #pragma once -#include "../common/net/daybreak_connection.h" +#include "../common/net/reliable_stream_connection.h" #include "../common/event/timer.h" #include @@ -10,17 +10,17 @@ public: WorldConnection(const std::string &key, uint32_t dbid, const std::string &host); ~WorldConnection(); private: - void OnNewConnection(std::shared_ptr connection); - void OnStatusChangeActive(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to); - void OnStatusChangeInactive(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to); - void OnPacketRecv(std::shared_ptr conn, const EQ::Net::Packet &p); + void OnNewConnection(std::shared_ptr connection); + void OnStatusChangeActive(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to); + void OnStatusChangeInactive(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to); + void OnPacketRecv(std::shared_ptr conn, const EQ::Net::Packet &p); void Kill(); void Start(); void SendClientAuth(); - std::unique_ptr m_connection_manager; - std::shared_ptr m_connection; + std::unique_ptr m_connection_manager; + std::shared_ptr m_connection; bool m_connecting; std::unique_ptr m_connect_timer; diff --git a/loginserver/account_management.cpp b/loginserver/account_management.cpp index a76ae894b..f7c0ed535 100644 --- a/loginserver/account_management.cpp +++ b/loginserver/account_management.cpp @@ -124,18 +124,18 @@ uint64 AccountManagement::CheckExternalLoginserverUserCredentials(LoginAccountCo bool running = true; uint32 ret = 0; - EQ::Net::DaybreakConnectionManager mgr; - std::shared_ptr conn; + EQ::Net::ReliableStreamConnectionManager mgr; + std::shared_ptr conn; mgr.OnNewConnection( - [&](std::shared_ptr connection) { + [&](std::shared_ptr connection) { conn = connection; } ); mgr.OnConnectionStateChange( [&]( - std::shared_ptr conn, + std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to ) { @@ -152,7 +152,7 @@ uint64 AccountManagement::CheckExternalLoginserverUserCredentials(LoginAccountCo ); mgr.OnPacketRecv( - [&](std::shared_ptr conn, const EQ::Net::Packet &p) { + [&](std::shared_ptr conn, const EQ::Net::Packet &p) { auto opcode = p.GetUInt16(0); switch (opcode) { case 0x0017: //OP_ChatMessage @@ -250,18 +250,18 @@ uint64 AccountManagement::HealthCheckUserLogin() bool running = true; uint64 ret = 0; - EQ::Net::DaybreakConnectionManager mgr; - std::shared_ptr c; + EQ::Net::ReliableStreamConnectionManager mgr; + std::shared_ptr c; mgr.OnNewConnection( - [&](std::shared_ptr connection) { + [&](std::shared_ptr connection) { c = connection; } ); mgr.OnConnectionStateChange( [&]( - std::shared_ptr conn, + std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to ) { @@ -278,7 +278,7 @@ uint64 AccountManagement::HealthCheckUserLogin() ); mgr.OnPacketRecv( - [&](std::shared_ptr conn, const EQ::Net::Packet &p) { + [&](std::shared_ptr conn, const EQ::Net::Packet &p) { auto opcode = p.GetUInt16(0); switch (opcode) { case 0x0017: //OP_ChatMessage diff --git a/loginserver/client.h b/loginserver/client.h index 5c62f2c83..0dc71d00c 100644 --- a/loginserver/client.h +++ b/loginserver/client.h @@ -6,7 +6,7 @@ #include "../common/random.h" #include "../common/eq_stream_intf.h" #include "../common/net/dns.h" -#include "../common/net/daybreak_connection.h" +#include "../common/net/reliable_stream_connection.h" #include "login_types.h" #include "../common/repositories/login_accounts_repository.h" #include @@ -54,8 +54,8 @@ private: unsigned int m_selected_play_server_id; unsigned int m_play_sequence_id; std::string m_key; - std::unique_ptr m_login_connection_manager; - std::shared_ptr m_login_connection; + std::unique_ptr m_login_connection_manager; + std::shared_ptr m_login_connection; LoginBaseMessage m_login_base_message; std::string m_stored_username; std::string m_stored_password; diff --git a/ucs/clientlist.cpp b/ucs/clientlist.cpp index 251fd8f05..749b9276f 100644 --- a/ucs/clientlist.cpp +++ b/ucs/clientlist.cpp @@ -469,11 +469,11 @@ static void ProcessCommandIgnore(Client *c, std::string Ignoree) { Clientlist::Clientlist(int ChatPort) { EQStreamManagerInterfaceOptions chat_opts(ChatPort, false, false); chat_opts.opcode_size = 1; - chat_opts.daybreak_options.stale_connection_ms = 600000; - chat_opts.daybreak_options.resend_delay_ms = RuleI(Network, ResendDelayBaseMS); - chat_opts.daybreak_options.resend_delay_factor = RuleR(Network, ResendDelayFactor); - chat_opts.daybreak_options.resend_delay_min = RuleI(Network, ResendDelayMinMS); - chat_opts.daybreak_options.resend_delay_max = RuleI(Network, ResendDelayMaxMS); + chat_opts.reliable_stream_options.stale_connection_ms = 600000; + chat_opts.reliable_stream_options.resend_delay_ms = RuleI(Network, ResendDelayBaseMS); + chat_opts.reliable_stream_options.resend_delay_factor = RuleR(Network, ResendDelayFactor); + chat_opts.reliable_stream_options.resend_delay_min = RuleI(Network, ResendDelayMinMS); + chat_opts.reliable_stream_options.resend_delay_max = RuleI(Network, ResendDelayMaxMS); chatsf = new EQ::Net::EQStreamManager(chat_opts); diff --git a/world/main.cpp b/world/main.cpp index 9ea0f26cb..c9386128e 100644 --- a/world/main.cpp +++ b/world/main.cpp @@ -333,11 +333,11 @@ int main(int argc, char **argv) WorldBoot::CheckForPossibleConfigurationIssues(); EQStreamManagerInterfaceOptions opts(9000, false, false); - opts.daybreak_options.resend_delay_ms = RuleI(Network, ResendDelayBaseMS); - opts.daybreak_options.resend_delay_factor = RuleR(Network, ResendDelayFactor); - opts.daybreak_options.resend_delay_min = RuleI(Network, ResendDelayMinMS); - opts.daybreak_options.resend_delay_max = RuleI(Network, ResendDelayMaxMS); - opts.daybreak_options.outgoing_data_rate = RuleR(Network, ClientDataRate); + opts.reliable_stream_options.resend_delay_ms = RuleI(Network, ResendDelayBaseMS); + opts.reliable_stream_options.resend_delay_factor = RuleR(Network, ResendDelayFactor); + opts.reliable_stream_options.resend_delay_min = RuleI(Network, ResendDelayMinMS); + opts.reliable_stream_options.resend_delay_max = RuleI(Network, ResendDelayMaxMS); + opts.reliable_stream_options.outgoing_data_rate = RuleR(Network, ClientDataRate); EQ::Net::EQStreamManager eqsm(opts); diff --git a/zone/api_service.cpp b/zone/api_service.cpp index 6f1c16d9d..607ab64c6 100644 --- a/zone/api_service.cpp +++ b/zone/api_service.cpp @@ -82,7 +82,7 @@ Json::Value ApiGetPacketStatistics(EQ::Net::WebsocketServerConnection *connectio auto connection = client->Connection(); auto opts = connection->GetManager()->GetOptions(); auto eqs_stats = connection->GetStats(); - auto &stats = eqs_stats.DaybreakStats; + auto &stats = eqs_stats.ReliableStreamStats; auto now = EQ::Net::Clock::now(); auto sec_since_stats_reset = std::chrono::duration_cast>( now - stats.created diff --git a/zone/attack.cpp b/zone/attack.cpp index 9c6581a32..f541c3e92 100644 --- a/zone/attack.cpp +++ b/zone/attack.cpp @@ -401,8 +401,8 @@ bool Mob::AvoidDamage(Mob *other, DamageHitInfo &hit) */ /* Order according to current (SoF+?) dev quotes: - * https://forums.daybreakgames.com/eq/index.php?threads/test-update-06-10-15.223510/page-2#post-3261772 - * https://forums.daybreakgames.com/eq/index.php?threads/test-update-06-10-15.223510/page-2#post-3268227 + * https://web.archive.org/web/20250816014133/https://forums.everquest.com/index.php?threads/test-update-06-10-15.223510/page-2#post-3261772 + * https://web.archive.org/web/20250816014133/https://forums.everquest.com/index.php?threads/test-update-06-10-15.223510/page-2#post-3268227 * Riposte 50, hDEX, must have weapon/fists, doesn't work on archery/throwing * Block 25, hDEX, works on archery/throwing, behind block done here if back to attacker base1 is chance * Parry 45, hDEX, doesn't work on throwing/archery, must be facing target @@ -461,7 +461,7 @@ bool Mob::AvoidDamage(Mob *other, DamageHitInfo &hit) } /* Heroic Strikethrough Implementation per Dev Quotes (2018): - * https://forums.daybreakgames.com/eq/index.php?threads/illusions-benefit-neza-10-dodge.246757/#post-3622670 + * https://web.archive.org/web/20250816014810/https://forums.everquest.com/index.php?threads/illusions-benefit-neza-10-dodge.246757/#post-3622670 * Step1 = HeroicStrikethrough(NPC) * Step2 = HeroicAgility / 25 * Step3 = MIN( Step1, Step2 ) @@ -3414,7 +3414,7 @@ void Mob::DamageShield(Mob* attacker, bool spell_ds) { uint8 Mob::GetWeaponDamageBonus(const EQ::ItemData *weapon, bool offhand) { // dev quote with old and new formulas - // https://forums.daybreakgames.com/eq/index.php?threads/test-update-09-17-15.226618/page-5#post-3326194 + // https://web.archive.org/web/20250816013618/https://forums.everquest.com/index.php?threads/test-update-09-17-15.226618/page-5#post-3326194 // // We assume that the level check is done before calling this function and sinister strikes is checked before // calling for offhand DB diff --git a/zone/gm_commands/show/network.cpp b/zone/gm_commands/show/network.cpp index d9eff2c16..46d32a69c 100644 --- a/zone/gm_commands/show/network.cpp +++ b/zone/gm_commands/show/network.cpp @@ -16,17 +16,17 @@ void ShowNetwork(Client *c, const Seperator *sep) popup_table += DialogueWindow::TableRow( DialogueWindow::TableCell("Max Packet Size") + - DialogueWindow::TableCell(Strings::Commify(opts.daybreak_options.max_packet_size)) + DialogueWindow::TableCell(Strings::Commify(opts.reliable_stream_options.max_packet_size)) ); popup_table += DialogueWindow::TableRow( DialogueWindow::TableCell("Max Connection Count") + - DialogueWindow::TableCell(Strings::Commify(opts.daybreak_options.max_connection_count)) + DialogueWindow::TableCell(Strings::Commify(opts.reliable_stream_options.max_connection_count)) ); popup_table += DialogueWindow::TableRow( DialogueWindow::TableCell("Keep Alive Delay") + - DialogueWindow::TableCell(Strings::MillisecondsToTime(opts.daybreak_options.keepalive_delay_ms)) + DialogueWindow::TableCell(Strings::MillisecondsToTime(opts.reliable_stream_options.keepalive_delay_ms)) ); popup_table += DialogueWindow::TableRow( @@ -34,64 +34,64 @@ void ShowNetwork(Client *c, const Seperator *sep) DialogueWindow::TableCell( fmt::format( "{:.2f}", - opts.daybreak_options.resend_delay_factor + opts.reliable_stream_options.resend_delay_factor ) ) ); popup_table += DialogueWindow::TableRow( DialogueWindow::TableCell("Resend Delay") + - DialogueWindow::TableCell(Strings::MillisecondsToTime(opts.daybreak_options.resend_delay_ms)) + DialogueWindow::TableCell(Strings::MillisecondsToTime(opts.reliable_stream_options.resend_delay_ms)) ); popup_table += DialogueWindow::TableRow( DialogueWindow::TableCell("Resend Delay Minimum") + - DialogueWindow::TableCell(Strings::MillisecondsToTime(opts.daybreak_options.resend_delay_min)) + DialogueWindow::TableCell(Strings::MillisecondsToTime(opts.reliable_stream_options.resend_delay_min)) ); popup_table += DialogueWindow::TableRow( DialogueWindow::TableCell("Resend Delay Maximum") + - DialogueWindow::TableCell(Strings::MillisecondsToTime(opts.daybreak_options.resend_delay_max)) + DialogueWindow::TableCell(Strings::MillisecondsToTime(opts.reliable_stream_options.resend_delay_max)) ); popup_table += DialogueWindow::TableRow( DialogueWindow::TableCell("Connect Delay") + - DialogueWindow::TableCell(Strings::MillisecondsToTime(opts.daybreak_options.connect_delay_ms)) + DialogueWindow::TableCell(Strings::MillisecondsToTime(opts.reliable_stream_options.connect_delay_ms)) ); popup_table += DialogueWindow::TableRow( DialogueWindow::TableCell("Connect Stale") + - DialogueWindow::TableCell(Strings::MillisecondsToTime(opts.daybreak_options.connect_stale_ms)) + DialogueWindow::TableCell(Strings::MillisecondsToTime(opts.reliable_stream_options.connect_stale_ms)) ); popup_table += DialogueWindow::TableRow( DialogueWindow::TableCell("Stale Connection") + - DialogueWindow::TableCell(Strings::MillisecondsToTime(opts.daybreak_options.stale_connection_ms)) + DialogueWindow::TableCell(Strings::MillisecondsToTime(opts.reliable_stream_options.stale_connection_ms)) ); popup_table += DialogueWindow::TableRow( DialogueWindow::TableCell("CRC Length") + - DialogueWindow::TableCell(Strings::Commify(opts.daybreak_options.crc_length)) + DialogueWindow::TableCell(Strings::Commify(opts.reliable_stream_options.crc_length)) ); popup_table += DialogueWindow::TableRow( DialogueWindow::TableCell("Hold Size") + - DialogueWindow::TableCell(Strings::Commify(opts.daybreak_options.hold_size)) + DialogueWindow::TableCell(Strings::Commify(opts.reliable_stream_options.hold_size)) ); popup_table += DialogueWindow::TableRow( DialogueWindow::TableCell("Hold Length") + - DialogueWindow::TableCell(Strings::MillisecondsToTime(opts.daybreak_options.hold_length_ms)) + DialogueWindow::TableCell(Strings::MillisecondsToTime(opts.reliable_stream_options.hold_length_ms)) ); popup_table += DialogueWindow::TableRow( DialogueWindow::TableCell("Simulated In Packet Loss") + - DialogueWindow::TableCell(std::to_string(opts.daybreak_options.simulated_in_packet_loss)) + DialogueWindow::TableCell(std::to_string(opts.reliable_stream_options.simulated_in_packet_loss)) ); popup_table += DialogueWindow::TableRow( DialogueWindow::TableCell("Simulated Out Packet Loss") + - DialogueWindow::TableCell(std::to_string(opts.daybreak_options.simulated_out_packet_loss)) + DialogueWindow::TableCell(std::to_string(opts.reliable_stream_options.simulated_out_packet_loss)) ); popup_table += DialogueWindow::TableRow( @@ -99,34 +99,34 @@ void ShowNetwork(Client *c, const Seperator *sep) DialogueWindow::TableCell( fmt::format( "{:.2f}", - opts.daybreak_options.tic_rate_hertz + opts.reliable_stream_options.tic_rate_hertz ) ) ); popup_table += DialogueWindow::TableRow( DialogueWindow::TableCell("Resend Timeout") + - DialogueWindow::TableCell(Strings::MillisecondsToTime(opts.daybreak_options.resend_timeout)) + DialogueWindow::TableCell(Strings::MillisecondsToTime(opts.reliable_stream_options.resend_timeout)) ); popup_table += DialogueWindow::TableRow( DialogueWindow::TableCell("Connection Close Time") + - DialogueWindow::TableCell(Strings::MillisecondsToTime(opts.daybreak_options.connection_close_time)) + DialogueWindow::TableCell(Strings::MillisecondsToTime(opts.reliable_stream_options.connection_close_time)) ); popup_table += DialogueWindow::TableRow( DialogueWindow::TableCell("Encode Passes (1)") + - DialogueWindow::TableCell(Strings::Commify(opts.daybreak_options.encode_passes[0])) + DialogueWindow::TableCell(Strings::Commify(opts.reliable_stream_options.encode_passes[0])) ); popup_table += DialogueWindow::TableRow( DialogueWindow::TableCell("Encode Passes (2)") + - DialogueWindow::TableCell(Strings::Commify(opts.daybreak_options.encode_passes[1])) + DialogueWindow::TableCell(Strings::Commify(opts.reliable_stream_options.encode_passes[1])) ); popup_table += DialogueWindow::TableRow( DialogueWindow::TableCell("Port") + - DialogueWindow::TableCell(Strings::Commify(opts.daybreak_options.port)) + DialogueWindow::TableCell(Strings::Commify(opts.reliable_stream_options.port)) ); popup_table = DialogueWindow::Table(popup_table); diff --git a/zone/gm_commands/show/network_stats.cpp b/zone/gm_commands/show/network_stats.cpp index 8d51e8f69..75bf2b25f 100644 --- a/zone/gm_commands/show/network_stats.cpp +++ b/zone/gm_commands/show/network_stats.cpp @@ -7,7 +7,7 @@ void ShowNetworkStats(Client *c, const Seperator *sep) const auto opts = connection->GetManager()->GetOptions(); const auto eqs_stats = connection->GetStats(); - const auto& stats = eqs_stats.DaybreakStats; + const auto& stats = eqs_stats.ReliableStreamStats; const auto sec_since_stats_reset = std::chrono::duration_cast>( EQ::Net::Clock::now() - stats.created @@ -217,7 +217,7 @@ void ShowNetworkStats(Client *c, const Seperator *sep) ) ); - if (opts.daybreak_options.outgoing_data_rate > 0.0) { + if (opts.reliable_stream_options.outgoing_data_rate > 0.0) { popup_table += DialogueWindow::TableRow( DialogueWindow::TableCell("Outgoing Link Saturation") + DialogueWindow::TableCell( @@ -229,14 +229,14 @@ void ShowNetworkStats(Client *c, const Seperator *sep) 1.0 - ( ( - opts.daybreak_options.outgoing_data_rate - + opts.reliable_stream_options.outgoing_data_rate - stats.datarate_remaining ) / - opts.daybreak_options.outgoing_data_rate + opts.reliable_stream_options.outgoing_data_rate ) ) ), - opts.daybreak_options.outgoing_data_rate + opts.reliable_stream_options.outgoing_data_rate ) ) ); diff --git a/zone/main.cpp b/zone/main.cpp index 6177ce562..4f5916078 100644 --- a/zone/main.cpp +++ b/zone/main.cpp @@ -555,11 +555,11 @@ int main(int argc, char **argv) LogInfo("Starting EQ Network server on port [{}]", Config->ZonePort); EQStreamManagerInterfaceOptions opts(Config->ZonePort, false, RuleB(Network, CompressZoneStream)); - opts.daybreak_options.resend_delay_ms = RuleI(Network, ResendDelayBaseMS); - opts.daybreak_options.resend_delay_factor = RuleR(Network, ResendDelayFactor); - opts.daybreak_options.resend_delay_min = RuleI(Network, ResendDelayMinMS); - opts.daybreak_options.resend_delay_max = RuleI(Network, ResendDelayMaxMS); - opts.daybreak_options.outgoing_data_rate = RuleR(Network, ClientDataRate); + opts.reliable_stream_options.resend_delay_ms = RuleI(Network, ResendDelayBaseMS); + opts.reliable_stream_options.resend_delay_factor = RuleR(Network, ResendDelayFactor); + opts.reliable_stream_options.resend_delay_min = RuleI(Network, ResendDelayMinMS); + opts.reliable_stream_options.resend_delay_max = RuleI(Network, ResendDelayMaxMS); + opts.reliable_stream_options.outgoing_data_rate = RuleR(Network, ClientDataRate); eqsm = std::make_unique(opts); eqsf_open = true;