From b42d453d603e54e395efe9b537f9687cc33b4315 Mon Sep 17 00:00:00 2001 From: Rich Logan Date: Wed, 21 Aug 2024 15:44:34 +0100 Subject: [PATCH 1/2] Rename to match style --- .clang-tidy | 26 +- .git-blame-ignore-revs | 3 + cmd/client.cc | 42 +- cmd/echoServer.cc | 38 +- include/transport/priority_queue.h | 104 ++-- include/transport/safe_queue.h | 118 ++--- include/transport/span.h | 4 + include/transport/stream_buffer.h | 156 +++--- include/transport/time_queue.h | 194 ++++---- include/transport/transport.h | 82 ++-- include/transport/transport_metrics.h | 70 +-- include/transport/uintvar.h | 52 +- src/transport.cpp | 12 +- src/transport_picoquic.cpp | 670 +++++++++++++------------- src/transport_picoquic.h | 135 +++--- src/transport_udp.cpp | 600 +++++++++++------------ src/transport_udp.h | 106 ++-- src/transport_udp_protocol.h | 30 +- 18 files changed, 1235 insertions(+), 1207 deletions(-) create mode 100644 .git-blame-ignore-revs diff --git a/.clang-tidy b/.clang-tidy index f05068d..fcc07a6 100644 --- a/.clang-tidy +++ b/.clang-tidy @@ -11,7 +11,29 @@ Checks: ' readability-non-const-parameter, ' CheckOptions: - - { key: readability-identifier-naming.PrivateMemberPrefix, value: _ } - - { key: readability-identifier-naming.ClassCase, value: CamelCase } + - { key: readability-identifier-naming.ClassCase, value: CamelCase } + - { key: readability-identifier-naming.ClassMemberCase, value: lower_case } + - { key: readability-identifier-naming.ConstexprVariableCase, value: CamelCase } + - { key: readability-identifier-naming.ConstexprVariablePrefix, value: k } + - { key: readability-identifier-naming.EnumCase, value: CamelCase } + - { key: readability-identifier-naming.EnumConstantCase, value: CamelCase } + - { key: readability-identifier-naming.EnumConstantPrefix, value: k } + - { key: readability-identifier-naming.FunctionCase, value: CamelCase } + - { key: readability-identifier-naming.GlobalConstantCase, value: CamelCase } + - { key: readability-identifier-naming.GlobalConstantPrefix, value: k } + - { key: readability-identifier-naming.StaticConstantCase, value: CamelCase } + - { key: readability-identifier-naming.StaticConstantPrefix, value: k } + - { key: readability-identifier-naming.StaticVariableCase, value: lower_case } + - { key: readability-identifier-naming.MacroDefinitionCase, value: UPPER_CASE } + - { key: readability-identifier-naming.MacroDefinitionIgnoredRegexp, value: '^[A-Z]+(_[A-Z]+)*_$' } + - { key: readability-identifier-naming.MemberCase, value: lower_case } + - { key: readability-identifier-naming.PrivateMemberSuffix, value: _ } + - { key: readability-identifier-naming.PublicMemberSuffix, value: '' } + - { key: readability-identifier-naming.NamespaceCase, value: lower_case } + - { key: readability-identifier-naming.ParameterCase, value: lower_case } + - { key: readability-identifier-naming.TypeAliasCase, value: CamelCase } + - { key: readability-identifier-naming.TypedefCase, value: CamelCase } + - { key: readability-identifier-naming.VariableCase, value: lower_case } + - { key: readability-identifier-naming.IgnoreMainLikeFunctions, value: 1 } WarningsAsErrors: "*" HeaderFilterRegex: "(/include/transport|/src)/.*" diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs new file mode 100644 index 0000000..bd7868b --- /dev/null +++ b/.git-blame-ignore-revs @@ -0,0 +1,3 @@ +# Rename +d67b913f5a8cf5c5a869c70862b857f4f99093bd +38cd7b58bfb93ea996f5ca348ea903f0c5463a8b diff --git a/cmd/client.cc b/cmd/client.cc index a280be4..725c9b7 100644 --- a/cmd/client.cc +++ b/cmd/client.cc @@ -37,28 +37,28 @@ struct Delegate : public ITransport::TransportDelegate TransportConnId getContextId() const { return conn_id; } - void on_connection_status(const TransportConnId& conn_id, const TransportStatus status) + void OnConnectionStatus(const TransportConnId& conn_id, const TransportStatus status) { SPDLOG_LOGGER_INFO(logger, "Connection state change conn_id: {0}, {1}", conn_id, int(status)); } - void on_new_connection(const TransportConnId& , const TransportRemote&) {} + void OnNewConnection(const TransportConnId& , const TransportRemote&) {} - void on_recv_stream(const TransportConnId& conn_id, + void OnRecvStream(const TransportConnId& conn_id, uint64_t stream_id, std::optional data_ctx_id, [[maybe_unused]] const bool is_bidir) { - auto stream_buf = client->getStreamBuffer(conn_id, stream_id); + auto stream_buf = client->GetStreamBuffer(conn_id, stream_id); while (true) { - if (stream_buf->available(4)) { - auto msg_len_b = stream_buf->front(4); + if (stream_buf->Available(4)) { + auto msg_len_b = stream_buf->Front(4); auto* msg_len = reinterpret_cast(msg_len_b.data()); - if (stream_buf->available(*msg_len)) { - auto obj = stream_buf->front(*msg_len); - stream_buf->pop(*msg_len); + if (stream_buf->Available(*msg_len)) { + auto obj = stream_buf->Front(*msg_len); + stream_buf->Pop(*msg_len); _rx_object.process(conn_id, data_ctx_id, obj); } else { @@ -70,11 +70,11 @@ struct Delegate : public ITransport::TransportDelegate } } - void on_recv_dgram(const TransportConnId& conn_id, + void OnRecvDgram(const TransportConnId& conn_id, std::optional data_ctx_id) { for (int i=0; i < 50; i++) { - auto data = client->dequeue(conn_id, data_ctx_id); + auto data = client->Dequeue(conn_id, data_ctx_id); if (data) { _rx_object.process(conn_id, data_ctx_id, *data); @@ -82,7 +82,7 @@ struct Delegate : public ITransport::TransportDelegate } } - void on_new_data_context(const TransportConnId&, const DataContextId&) {} + void OnNewDataContext(const TransportConnId&, const DataContextId&) {} }; auto logger = spdlog::stderr_color_mt("CLIENT"); @@ -95,7 +95,7 @@ main() logger->set_level(spdlog::level::debug); - TransportRemote server = TransportRemote{ "127.0.0.1", 1234, TransportProtocol::QUIC }; + TransportRemote server = TransportRemote{ "127.0.0.1", 1234, TransportProtocol::kQuic }; TransportConfig tconfig{ .tls_cert_filename = "", .tls_key_filename = "", @@ -114,7 +114,7 @@ main() if (getenv("RELAY_UNIDIR")) bidir = false; - auto client = ITransport::make_client_transport(server, tconfig, d, logger); + auto client = ITransport::MakeClientTransport(server, tconfig, d, logger); SPDLOG_LOGGER_INFO(logger, "bidir is {0}", (bidir ? "True" : "False")); SPDLOG_LOGGER_INFO(logger, "client use_count: {0}", client.use_count()); @@ -125,15 +125,15 @@ main() auto metrics_conn_samples = std::make_shared>(10); auto metrics_data_samples = std::make_shared>(10); - auto conn_id = client->start(metrics_conn_samples, metrics_data_samples); + auto conn_id = client->Start(metrics_conn_samples, metrics_data_samples); - while (client->status() != TransportStatus::Ready) { + while (client->Status() != TransportStatus::kReady) { SPDLOG_LOGGER_INFO(logger, "Waiting for client to be ready"); std::this_thread::sleep_for(std::chrono::milliseconds(250)); } bool use_reliable = true; - DataContextId data_ctx_id = client->createDataContext(conn_id, use_reliable, 1, bidir); + DataContextId data_ctx_id = client->CreateDataContext(conn_id, use_reliable, 1, bidir); int period_count = 0; @@ -141,7 +141,7 @@ main() auto tx_object = Object(logger); - while (client->status() != TransportStatus::Shutdown && client->status() != TransportStatus::Disconnected) { + while (client->Status() != TransportStatus::kShutdown && client->Status() != TransportStatus::kDisconnected) { period_count++; for (int i = 0; i < 10; i++) { auto obj = tx_object.encode(); @@ -163,7 +163,7 @@ main() } } - client->enqueue(conn_id, + client->Enqueue(conn_id, data_ctx_id, std::move(obj), std::move(trace), @@ -174,7 +174,7 @@ main() } // Increase delay if using UDP, need to pace more - if (server.proto == TransportProtocol::UDP) { + if (server.proto == TransportProtocol::kUdp) { std::this_thread::sleep_for(std::chrono::milliseconds (10)); } else { std::this_thread::sleep_for(std::chrono::milliseconds(2)); @@ -183,7 +183,7 @@ main() } - client->deleteDataContext(conn_id, data_ctx_id); + client->DeleteDataContext(conn_id, data_ctx_id); SPDLOG_LOGGER_INFO(logger, "Done with transport, closing"); client.reset(); diff --git a/cmd/echoServer.cc b/cmd/echoServer.cc index 6b9af55..41df525 100644 --- a/cmd/echoServer.cc +++ b/cmd/echoServer.cc @@ -31,41 +31,41 @@ struct Delegate : public ITransport::TransportDelegate void setServerTransport(std::shared_ptr server) { this->server = server; } - void on_connection_status(const TransportConnId& conn_id, const TransportStatus status) + void OnConnectionStatus(const TransportConnId& conn_id, const TransportStatus status) { SPDLOG_LOGGER_INFO(logger, "Connection state change conn_id: {0}, {1}", conn_id, int(status)); } - void on_new_connection(const TransportConnId& conn_id, const TransportRemote& remote) + void OnNewConnection(const TransportConnId& conn_id, const TransportRemote& remote) { SPDLOG_LOGGER_INFO(logger, "New connection conn_id: {0} from {1}:{2}", conn_id, remote.host_or_ip, remote.port); - out_data_ctx = this->server->createDataContext(conn_id, true, 10); + out_data_ctx = this->server->CreateDataContext(conn_id, true, 10); } - void on_recv_stream(const TransportConnId& conn_id, + void OnRecvStream(const TransportConnId& conn_id, uint64_t stream_id, std::optional data_ctx_id, [[maybe_unused]] const bool is_bidir) { - auto stream_buf = server->getStreamBuffer(conn_id, stream_id); + auto stream_buf = server->GetStreamBuffer(conn_id, stream_id); while(true) { - if (stream_buf->available(4)) { - auto len_b = stream_buf->front(4); + if (stream_buf->Available(4)) { + auto len_b = stream_buf->Front(4); if (!len_b.size()) return; auto* msg_len = reinterpret_cast(len_b.data()); - if (stream_buf->available(*msg_len)) { - auto obj = stream_buf->front(*msg_len); - stream_buf->pop(*msg_len); + if (stream_buf->Available(*msg_len)) { + auto obj = stream_buf->Front(*msg_len); + stream_buf->Pop(*msg_len); _object.process(conn_id, data_ctx_id, obj); - server->enqueue(conn_id, out_data_ctx, std::move(obj), { MethodTraceItem{} }, 2, 500, 0, { true, false, false, false }); + server->Enqueue(conn_id, out_data_ctx, std::move(obj), { MethodTraceItem{} }, 2, 500, 0, { true, false, false, false }); } else { break; } @@ -75,21 +75,21 @@ struct Delegate : public ITransport::TransportDelegate } } - void on_recv_dgram(const TransportConnId& conn_id, + void OnRecvDgram(const TransportConnId& conn_id, std::optional data_ctx_id) { for (int i=0; i < 150; i++) { - auto data = server->dequeue(conn_id, data_ctx_id); + auto data = server->Dequeue(conn_id, data_ctx_id); if (data) { _object.process(conn_id, data_ctx_id, *data); - server->enqueue(conn_id, out_data_ctx, std::move(*data)); + server->Enqueue(conn_id, out_data_ctx, std::move(*data)); } } } - void on_new_data_context(const TransportConnId& conn_id, const DataContextId& data_ctx_id) + void OnNewDataContext(const TransportConnId& conn_id, const DataContextId& data_ctx_id) { SPDLOG_LOGGER_INFO(logger, "Callback for new data context conn_id: {0} data_ctx_id: {1}", conn_id, data_ctx_id); } @@ -103,7 +103,7 @@ main() logger->set_level(spdlog::level::debug); Delegate d; - TransportRemote serverIp = TransportRemote{ "127.0.0.1", 1234, TransportProtocol::QUIC }; + TransportRemote serverIp = TransportRemote{ "127.0.0.1", 1234, TransportProtocol::kQuic }; TransportConfig tconfig{ .tls_cert_filename = "./server-cert.pem", .tls_key_filename = "./server-key.pem", .time_queue_max_duration = 1000, @@ -113,15 +113,15 @@ main() if ((envVar = getenv("RELAY_PORT"))) serverIp.port = atoi(envVar); - auto server = ITransport::make_server_transport(serverIp, tconfig, d, logger); + auto server = ITransport::MakeServerTransport(serverIp, tconfig, d, logger); auto metrics_conn_samples = std::make_shared>(10); auto metrics_data_samples = std::make_shared>(10); - server->start(metrics_conn_samples, metrics_data_samples); + server->Start(metrics_conn_samples, metrics_data_samples); d.setServerTransport(server); - while (server->status() != TransportStatus::Shutdown) { + while (server->Status() != TransportStatus::kShutdown) { std::this_thread::sleep_for(std::chrono::seconds(3)); } diff --git a/include/transport/priority_queue.h b/include/transport/priority_queue.h index 01c4d45..dc544b0 100644 --- a/include/transport/priority_queue.h +++ b/include/transport/priority_queue.h @@ -25,8 +25,8 @@ namespace qtransport { template class PriorityQueue { - using timeType = std::chrono::milliseconds; - using timeQueue = TimeQueue; + using TimeType = std::chrono::milliseconds; + using TimeQueueType = TimeQueue; struct Exception : public std::runtime_error { @@ -47,7 +47,7 @@ namespace qtransport { * @param tick_service Shared pointer to tick_service service */ PriorityQueue(const std::shared_ptr& tick_service) - : PriorityQueue(1000, 1, _tick_service, 1000) + : PriorityQueue(1000, 1, tick_service_, 1000) { } @@ -63,16 +63,16 @@ namespace qtransport { size_t interval, const std::shared_ptr& tick_service, size_t initial_queue_size) - : _tick_service(tick_service) + : tick_service_(tick_service) { if (tick_service == nullptr) { throw std::invalid_argument("Tick service cannot be null"); } - _initial_queue_size = initial_queue_size; - _duration_ms = duration; - _interval_ms = interval; + initial_queue_size_ = initial_queue_size; + duration_ms_ = duration; + interval_ms_ = interval; } /** @@ -83,12 +83,12 @@ namespace qtransport { * @param priority The priority of the value (range is 0 - PMAX) * @param delay_ttl Delay POP by this ttl value in milliseconds */ - void push(DataType& value, uint32_t ttl, uint8_t priority = 0, uint32_t delay_ttl=0) + void Push(DataType& value, uint32_t ttl, uint8_t priority = 0, uint32_t delay_ttl=0) { - std::lock_guard _(_mutex); + std::lock_guard _(mutex_); - auto& queue = get_queue_by_priority(priority); - queue->push(value, ttl, delay_ttl); + auto& queue = GetQueueByPriority(priority); + queue->Push(value, ttl, delay_ttl); } /** @@ -99,11 +99,11 @@ namespace qtransport { * @param priority The priority of the value (range is 0 - PMAX) * @param delay_ttl Delay POP by this ttl value in milliseconds */ - void push(DataType&& value, uint32_t ttl, uint8_t priority = 0, uint32_t delay_ttl=0) { - std::lock_guard _(_mutex); + void Push(DataType&& value, uint32_t ttl, uint8_t priority = 0, uint32_t delay_ttl=0) { + std::lock_guard _(mutex_); - auto& queue = get_queue_by_priority(priority); - queue->push(std::move(value), ttl, delay_ttl); + auto& queue = GetQueueByPriority(priority); + queue->Push(std::move(value), ttl, delay_ttl); } /** @@ -111,15 +111,15 @@ namespace qtransport { * * @return TimeQueueElement value from time queue */ - TimeQueueElement front() + TimeQueueElement Front() { - std::lock_guard _(_mutex); + std::lock_guard _(mutex_); - for (auto& tqueue : _queue) { - if (!tqueue || tqueue->empty()) + for (auto& tqueue : queue_) { + if (!tqueue || tqueue->Empty()) continue; - return std::move(tqueue->front()); + return std::move(tqueue->Front()); } return {}; @@ -130,15 +130,15 @@ namespace qtransport { * * @return TimeQueueElement from time queue */ - TimeQueueElement pop_front() + TimeQueueElement PopFront() { - std::lock_guard _(_mutex); + std::lock_guard _(mutex_); - for (auto& tqueue : _queue) { - if (!tqueue || tqueue->empty()) + for (auto& tqueue : queue_) { + if (!tqueue || tqueue->Empty()) continue; - return std::move(tqueue->pop_front()); + return std::move(tqueue->PopFront()); } return {}; @@ -147,41 +147,41 @@ namespace qtransport { /** * @brief Pop/remove the first object from queue */ - void pop() + void Pop() { - std::lock_guard _(_mutex); + std::lock_guard _(mutex_); - for (auto& tqueue : _queue) { - if (tqueue && !tqueue->empty()) - return tqueue->pop(); + for (auto& tqueue : queue_) { + if (tqueue && !tqueue->Empty()) + return tqueue->Pop(); } } /** * @brief Clear queue */ - void clear() + void Clear() { - std::lock_guard _(_mutex); + std::lock_guard _(mutex_); - for (auto& tqueue : _queue) { - if (tqueue && !tqueue->empty()) - tqueue->clear(); + for (auto& tqueue : queue_) { + if (tqueue && !tqueue->Empty()) + tqueue->Clear(); } } // TODO: Consider changing empty/size to look at timeQueue sizes - maybe support blocking pops - size_t size() const + size_t Size() const { - return std::accumulate(_queue.begin(), _queue.end(), 0, [](auto sum, auto& tqueue) { - return tqueue ? sum + tqueue->size() : sum; + return std::accumulate(queue_.begin(), queue_.end(), 0, [](auto sum, auto& tqueue) { + return tqueue ? sum + tqueue->Size() : sum; }); } - bool empty() const + bool Empty() const { - for (auto& tqueue : _queue) { - if (tqueue && !tqueue->empty()) { + for (auto& tqueue : queue_) { + if (tqueue && !tqueue->Empty()) { return false; } } @@ -197,25 +197,25 @@ namespace qtransport { * * @return Unique pointer to queue for the given priority */ - std::unique_ptr& get_queue_by_priority(const uint8_t priority) + std::unique_ptr& GetQueueByPriority(const uint8_t priority) { if (priority >= PMAX) { throw InvalidPriorityException("Priority not within range"); } - if (!_queue[priority]) { - _queue[priority] = std::make_unique(_duration_ms, _interval_ms, _tick_service, _initial_queue_size); + if (!queue_[priority]) { + queue_[priority] = std::make_unique(duration_ms_, interval_ms_, tick_service_, initial_queue_size_); } - return _queue[priority]; + return queue_[priority]; } - std::mutex _mutex; - size_t _initial_queue_size; - size_t _duration_ms; - size_t _interval_ms; + std::mutex mutex_; + size_t initial_queue_size_; + size_t duration_ms_; + size_t interval_ms_; - std::array, PMAX> _queue; - std::shared_ptr _tick_service; + std::array, PMAX> queue_; + std::shared_ptr tick_service_; }; -}; // end of namespace qtransport \ No newline at end of file +}; // end of namespace qtransport diff --git a/include/transport/safe_queue.h b/include/transport/safe_queue.h index 3adbb67..ac51c03 100644 --- a/include/transport/safe_queue.h +++ b/include/transport/safe_queue.h @@ -32,12 +32,12 @@ class SafeQueue * is unlimited. */ SafeQueue(uint32_t limit = 1000) - : _stop_waiting{ false } - , _limit{ limit } + : stop_waiting_{ false } + , limit_{ limit } { } - ~SafeQueue() { stop_waiting(); } + ~SafeQueue() { StopWaiting(); } /** * @brief inserts element at the end of queue @@ -51,23 +51,23 @@ class SafeQueue * @return True if successfully pushed, false if not. The cause for false is * that the queue is full. */ - bool push(T const& elem) + bool Push(T const& elem) { bool rval = true; - std::lock_guard _(_mutex); + std::lock_guard _(mutex_); - if (_queue.empty()) { - _cv.notify_one(); - _empty = false; + if (queue_.empty()) { + cv_.notify_one(); + empty_ = false; } - else if (_queue.size() >= _limit) { // Make room by removing first element - _queue.pop(); + else if (queue_.size() >= limit_) { // Make room by removing first element + queue_.pop(); rval = false; } - _queue.push(elem); + queue_.push(elem); return rval; } @@ -77,10 +77,10 @@ class SafeQueue * * @return std::nullopt if queue is empty, otherwise reference to object */ - std::optional pop() + std::optional Pop() { - std::lock_guard _(_mutex); - return pop_internal(); + std::lock_guard _(mutex_); + return PopInternal(); } /** @@ -88,26 +88,26 @@ class SafeQueue * * @return std::nullopt if queue is empty, otherwise reference to object */ - std::optional front() + std::optional Front() { - std::lock_guard _(_mutex); + std::lock_guard _(mutex_); - if (_queue.empty()) { + if (queue_.empty()) { return std::nullopt; } - return _queue.front(); + return queue_.front(); } /** * @brief Remove (aka pop) the first object from queue * */ - void pop_front() + void PopFront() { - std::lock_guard _(_mutex); + std::lock_guard _(mutex_); - pop_front_internal(); + PopFrontInternal(); } /** @@ -120,16 +120,16 @@ class SafeQueue * * @return std::nullopt if queue is empty, otherwise reference to object */ - std::optional block_pop() + std::optional BlockPop() { - std::unique_lock lock(_mutex); - _cv.wait(lock, [&]() { return (_stop_waiting || (_queue.size() > 0)); }); + std::unique_lock lock(mutex_); + cv_.wait(lock, [&]() { return (stop_waiting_ || (queue_.size() > 0)); }); - if (_stop_waiting) { + if (stop_waiting_) { return std::nullopt; } - return pop_internal(); + return PopInternal(); } /** @@ -137,19 +137,19 @@ class SafeQueue * * @return size of the queue */ - size_t size() + size_t Size() { - std::lock_guard _(_mutex); - return _queue.size(); + std::lock_guard _(mutex_); + return queue_.size(); } /** * @brief Clear the queue */ - void clear() { - std::lock_guard _(_mutex); + void Clear() { + std::lock_guard _(mutex_); std::queue empty; - std::swap(_queue, empty); + std::swap(queue_, empty); } /** @@ -157,24 +157,24 @@ class SafeQueue * * @returns True if empty, false if not */ - bool empty() const { return _empty; } + bool Empty() const { return empty_; } /** * @brief Put the queue in a state such that threads will not wait * * @return Nothing */ - void stop_waiting() + void StopWaiting() { - std::lock_guard _(_mutex); - _stop_waiting = true; - _cv.notify_all(); + std::lock_guard _(mutex_); + stop_waiting_ = true; + cv_.notify_all(); } - void set_limit(uint32_t limit) + void SetLimit(uint32_t limit) { - std::lock_guard _(_mutex); - _limit = limit; + std::lock_guard _(mutex_); + limit_ = limit; } private: @@ -186,18 +186,18 @@ class SafeQueue * * @details The mutex must be locked by the caller */ - std::optional pop_internal() + std::optional PopInternal() { - if (_queue.empty()) { - _empty = true; + if (queue_.empty()) { + empty_ = true; return std::nullopt; } - auto elem = _queue.front(); - _queue.pop(); + auto elem = queue_.front(); + queue_.pop(); - if (_queue.empty()) { - _empty = true; + if (queue_.empty()) { + empty_ = true; } return elem; @@ -208,26 +208,26 @@ class SafeQueue * * @details The mutex must be locked by the caller */ - void pop_front_internal() + void PopFrontInternal() { - if (_queue.empty()) { - _empty = true; + if (queue_.empty()) { + empty_ = true; return; } - _queue.pop(); + queue_.pop(); - if (_queue.empty()) { - _empty = true; + if (queue_.empty()) { + empty_ = true; } } - std::atomic _empty { true }; - bool _stop_waiting; // Instruct threads to stop waiting - uint32_t _limit; // Limit of number of messages in queue - std::condition_variable _cv; // Signaling for thread syncronization - std::mutex _mutex; // read/write lock - std::queue _queue; // Queue + std::atomic empty_ { true }; + bool stop_waiting_; // Instruct threads to stop waiting + uint32_t limit_; // Limit of number of messages in queue + std::condition_variable cv_; // Signaling for thread syncronization + std::mutex mutex_; // read/write lock + std::queue queue_; // Queue }; } /* namespace qtransport */ diff --git a/include/transport/span.h b/include/transport/span.h index e390638..482739d 100644 --- a/include/transport/span.h +++ b/include/transport/span.h @@ -1,3 +1,5 @@ +// NOLINTBEGIN(readability-identifier-naming) + #pragma once #if __cplusplus >= 202002L @@ -305,3 +307,5 @@ Span(const std::array& ) -> Span; template Span(R&&) -> Span()))&>())>>; #endif + +// NOLINTEND(readability-identifier-naming) diff --git a/include/transport/stream_buffer.h b/include/transport/stream_buffer.h index 3f6a89c..a1f83a0 100644 --- a/include/transport/stream_buffer.h +++ b/include/transport/stream_buffer.h @@ -13,7 +13,7 @@ namespace qtransport { template> class StreamBuffer { - using buffer_t = std::deque; + using BufferT = std::deque; public: StreamBuffer() = default; @@ -26,15 +26,15 @@ namespace qtransport { * @tparam D Data type for value */ template - void initAny() + void InitAny() { - _parsed_data.emplace(); + parsed_data_.emplace(); } template - void initAnyB() + void InitAnyB() { - _parsed_dataB.emplace(); + parsed_dataB_.emplace(); } /** @@ -43,10 +43,10 @@ namespace qtransport { * @param type user defined type value for the parsed data any object */ template - void initAny(uint64_t type) + void InitAny(uint64_t type) { - _parsed_data.emplace(); - _parsed_data_type = type; + parsed_data_.emplace(); + parsed_data_type_ = type; } /** @@ -58,64 +58,64 @@ namespace qtransport { * @tparam D Data type of value */ template - D& getAny() + D& GetAny() { - return std::any_cast(_parsed_data); + return std::any_cast(parsed_data_); } template - D& getAnyB() + D& GetAnyB() { - return std::any_cast(_parsed_dataB); + return std::any_cast(parsed_dataB_); } /** * @brief Get the user defined parsed type value * @return Parsed data type value that was set via initAny(). nullopt if not set */ - std::optional getAnyType() { return _parsed_data_type; } + std::optional GetAnyType() { return parsed_data_type_; } /** * @brief Set the user-defined parsed data type value * @param type User defined value for the data type */ - void setAnyType(uint64_t type) { _parsed_data_type = type; } + void SetAnyType(uint64_t type) { parsed_data_type_ = type; } - void resetAny() + void ResetAny() { - _parsed_data.reset(); - _parsed_dataB.reset(); - _parsed_data_type = std::nullopt; + parsed_data_.reset(); + parsed_dataB_.reset(); + parsed_data_type_ = std::nullopt; } - void resetAnyB() + void ResetAnyB() { - _parsed_dataB.reset(); + parsed_dataB_.reset(); } - bool anyHasValue() + bool AnyHasValue() { - return _parsed_data.has_value(); + return parsed_data_.has_value(); } - bool anyHasValueB() + bool AnyHasValueB() { - return _parsed_dataB.has_value(); + return parsed_dataB_.has_value(); } - bool empty() const noexcept { return _buffer.empty(); } + bool Empty() const noexcept { return buffer_.empty(); } - size_t size() noexcept { return _buffer.size(); } + size_t Size() noexcept { return buffer_.size(); } /** * @brief Get the first data byte in stream buffer * @returns data byt or nullopt if no data */ - std::optional front() noexcept + std::optional Front() noexcept { - if (_buffer.size()) { - std::lock_guard _(_rwLock); - return _buffer.front(); + if (buffer_.size()) { + std::lock_guard _(rwLock_); + return buffer_.front(); } return std::nullopt; @@ -128,38 +128,38 @@ namespace qtransport { * * @returns data vector of bytes or nullopt if no data */ - std::vector front(std::uint32_t length) noexcept + std::vector Front(std::uint32_t length) noexcept { - if (!_buffer.empty()) { - std::lock_guard _(_rwLock); + if (!buffer_.empty()) { + std::lock_guard _(rwLock_); std::vector result(length); - std::copy_n(_buffer.begin(), length, result.begin()); + std::copy_n(buffer_.begin(), length, result.begin()); return result; } return std::vector(); } - void pop() + void Pop() { - if (_buffer.size()) { - std::lock_guard _(_rwLock); - _buffer.pop_front(); + if (buffer_.size()) { + std::lock_guard _(rwLock_); + buffer_.pop_front(); } } - void pop(std::uint32_t length) + void Pop(std::uint32_t length) { - if (!length || _buffer.empty()) + if (!length || buffer_.empty()) return; - std::lock_guard _(_rwLock); + std::lock_guard _(rwLock_); - if (length >= _buffer.size()) { - _buffer.clear(); + if (length >= buffer_.size()) { + buffer_.clear(); } else { - _buffer.erase(_buffer.begin(), _buffer.begin() + length); + buffer_.erase(buffer_.begin(), buffer_.begin() + length); } } @@ -170,38 +170,38 @@ namespace qtransport { * * @return True if data length is available, false if not. */ - bool available(std::uint32_t length) const noexcept { return _buffer.size() >= length; } + bool Available(std::uint32_t length) const noexcept { return buffer_.size() >= length; } - void push(const T& value) + void Push(const T& value) { - std::lock_guard _(_rwLock); - _buffer.push_back(value); + std::lock_guard _(rwLock_); + buffer_.push_back(value); } - void push(T&& value) + void Push(T&& value) { - std::lock_guard _(_rwLock); - _buffer.push_back(std::move(value)); + std::lock_guard _(rwLock_); + buffer_.push_back(std::move(value)); } - void push(const Span& value) + void Push(const Span& value) { - std::lock_guard _(_rwLock); - _buffer.insert(_buffer.end(), value.begin(), value.end()); + std::lock_guard _(rwLock_); + buffer_.insert(buffer_.end(), value.begin(), value.end()); } - void push(std::initializer_list value) + void Push(std::initializer_list value) { - std::lock_guard _(_rwLock); - _buffer.insert(_buffer.end(), value.begin(), value.end()); + std::lock_guard _(rwLock_); + buffer_.insert(buffer_.end(), value.begin(), value.end()); } - void push_lv(const Span& value) + void PushLv(const Span& value) { - std::lock_guard _(_rwLock); - const auto len = to_uintV(static_cast(value.size())); - _buffer.insert(_buffer.end(), len.begin(), len.end()); - _buffer.insert(_buffer.end(), value.begin(), value.end()); + std::lock_guard _(rwLock_); + const auto len = ToUintV(static_cast(value.size())); + buffer_.insert(buffer_.end(), len.begin(), len.end()); + buffer_.insert(buffer_.end(), value.begin(), value.end()); } /** @@ -214,14 +214,14 @@ namespace qtransport { * * @return Returns uint64 decoded value or nullopt if not enough bytes are available */ - std::optional decode_uintV() + std::optional DecodeUintV() { - if (const auto uv_msb = front()) { - if (available(uintV_size(*uv_msb))) { + if (const auto uv_msb = Front()) { + if (Available(uintV_size(*uv_msb))) { uint64_t uv_len = uintV_size(*uv_msb); - auto val = to_uint64(front(uv_len)); + auto val = to_uint64(Front(uv_len)); - pop(uv_len); + Pop(uv_len); return val; } @@ -240,15 +240,15 @@ namespace qtransport { * @return Returns vector or nullopt if not enough bytes are available */ - std::optional> decode_bytes() + std::optional> DecodeBytes() { - if (const auto uv_msb = front()) { - if (available(uintV_size(*uv_msb))) { + if (const auto uv_msb = Front()) { + if (Available(uintV_size(*uv_msb))) { uint64_t uv_len = uintV_size(*uv_msb); - auto len = to_uint64(front(uv_len)); + auto len = to_uint64(Front(uv_len)); - if (_buffer.size() >= uv_len + len) { - pop(uv_len); + if (buffer_.size() >= uv_len + len) { + Pop(uv_len); auto v = front(len); pop(len); @@ -261,10 +261,10 @@ namespace qtransport { } private: - buffer_t _buffer; - std::mutex _rwLock; - std::any _parsed_data; /// Working buffer for parsed data - std::any _parsed_dataB; /// Second Working buffer for parsed data - std::optional _parsed_data_type; /// working buffer type value + BufferT buffer_; + std::mutex rwLock_; + std::any parsed_data_; /// Working buffer for parsed data + std::any parsed_dataB_; /// Second Working buffer for parsed data + std::optional parsed_data_type_; /// working buffer type value }; } diff --git a/include/transport/time_queue.h b/include/transport/time_queue.h index d3cf557..866937d 100644 --- a/include/transport/time_queue.h +++ b/include/transport/time_queue.h @@ -40,10 +40,10 @@ namespace qtransport { */ struct TickService { - using tick_type = size_t; - using duration_type = std::chrono::microseconds; + using TickType = size_t; + using DurationType = std::chrono::microseconds; - virtual tick_type get_ticks(const duration_type& interval) const = 0; + virtual TickType GetTicks(const DurationType& interval) const = 0; }; template @@ -63,64 +63,64 @@ namespace qtransport { */ class ThreadedTickService : public TickService { - using clock_type = std::chrono::steady_clock; + using ClockType = std::chrono::steady_clock; public: - ThreadedTickService() { _tick_thread = std::thread(&ThreadedTickService::tick_loop, this); } + ThreadedTickService() { tick_thread_ = std::thread(&ThreadedTickService::TickLoop, this); } ThreadedTickService(const ThreadedTickService& other) - : _ticks{ other._ticks } - , _stop{ other._stop.load() } + : ticks_{ other.ticks_ } + , stop_{ other.stop_.load() } { - _tick_thread = std::thread(&ThreadedTickService::tick_loop, this); + tick_thread_ = std::thread(&ThreadedTickService::TickLoop, this); } ~ThreadedTickService() { - _stop = true; - if (_tick_thread.joinable()) - _tick_thread.join(); + stop_ = true; + if (tick_thread_.joinable()) + tick_thread_.join(); } ThreadedTickService& operator=(const ThreadedTickService& other) { - _ticks = other._ticks; - _stop = other._stop.load(); - _tick_thread = std::thread(&ThreadedTickService::tick_loop, this); + ticks_ = other.ticks_; + stop_ = other.stop_.load(); + tick_thread_ = std::thread(&ThreadedTickService::TickLoop, this); return *this; } - tick_type get_ticks(const duration_type& interval) const override + TickType GetTicks(const DurationType& interval) const override { - const tick_type increment = std::max(interval, _interval) / _interval; - return _ticks / increment; + const TickType increment = std::max(interval, interval_) / interval_; + return ticks_ / increment; } private: - void tick_loop() + void TickLoop() { - const int interval_us = _interval.count(); + const int interval_us = interval_.count(); timeval sleep_time = {.tv_sec = 0, .tv_usec = interval_us}; - while (!_stop) { + while (!stop_) { select(0, NULL, NULL, NULL, &sleep_time); sleep_time.tv_usec = interval_us; - ++_ticks; + ++ticks_; } } private: /// The current ticks since the tick_service began. - uint64_t _ticks{ 0 }; + uint64_t ticks_{ 0 }; /// Flag to stop tick_service thread. - std::atomic _stop{ false }; + std::atomic stop_{ false }; /// The interval at which ticks should increase. - const duration_type _interval{ 500 }; + const DurationType interval_{ 500 }; /// The thread to update ticks on. - std::thread _tick_thread; + std::thread tick_thread_; }; /** @@ -154,27 +154,27 @@ namespace qtransport { // Internal type definitions /*=======================================================================*/ - using tick_type = TickService::tick_type; - using bucket_type = std::vector; - using index_type = std::uint32_t; + using TickType = TickService::TickType; + using BucketType = std::vector; + using IndexType = std::uint32_t; struct QueueValueType { - QueueValueType(bucket_type& bucket, index_type value_index, tick_type expiry_tick, tick_type wait_for_tick) - : _bucket{ bucket } - , _value_index{ value_index } - , _expiry_tick(expiry_tick) - , _wait_for_tick(wait_for_tick) + QueueValueType(BucketType& bucket, IndexType value_index, TickType expiry_tick, TickType wait_for_tick) + : bucket{ bucket } + , value_index{ value_index } + , expiry_tick(expiry_tick) + , wait_for_tick(wait_for_tick) { } - bucket_type& _bucket; - index_type _value_index; - tick_type _expiry_tick; - tick_type _wait_for_tick; + BucketType& bucket; + IndexType value_index; + TickType expiry_tick; + TickType wait_for_tick; }; - using queue_type = std::vector; + using QueueType = std::vector; public: /** @@ -188,10 +188,10 @@ namespace qtransport { * is null. */ TimeQueue(size_t duration, size_t interval, const std::shared_ptr& tick_service) - : _duration{ duration } - , _interval{ interval } - , _total_buckets{ _duration / _interval } - , _tick_service(tick_service) + : duration_{ duration } + , interval_{ interval } + , total_buckets_{ duration_ / interval_ } + , tick_service_(tick_service) { if (duration == 0 || duration % interval != 0 || duration == interval) { throw std::invalid_argument("Invalid time_queue constructor args"); @@ -201,8 +201,8 @@ namespace qtransport { throw std::invalid_argument("Tick service cannot be null"); } - _buckets.resize(_total_buckets); - _queue.reserve(_total_buckets); + buckets_.resize(total_buckets_); + queue_.reserve(total_buckets_); } /** @@ -223,7 +223,7 @@ namespace qtransport { size_t initial_queue_size) : TimeQueue(duration, interval, tick_service) { - _queue.reserve(initial_queue_size); + queue_.reserve(initial_queue_size); } TimeQueue() = delete; @@ -243,9 +243,9 @@ namespace qtransport { * * @throws std::invalid_argument If ttl is greater than duration. */ - void push(const T& value, size_t ttl, size_t delay_ttl=0) + void Push(const T& value, size_t ttl, size_t delay_ttl=0) { - internal_push(value, ttl, delay_ttl); + InternalPush(value, ttl, delay_ttl); } /** @@ -258,9 +258,9 @@ namespace qtransport { * * @throws std::invalid_argument If ttl is greater than duration. */ - void push(T&& value, size_t ttl, size_t delay_ttl=0) + void Push(T&& value, size_t ttl, size_t delay_ttl=0) { - internal_push(std::move(value), ttl, delay_ttl); + InternalPush(std::move(value), ttl, delay_ttl); } /** @@ -269,12 +269,12 @@ namespace qtransport { * @details This method should be called after front when the object is processed. This * will move the queue forward. If at the end of the queue, it'll be cleared and reset. */ - void pop() noexcept + void Pop() noexcept { - if (_queue.empty() || ++_queue_index < _queue.size()) + if (queue_.empty() || ++queue_index_ < queue_.size()) return; - clear(); + Clear(); } /** @@ -282,11 +282,11 @@ namespace qtransport { * * @returns TimeQueueElement of the popped value */ - [[nodiscard]] TimeQueueElement pop_front() + [[nodiscard]] TimeQueueElement PopFront() { - auto obj = std::move(front()); + auto obj = std::move(Front()); if (obj.has_value) { - pop(); + Pop(); } return std::move(obj); @@ -296,20 +296,20 @@ namespace qtransport { * @brief Returns the most valid front of the queue without popping. * @returns Element of the front value */ - [[nodiscard]] TimeQueueElement front() + [[nodiscard]] TimeQueueElement Front() { - const tick_type ticks = advance(); + const TickType ticks = Advance(); TimeQueueElement elem; - if (_queue.empty()) + if (queue_.empty()) return std::move(elem); - while (_queue_index < _queue.size()) { - auto& [bucket, value_index, expiry_tick, pop_wait_ttl] = _queue.at(_queue_index); + while (queue_index_ < queue_.size()) { + auto& [bucket, value_index, expiry_tick, pop_wait_ttl] = queue_.at(queue_index_); if (value_index >= bucket.size() || ticks > expiry_tick) { elem.expired_count++; - _queue_index++; + queue_index_++; continue; } @@ -322,23 +322,23 @@ namespace qtransport { return std::move(elem); } - clear(); + Clear(); return std::move(elem); } - size_t size() const noexcept { return _queue.size() - _queue_index; } - bool empty() const noexcept { return _queue.empty() || _queue_index >= _queue.size(); } + size_t Size() const noexcept { return queue_.size() - queue_index_; } + bool Empty() const noexcept { return queue_.empty() || queue_index_ >= queue_.size(); } /** * @brief Clear/reset the queue to no objects */ - void clear() noexcept + void Clear() noexcept { - _queue.clear(); - _queue_index = _bucket_index = 0; + queue_.clear(); + queue_index_ = bucket_index_ = 0; - for (auto& bucket : _buckets) { + for (auto& bucket : buckets_) { bucket.clear(); } } @@ -350,27 +350,27 @@ namespace qtransport { * * @returns Current tick value at time of advance */ - tick_type advance() + TickType Advance() { - const tick_type new_ticks = _tick_service->get_ticks(Duration_t(_interval)); - const tick_type delta = _current_ticks ? new_ticks - _current_ticks : 0; - _current_ticks = new_ticks; + const TickType new_ticks = tick_service_->GetTicks(Duration_t(interval_)); + const TickType delta = current_ticks_ ? new_ticks - current_ticks_ : 0; + current_ticks_ = new_ticks; if (delta == 0) - return _current_ticks; + return current_ticks_; - if (delta >= static_cast(_total_buckets)) { - clear(); - return _current_ticks; + if (delta >= static_cast(total_buckets_)) { + Clear(); + return current_ticks_; } for (int i = 0; i < delta; ++i) { - _buckets[(_bucket_index + i) % _total_buckets].clear(); + buckets_[(bucket_index_ + i) % total_buckets_].clear(); } - _bucket_index = (_bucket_index + delta) % _total_buckets; + bucket_index_ = (bucket_index_ + delta) % total_buckets_; - return _current_ticks; + return current_ticks_; } /** @@ -387,55 +387,55 @@ namespace qtransport { * @throws std::invalid_argument If ttl is greater than duration. */ template - inline void internal_push(Value value, size_t ttl, size_t delay_ttl) + inline void InternalPush(Value value, size_t ttl, size_t delay_ttl) { - if (ttl > _duration) { + if (ttl > duration_) { throw std::invalid_argument("TTL is greater than max duration"); } else if (ttl == 0) { - ttl = _duration; + ttl = duration_; } - ttl = ttl / _interval; + ttl = ttl / interval_; - const tick_type ticks = advance(); + const TickType ticks = Advance(); - const tick_type expiry_tick = ticks + ttl; + const TickType expiry_tick = ticks + ttl; - const index_type future_index = (_bucket_index + ttl - 1) % _total_buckets; + const IndexType future_index = (bucket_index_ + ttl - 1) % total_buckets_; - bucket_type& bucket = _buckets[future_index]; + BucketType& bucket = buckets_[future_index]; bucket.push_back(value); - _queue.emplace_back(bucket, bucket.size() - 1, expiry_tick, ticks + delay_ttl); + queue_.emplace_back(bucket, bucket.size() - 1, expiry_tick, ticks + delay_ttl); } private: /// The duration in ticks of the entire queue. - const size_t _duration; + const size_t duration_; /// The interval at which buckets are cleared in ticks. - const size_t _interval; + const size_t interval_; /// The total amount of buckets. Value is calculated by duration / interval. - const size_t _total_buckets; + const size_t total_buckets_; /// The index in time of the current bucket. - index_type _bucket_index{ 0 }; + IndexType bucket_index_{ 0 }; /// The index of the first valid item in the queue. - index_type _queue_index{ 0 }; + IndexType queue_index_{ 0 }; /// Last calculated tick value. - tick_type _current_ticks{ 0 }; + TickType current_ticks_{ 0 }; /// The memory storage for all elements to be managed. - std::vector _buckets; + std::vector buckets_; /// The FIFO ordered queue of values as they were inserted. - queue_type _queue; + QueueType queue_; /// Tick service for calculating new tick and jumps in time. - std::shared_ptr _tick_service; + std::shared_ptr tick_service_; }; }; // namespace qtransport diff --git a/include/transport/transport.h b/include/transport/transport.h index 1767217..d5088ee 100644 --- a/include/transport/transport.h +++ b/include/transport/transport.h @@ -25,11 +25,11 @@ using DataContextId = uint64_t; ///< Data Context 64bit number that ide */ enum class TransportStatus : uint8_t { - Ready = 0, - Connecting, - RemoteRequestClose, - Disconnected, - Shutdown + kReady = 0, + kConnecting, + kRemoteRequestClose, + kDisconnected, + kShutdown }; /** @@ -37,16 +37,16 @@ enum class TransportStatus : uint8_t */ enum class TransportError : uint8_t { - None = 0, - QueueFull, - UnknownError, - PeerDisconnected, - PeerUnreachable, - CannotResolveHostname, - InvalidConnContextId, - InvalidDataContextId, - InvalidIpv4Address, - InvalidIpv6Address + kNone = 0, + kQueueFull, + kUnknownError, + kPeerDisconnected, + kPeerUnreachable, + kCannotResolveHostname, + kInvalidConnContextId, + kInvalidDataContextId, + kInvalidIpv4Address, + kInvalidIpv6Address }; /** @@ -54,8 +54,8 @@ enum class TransportError : uint8_t */ enum class TransportProtocol: uint8_t { - UDP = 0, - QUIC + kUdp = 0, + kQuic }; /** @@ -85,8 +85,8 @@ struct TransportConfig uint64_t quic_cwin_minimum { 131072 }; /// QUIC congestion control minimum size (default is 128k) uint32_t quic_wifi_shadow_rtt_us { 20000 }; /// QUIC wifi shadow RTT in microseconds - uint64_t pacing_decrease_threshold_Bps { 16000 }; /// QUIC pacing rate decrease threshold for notification in Bps - uint64_t pacing_increase_threshold_Bps { 16000 }; /// QUIC pacing rate increase threshold for notification in Bps + uint64_t pacing_decrease_threshold_bps { 16000 }; /// QUIC pacing rate decrease threshold for notification in Bps + uint64_t pacing_increase_threshold_bps { 16000 }; /// QUIC pacing rate increase threshold for notification in Bps uint64_t idle_timeout_ms { 30000 }; /// Idle timeout for transport connection(s) in milliseconds bool use_reset_wait_strategy { false }; /// Use Reset and wait strategy for congestion control @@ -95,11 +95,11 @@ struct TransportConfig uint8_t quic_priority_limit { 0 }; /// Lowest priority that will not be bypassed from pacing/CC in picoquic }; -using time_stamp_us = std::chrono::time_point; +using TimeStampUs = std::chrono::time_point; struct MethodTraceItem { std::string method; /// Name of the method - time_stamp_us start_time; /// Original start time of the call + TimeStampUs start_time; /// Original start time of the call uint32_t delta; /// Delta is calculated based on start_time and now time of constructor MethodTraceItem() : @@ -108,7 +108,7 @@ struct MethodTraceItem { delta(0) { } - MethodTraceItem(const std::string& method, const time_stamp_us start_time) : + MethodTraceItem(const std::string& method, const TimeStampUs start_time) : method(method), start_time(start_time) { delta = (std::chrono::time_point_cast(std::chrono::steady_clock::now()) - @@ -161,7 +161,7 @@ class ITransport * @param[in] conn_id Transport context Id * @param[in] status Transport Status value */ - virtual void on_connection_status(const TransportConnId& conn_id, + virtual void OnConnectionStatus(const TransportConnId& conn_id, TransportStatus status) = 0; /** @@ -173,7 +173,7 @@ class ITransport * @param[in] conn_id Transport context identifier mapped to the connection * @param[in] remote Transport information for the connection */ - virtual void on_new_connection(const TransportConnId& conn_id, + virtual void OnNewConnection(const TransportConnId& conn_id, const TransportRemote& remote) = 0; /** @@ -186,7 +186,7 @@ class ITransport * @param[in] conn_id Transport context identifier mapped to the connection * @param[in] data_ctx_id Data context id for a new data context received by the transport */ - virtual void on_new_data_context(const TransportConnId& conn_id, + virtual void OnNewDataContext(const TransportConnId& conn_id, const DataContextId& data_ctx_id) = 0; /** @@ -195,7 +195,7 @@ class ITransport * @param[in] conn_id Transport context identifier mapped to the connection * @param[in] data_ctx_id If known, Data context id that the data was received on */ - virtual void on_recv_dgram(const TransportConnId& conn_id, + virtual void OnRecvDgram(const TransportConnId& conn_id, std::optional data_ctx_id) = 0; /** @@ -206,7 +206,7 @@ class ITransport * @param[in] data_ctx_id If known, Data context id that the data was received on * @param[in] is_bidir True if the message is from a bidirectional stream */ - virtual void on_recv_stream(const TransportConnId& conn_id, + virtual void OnRecvStream(const TransportConnId& conn_id, uint64_t stream_id, std::optional data_ctx_id, bool is_bidir=false) = 0; @@ -226,7 +226,7 @@ class ITransport * * @return shared_ptr for the under lining transport. */ - static std::shared_ptr make_client_transport( + static std::shared_ptr MakeClientTransport( const TransportRemote& server, const TransportConfig &tcfg, TransportDelegate& delegate, @@ -243,7 +243,7 @@ class ITransport * * @return shared_ptr for the under lining transport. */ - static std::shared_ptr make_server_transport( + static std::shared_ptr MakeServerTransport( const TransportRemote& server, const TransportConfig &tcfg, TransportDelegate& delegate, @@ -259,7 +259,7 @@ class ITransport * will reflect the status of the listening socket. In client mode it will * reflect the status of the server connection. */ - virtual TransportStatus status() const = 0; + virtual TransportStatus Status() const = 0; /** * @brief Setup the transport connection @@ -273,7 +273,7 @@ class ITransport * * @return TransportContextId: identifying the connection */ - virtual TransportConnId start(std::shared_ptr> metrics_conn_samples, + virtual TransportConnId Start(std::shared_ptr> metrics_conn_samples, std::shared_ptr> metrics_data_samples) = 0; /** @@ -289,7 +289,7 @@ class ITransport * * @return DataContextId identifying the data context via the connection */ - virtual DataContextId createDataContext(TransportConnId conn_id, + virtual DataContextId CreateDataContext(TransportConnId conn_id, bool use_reliable_transport, uint8_t priority = 1, bool bidir = false) = 0; @@ -300,7 +300,7 @@ class ITransport * @param conn_id Connection ID to close * @param app_reason_code Application reason code to use when closing QUIC connnection */ - virtual void close(const TransportConnId& conn_id, uint64_t app_reason_code=0) = 0; + virtual void Close(const TransportConnId& conn_id, uint64_t app_reason_code=0) = 0; /** * @brief Delete data context @@ -310,7 +310,7 @@ class ITransport * @param[in] conn_id Connection ID to create data context * @param[in] data_ctx_id Data context ID to delete */ - virtual void deleteDataContext(const TransportConnId& conn_id, DataContextId data_ctx_id) = 0; + virtual void DeleteDataContext(const TransportConnId& conn_id, DataContextId data_ctx_id) = 0; /** * @brief Get the peer IP address and port associated with the stream @@ -320,7 +320,7 @@ class ITransport * * @returns True if the address was successfully returned, false otherwise */ - virtual bool getPeerAddrInfo(const TransportConnId& context_id, + virtual bool GetPeerAddrInfo(const TransportConnId& context_id, sockaddr_storage* addr) = 0; /** @@ -330,7 +330,7 @@ class ITransport * @param data_ctx_id Local data context ID * @param stream_id RX stream ID */ - virtual void setStreamIdDataCtxId(TransportConnId conn_id, + virtual void SetStreamIdDataCtxId(TransportConnId conn_id, DataContextId data_ctx_id, uint64_t stream_id) = 0; @@ -341,7 +341,7 @@ class ITransport * @param data_ctx_id Local data context ID * @param priority Priority for data context stream, range should be 0 - 255 */ - virtual void setDataCtxPriority(TransportConnId conn_id, DataContextId data_ctx_id, uint8_t priority) = 0; + virtual void SetDataCtxPriority(TransportConnId conn_id, DataContextId data_ctx_id, uint8_t priority) = 0; /** * @brief Set the remote data context id @@ -351,7 +351,7 @@ class ITransport * @param data_ctx_id Local data context ID * @param remote_data_ctx_id Remote data context ID (learned via subscribe/publish) */ - virtual void setRemoteDataCtxId(TransportConnId conn_id, + virtual void SetRemoteDataCtxId(TransportConnId conn_id, DataContextId data_ctx_id, DataContextId remote_data_ctx_id) = 0; @@ -384,7 +384,7 @@ class ITransport * * @returns TransportError is returned indicating status of the operation */ - virtual TransportError enqueue(const TransportConnId& context_id, + virtual TransportError Enqueue(const TransportConnId& context_id, const DataContextId& data_ctx_id, std::vector&& bytes, std::vector &&trace = { MethodTraceItem{} }, @@ -404,7 +404,7 @@ class ITransport * * @returns std::nullopt if there is no data */ - virtual std::optional> dequeue(TransportConnId conn_id, + virtual std::optional> Dequeue(TransportConnId conn_id, std::optional data_ctx_id) = 0; @@ -414,7 +414,7 @@ class ITransport * @param[in] conn_id Identifying the connection * @param[in] stream_id Stream ID of stream buffer */ - virtual std::shared_ptr> getStreamBuffer(TransportConnId conn_id, uint64_t stream_id) = 0; + virtual std::shared_ptr> GetStreamBuffer(TransportConnId conn_id, uint64_t stream_id) = 0; /// Metrics samples to be written to TSDB. When full the buffer will remove the oldest std::shared_ptr> metrics_conn_samples; diff --git a/include/transport/transport_metrics.h b/include/transport/transport_metrics.h index 7a7d695..753bc1b 100644 --- a/include/transport/transport_metrics.h +++ b/include/transport/transport_metrics.h @@ -14,14 +14,14 @@ namespace qtransport { uint64_t max {0}; /// Maximum value in period uint64_t avg {0}; /// Average value in period - uint64_t _value_sum {0}; /// Accumulating sum of values in period - uint64_t _value_count {0}; /// Number of values in period + uint64_t value_sum {0}; /// Accumulating sum of values in period + uint64_t value_count {0}; /// Number of values in period #if __cplusplus >= 202002L constexpr auto operator<=>(const MinMaxAvg&) const = default; #else constexpr bool operator==(const MinMaxAvg& other) const { - return min == other.min && max == other.max && avg == other.avg && _value_sum == other._value_sum; + return min == other.min && max == other.max && avg == other.avg && value_sum == other.value_sum; } constexpr bool operator!=(const MinMaxAvg& other) const { return !(*this == other); } #endif @@ -33,25 +33,25 @@ namespace qtransport { * * @param value The value to add. */ - void addValue(const uint64_t value) { + void AddValue(const uint64_t value) { min = min ? std::min(min, value) : value; max = std::max(max, value); - _value_sum += value; - _value_count++; + value_sum += value; + value_count++; - if (!_value_count) _value_count = 1; + if (!value_count) value_count = 1; - avg = _value_sum / _value_count; + avg = value_sum / value_count; } - void clear() + void Clear() { min = 0; max = 0; avg = 0; - _value_sum = 0; - _value_count = 0; + value_sum = 0; + value_count = 0; } }; @@ -61,7 +61,7 @@ namespace qtransport { struct QuicConnectionMetrics { uint64_t cwin_congested{ 0 }; /// CC: Number of times CWIN is low or zero (congested) - uint64_t _prev_cwin_congested{ 0 }; /// Previous number of times CWIN is congested + uint64_t prev_cwin_congested{ 0 }; /// Previous number of times CWIN is congested uint64_t tx_congested {0}; /// count of times transmit connection is considered congested MinMaxAvg tx_rate_bps; /// Rate in bits per second in period @@ -90,7 +90,7 @@ namespace qtransport { #else constexpr bool operator==(const QuicConnectionMetrics& other) const { return this->cwin_congested == other.cwin_congested && - this->_prev_cwin_congested == other._prev_cwin_congested && + this->prev_cwin_congested == other.prev_cwin_congested && this->tx_congested == other.tx_congested && this->tx_rate_bps == other.tx_rate_bps && this->rx_rate_bps == other.rx_rate_bps && @@ -116,14 +116,14 @@ namespace qtransport { /** * @brief Reset metrics for period */ - void resetPeriod() + void ResetPeriod() { - tx_rate_bps.clear(); - rx_rate_bps.clear(); - tx_cwin_bytes.clear(); - tx_in_transit_bytes.clear(); - rtt_us.clear(); - srtt_us.clear(); + tx_rate_bps.Clear(); + rx_rate_bps.Clear(); + tx_cwin_bytes.Clear(); + tx_in_transit_bytes.Clear(); + rtt_us.Clear(); + srtt_us.Clear(); } }; @@ -139,7 +139,7 @@ namespace qtransport { uint64_t tx_queue_expired{ 0 }; /// count of objects expired before pop/front uint64_t tx_delayed_callback{ 0 }; /// Count of times transmit callbacks were delayed - uint64_t _prev_tx_delayed_callback{ 0 }; /// Previous transmit delayed callback value, set each interval + uint64_t prev_tx_delayed_callback{ 0 }; /// Previous transmit delayed callback value, set each interval uint64_t tx_reset_wait{ 0 }; /// count of times data context performed a reset and wait MinMaxAvg tx_queue_size; /// TX queue size in period MinMaxAvg tx_callback_ms; /// Callback time in milliseconds in period @@ -163,7 +163,7 @@ namespace qtransport { this->tx_queue_discards == other.tx_queue_discards && this->tx_queue_expired == other.tx_queue_expired && this->tx_delayed_callback == other.tx_delayed_callback && - this->_prev_tx_delayed_callback == other._prev_tx_delayed_callback && + this->prev_tx_delayed_callback == other.prev_tx_delayed_callback && this->tx_reset_wait == other.tx_reset_wait && this->tx_queue_size == other.tx_queue_size && this->tx_callback_ms == other.tx_callback_ms && @@ -180,11 +180,11 @@ namespace qtransport { /** * @brief Reset metrics for period */ - void resetPeriod() + void ResetPeriod() { - tx_queue_size.clear(); - tx_callback_ms.clear(); - tx_object_duration_us.clear(); + tx_queue_size.Clear(); + tx_callback_ms.Clear(); + tx_object_duration_us.Clear(); } }; @@ -225,11 +225,11 @@ namespace qtransport { }; - using time_stamp_us = std::chrono::time_point; + using TimeStampUs = std::chrono::time_point; struct MetricsConnSample { - time_stamp_us sample_time; /// Sample time + TimeStampUs sample_time; /// Sample time uint64_t conn_ctx_id {0}; /// Conn context ID std::optional udp_sample; std::optional quic_sample; @@ -242,7 +242,7 @@ namespace qtransport { , conn_ctx_id(conn_id) , udp_sample(udp_sample) {} - MetricsConnSample(const time_stamp_us sample_time, const uint64_t conn_id, const UdpConnectionMetrics udp_sample) + MetricsConnSample(const TimeStampUs sample_time, const uint64_t conn_id, const UdpConnectionMetrics udp_sample) : sample_time(sample_time) , conn_ctx_id(conn_id) , udp_sample(udp_sample) {} @@ -252,7 +252,7 @@ namespace qtransport { , conn_ctx_id(conn_id) , quic_sample(quic_sample) {} - MetricsConnSample(const time_stamp_us sample_time, const uint64_t conn_id, const QuicConnectionMetrics quic_sample) + MetricsConnSample(const TimeStampUs sample_time, const uint64_t conn_id, const QuicConnectionMetrics quic_sample) : sample_time(sample_time) , conn_ctx_id(conn_id) , quic_sample(quic_sample) {} @@ -260,7 +260,7 @@ namespace qtransport { struct MetricsDataSample { - time_stamp_us sample_time; /// Sample time + TimeStampUs sample_time; /// Sample time uint64_t conn_ctx_id {0}; /// Conn context ID uint64_t data_ctx_id {0}; /// Data context ID std::optional udp_sample; @@ -275,7 +275,7 @@ namespace qtransport { , data_ctx_id(data_id) , udp_sample(udp_sample) {} - MetricsDataSample(const time_stamp_us sample_time, const uint64_t conn_id, const uint64_t data_id, + MetricsDataSample(const TimeStampUs sample_time, const uint64_t conn_id, const uint64_t data_id, const UdpDataContextMetrics udp_sample) : sample_time(sample_time) , conn_ctx_id(conn_id) @@ -288,7 +288,7 @@ namespace qtransport { , data_ctx_id(data_id) , quic_sample(quic_sample) {} - MetricsDataSample(const time_stamp_us sample_time, const uint64_t conn_id, const uint64_t data_id, + MetricsDataSample(const TimeStampUs sample_time, const uint64_t conn_id, const uint64_t data_id, const QuicDataContextMetrics quic_sample) : sample_time(sample_time) , conn_ctx_id(conn_id) @@ -297,7 +297,7 @@ namespace qtransport { }; - constexpr uint64_t METRICS_INTERVAL_US = 5'000'000; /// Metrics interval for samples in microseconds - constexpr size_t MAX_METRICS_SAMPLES_QUEUE = 500; /// Max metric samples pending to be written + constexpr uint64_t kMetricsIntervalUs = 5'000'000; /// Metrics interval for samples in microseconds + constexpr size_t kMaxMetricsSamplesQueue = 500; /// Max metric samples pending to be written } // end namespace qtransport \ No newline at end of file diff --git a/include/transport/uintvar.h b/include/transport/uintvar.h index 6b8b456..3db7bdd 100644 --- a/include/transport/uintvar.h +++ b/include/transport/uintvar.h @@ -4,7 +4,7 @@ namespace qtransport { - using uintV_t = std::vector; + using UintVT = std::vector; /** * @brief Get the byte size from variable length-integer @@ -13,13 +13,13 @@ namespace qtransport { * * @returns the size in bytes of the variable length integer */ - inline uint8_t uintV_size(const uint8_t uintV_msbbyte) + inline uint8_t UintVSize(const uint8_t uint_v_msbbyte) { - if ((uintV_msbbyte & 0xC0) == 0xC0) { + if ((uint_v_msbbyte & 0xC0) == 0xC0) { return 8; - } else if ((uintV_msbbyte & 0x80) == 0x80) { + } else if ((uint_v_msbbyte & 0x80) == 0x80) { return 4; - } else if ((uintV_msbbyte & 0x40) == 0x40) { + } else if ((uint_v_msbbyte & 0x40) == 0x40) { return 2; } else { return 1; @@ -36,11 +36,11 @@ namespace qtransport { * * @returns vector of encoded bytes or empty vector if value is invalid */ - inline uintV_t to_uintV(uint64_t value) + inline UintVT ToUintV(uint64_t value) { - static constexpr uint64_t len_1 = (static_cast(-1) << (64 - 6) >> (64 - 6)); - static constexpr uint64_t len_2 = (static_cast(-1) << (64 - 14) >> (64 - 14)); - static constexpr uint64_t len_4 = (static_cast(-1) << (64 - 30) >> (64 - 30)); + static constexpr uint64_t kLen1 = (static_cast(-1) << (64 - 6) >> (64 - 6)); + static constexpr uint64_t kLen2 = (static_cast(-1) << (64 - 14) >> (64 - 14)); + static constexpr uint64_t kLen4 = (static_cast(-1) << (64 - 30) >> (64 - 30)); uint8_t net_bytes[8]{ 0 }; // Network order bytes uint8_t len{ 0 }; // Length of bytes encoded @@ -50,31 +50,31 @@ namespace qtransport { #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ constexpr std::array host_order{ 0, 1, 2, 3, 4, 5, 6, 7 }; #else - constexpr std::array host_order{ 7, 6, 5, 4, 3, 2, 1, 0 }; + constexpr std::array kHostOrder{ 7, 6, 5, 4, 3, 2, 1, 0 }; #endif - if (byte_value[host_order[0]] & 0xC0) { // Check if invalid + if (byte_value[kHostOrder[0]] & 0xC0) { // Check if invalid return {}; } - if (value > len_4) { // 62 bit encoding (8 bytes) + if (value > kLen4) { // 62 bit encoding (8 bytes) for (int i = 0; i < 8; i++) { - net_bytes[i] = byte_value[host_order[i]]; + net_bytes[i] = byte_value[kHostOrder[i]]; } net_bytes[0] |= 0xC0; len = 8; - } else if (value > len_2) { // 30 bit encoding (4 bytes) + } else if (value > kLen2) { // 30 bit encoding (4 bytes) for (int i = 0; i < 4; i++) { - net_bytes[i] = byte_value[host_order[i + 4]]; + net_bytes[i] = byte_value[kHostOrder[i + 4]]; } net_bytes[0] |= 0x80; len = 4; - } else if (value > len_1) { // 14 bit encoding (2 bytes) - net_bytes[0] = byte_value[host_order[6]] | 0x40; - net_bytes[1] = byte_value[host_order[7]]; + } else if (value > kLen1) { // 14 bit encoding (2 bytes) + net_bytes[0] = byte_value[kHostOrder[6]] | 0x40; + net_bytes[1] = byte_value[kHostOrder[7]]; len = 2; } else { - net_bytes[0] = byte_value[host_order[7]]; + net_bytes[0] = byte_value[kHostOrder[7]]; len = 1; } @@ -89,27 +89,27 @@ namespace qtransport { * * @returns uint64_t value of the variable length integer */ - inline uint64_t to_uint64(const uintV_t& uintV) + inline uint64_t ToUint64(const UintVT& uint_v) { - if (uintV.empty()) { + if (uint_v.empty()) { return 0; } #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ constexpr std::array host_order{ 0, 1, 2, 3, 4, 5, 6, 7 }; #else - constexpr std::array host_order{ 7, 6, 5, 4, 3, 2, 1, 0 }; + constexpr std::array kHostOrder{ 7, 6, 5, 4, 3, 2, 1, 0 }; #endif uint64_t value{ 0 }; uint8_t* byte_value = reinterpret_cast(&value); - const auto offset = 8 - uintV.size(); + const auto offset = 8 - uint_v.size(); - for (size_t i = 0; i < uintV.size(); i++) { - byte_value[host_order[i + offset]] = uintV[i]; + for (size_t i = 0; i < uint_v.size(); i++) { + byte_value[kHostOrder[i + offset]] = uint_v[i]; } - byte_value[host_order[offset]] = uintV[0] & 0x3f; // Zero MSB length bits + byte_value[kHostOrder[offset]] = uint_v[0] & 0x3f; // Zero MSB length bits return value; } diff --git a/src/transport.cpp b/src/transport.cpp index 81990dd..434dfcf 100644 --- a/src/transport.cpp +++ b/src/transport.cpp @@ -11,16 +11,16 @@ namespace qtransport { std::shared_ptr -ITransport::make_client_transport(const TransportRemote& server, +ITransport::MakeClientTransport(const TransportRemote& server, const TransportConfig& tcfg, TransportDelegate& delegate, std::shared_ptr logger) { switch (server.proto) { - case TransportProtocol::UDP: + case TransportProtocol::kUdp: return std::make_shared(server, tcfg, delegate, false, std::move(logger)); #ifndef PLATFORM_ESP - case TransportProtocol::QUIC: + case TransportProtocol::kQuic: return std::make_shared(server, tcfg, delegate, @@ -36,17 +36,17 @@ ITransport::make_client_transport(const TransportRemote& server, } std::shared_ptr -ITransport::make_server_transport(const TransportRemote& server, +ITransport::MakeServerTransport(const TransportRemote& server, const TransportConfig& tcfg, TransportDelegate& delegate, std::shared_ptr logger) { switch (server.proto) { - case TransportProtocol::UDP: + case TransportProtocol::kUdp: return std::make_shared(server, tcfg, delegate, true, std::move(logger)); #ifndef PLATFORM_ESP - case TransportProtocol::QUIC: + case TransportProtocol::kQuic: return std::make_shared(server, tcfg, delegate, diff --git a/src/transport_picoquic.cpp b/src/transport_picoquic.cpp index b84877e..1251bbd 100644 --- a/src/transport_picoquic.cpp +++ b/src/transport_picoquic.cpp @@ -65,7 +65,7 @@ namespace { * * @return The correctly adjusted stream id value. */ - constexpr uint64_t get_next_stream_id(uint64_t last_stream_id, bool is_server, bool is_unidirectional) + constexpr uint64_t GetNextStreamId(uint64_t last_stream_id, bool is_server, bool is_unidirectional) { return ((last_stream_id + 4) & (~0x0u << 2)) | (is_server ? 0b01 : 0b00) | (is_unidirectional ? 0b10 : 0b00); } @@ -79,7 +79,7 @@ namespace { * * @return The datagram stream id. */ - constexpr DataContextId make_datagram_stream_id(bool is_server, bool is_unidirectional) + constexpr DataContextId MakeDatagramStreamId(bool is_server, bool is_unidirectional) { return 0; } @@ -90,7 +90,7 @@ namespace { * ============================================================================ */ -int pq_event_cb(picoquic_cnx_t* pq_cnx, +int PqEventCb(picoquic_cnx_t* pq_cnx, uint64_t stream_id, uint8_t* bytes, size_t length, @@ -112,12 +112,12 @@ int pq_event_cb(picoquic_cnx_t* pq_cnx, case picoquic_callback_prepare_datagram: { // length is the max allowed data length - if (auto conn_ctx = transport->getConnContext(conn_id)) { + if (auto conn_ctx = transport->GetConnContext(conn_id)) { conn_ctx->metrics.tx_dgram_cb++; - transport->send_next_datagram(conn_ctx, bytes, length); + transport->SendNextDatagram(conn_ctx, bytes, length); - if (picoquic_get_cwin(pq_cnx) < PQ_CC_LOW_CWIN) { // Congested if less than 8K or near jumbo MTU size + if (picoquic_get_cwin(pq_cnx) < kPqCcLowCwin) { // Congested if less than 8K or near jumbo MTU size conn_ctx->metrics.cwin_congested++; } } @@ -127,34 +127,34 @@ int pq_event_cb(picoquic_cnx_t* pq_cnx, case picoquic_callback_datagram_acked: // bytes carries the original packet data - if (auto conn_ctx = transport->getConnContext(conn_id)) { + if (auto conn_ctx = transport->GetConnContext(conn_id)) { conn_ctx->metrics.tx_dgram_ack++; } break; case picoquic_callback_datagram_spurious: - if (auto conn_ctx = transport->getConnContext(conn_id)) { + if (auto conn_ctx = transport->GetConnContext(conn_id)) { conn_ctx->metrics.tx_dgram_spurious++; } break; case picoquic_callback_datagram_lost: - if (auto conn_ctx = transport->getConnContext(conn_id)) { + if (auto conn_ctx = transport->GetConnContext(conn_id)) { conn_ctx->metrics.tx_dgram_lost++; } break; case picoquic_callback_datagram: { - if (auto conn_ctx = transport->getConnContext(conn_id)) { - transport->on_recv_datagram(conn_ctx, bytes, length); + if (auto conn_ctx = transport->GetConnContext(conn_id)) { + transport->OnRecvDatagram(conn_ctx, bytes, length); } break; } case picoquic_callback_prepare_to_send: { - if (picoquic_get_cwin(pq_cnx) < PQ_CC_LOW_CWIN) { + if (picoquic_get_cwin(pq_cnx) < kPqCcLowCwin) { // Congested if less than 8K or near jumbo MTU size - if (auto conn_ctx = transport->getConnContext(conn_id)) { + if (auto conn_ctx = transport->GetConnContext(conn_id)) { conn_ctx->metrics.cwin_congested++; } else { break; @@ -168,7 +168,7 @@ int pq_event_cb(picoquic_cnx_t* pq_cnx, } data_ctx->metrics.tx_stream_cb++; - transport->send_stream_bytes(data_ctx, bytes, length); + transport->SendStreamBytes(data_ctx, bytes, length); break; } @@ -186,11 +186,11 @@ int pq_event_cb(picoquic_cnx_t* pq_cnx, if (!((stream_id & 0x2) == 2) /* not unidir stream */) { // Create bidir stream if it wasn't initiated by this instance (remote initiated it) - if ( ( (stream_id & 0x1) == 1 && !transport->_is_server_mode) - || ( (stream_id & 0x0) == 0 && transport->_is_server_mode)) { + if ( ( (stream_id & 0x1) == 1 && !transport->is_server_mode) + || ( (stream_id & 0x0) == 0 && transport->is_server_mode)) { // Create the data context for new bidir streams created by remote side - data_ctx = transport->createDataContextBiDirRecv(conn_id, stream_id); + data_ctx = transport->CreateDataContextBiDirRecv(conn_id, stream_id); picoquic_set_app_stream_ctx(pq_cnx, stream_id, data_ctx); } else { @@ -200,14 +200,14 @@ int pq_event_cb(picoquic_cnx_t* pq_cnx, } } - if (auto conn_ctx = transport->getConnContext(conn_id)) { - transport->on_recv_stream_bytes(conn_ctx, data_ctx, stream_id, bytes, length); + if (auto conn_ctx = transport->GetConnContext(conn_id)) { + transport->OnRecvStreamBytes(conn_ctx, data_ctx, stream_id, bytes, length); if (is_fin) { LOGGER_INFO(transport->logger, "Received FIN for stream {0}",stream_id); picoquic_reset_stream_ctx(pq_cnx, stream_id); - if (auto conn_ctx = transport->getConnContext(conn_id)) { + if (auto conn_ctx = transport->GetConnContext(conn_id)) { const auto rx_buf_it = conn_ctx->rx_stream_buffer.find(stream_id); if (rx_buf_it != conn_ctx->rx_stream_buffer.end()) { rx_buf_it->second.closed = true; @@ -230,7 +230,7 @@ int pq_event_cb(picoquic_cnx_t* pq_cnx, picoquic_reset_stream_ctx(pq_cnx, stream_id); - if (auto conn_ctx = transport->getConnContext(conn_id)) { + if (auto conn_ctx = transport->GetConnContext(conn_id)) { const auto rx_buf_it = conn_ctx->rx_stream_buffer.find(stream_id); if (rx_buf_it != conn_ctx->rx_stream_buffer.end()) { rx_buf_it->second.closed = true; @@ -307,15 +307,15 @@ int pq_event_cb(picoquic_cnx_t* pq_cnx, picoquic_set_callback(pq_cnx, NULL, NULL); - if (auto conn_ctx = transport->getConnContext(conn_id)) { + if (auto conn_ctx = transport->GetConnContext(conn_id)) { log_msg << " remote: " << conn_ctx->peer_addr_text; } LOGGER_INFO(transport->logger, log_msg.str()); - transport->close(conn_id); + transport->Close(conn_id); - if (not transport->_is_server_mode) { + if (not transport->is_server_mode) { // TODO: Fix picoquic. Apparently picoquic is not processing return values for this callback return PICOQUIC_NO_ERROR_TERMINATE_PACKET_LOOP; } @@ -324,14 +324,14 @@ int pq_event_cb(picoquic_cnx_t* pq_cnx, } case picoquic_callback_ready: { // Connection callback, not per stream - if (transport->_is_server_mode) { - transport->createConnContext(pq_cnx); - transport->on_new_connection(conn_id); + if (transport->is_server_mode) { + transport->CreateConnContext(pq_cnx); + transport->OnNewConnection(conn_id); } else { // Client - transport->setStatus(TransportStatus::Ready); - transport->on_connection_status(conn_id, TransportStatus::Ready); + transport->SetStatus(TransportStatus::kReady); + transport->OnConnectionStatus(conn_id, TransportStatus::kReady); } (void)picoquic_mark_datagram_ready(pq_cnx, 1); @@ -347,7 +347,7 @@ int pq_event_cb(picoquic_cnx_t* pq_cnx, return 0; } -int pq_loop_cb(picoquic_quic_t* quic, picoquic_packet_loop_cb_enum cb_mode, void* callback_ctx, void* callback_arg) +int PqLoopCb(picoquic_quic_t* quic, picoquic_packet_loop_cb_enum cb_mode, void* callback_ctx, void* callback_arg) { PicoQuicTransport* transport = static_cast(callback_ctx); int ret = 0; @@ -356,18 +356,18 @@ int pq_loop_cb(picoquic_quic_t* quic, picoquic_packet_loop_cb_enum cb_mode, void std::cerr << "picoquic transport was called with NULL transport" << '\n'; return PICOQUIC_ERROR_UNEXPECTED_ERROR; - } else if (transport->status() == TransportStatus::Disconnected) { + } else if (transport->Status() == TransportStatus::kDisconnected) { return PICOQUIC_NO_ERROR_TERMINATE_PACKET_LOOP; } else { - transport->pq_runner(); + transport->PqRunner(); switch (cb_mode) { case picoquic_packet_loop_ready: { LOGGER_INFO(transport->logger, "packet_loop_ready, waiting for packets"); - if (transport->_is_server_mode) - transport->setStatus(TransportStatus::Ready); + if (transport->is_server_mode) + transport->SetStatus(TransportStatus::kReady); if (callback_arg != nullptr) { auto* options = static_cast(callback_arg); @@ -394,8 +394,8 @@ int pq_loop_cb(picoquic_quic_t* quic, picoquic_packet_loop_cb_enum cb_mode, void case picoquic_packet_loop_time_check: { packet_loop_time_check_arg_t* targ = static_cast(callback_arg); - if (targ->delta_t > PQ_LOOP_MAX_DELAY_US) { - targ->delta_t = PQ_LOOP_MAX_DELAY_US; + if (targ->delta_t > kPqLoopMaxDelayUs) { + targ->delta_t = kPqLoopMaxDelayUs; } if (!transport->pq_loop_prev_time) { @@ -403,12 +403,12 @@ int pq_loop_cb(picoquic_quic_t* quic, picoquic_packet_loop_cb_enum cb_mode, void } - if (targ->current_time - transport->pq_loop_metrics_prev_time >= METRICS_INTERVAL_US) { + if (targ->current_time - transport->pq_loop_metrics_prev_time >= kMetricsIntervalUs) { // Use this time to clean up streams that have been closed - transport->remove_closed_streams(); + transport->RemoveClosedStreams(); if (transport->pq_loop_metrics_prev_time) { - transport->emit_metrics(); + transport->EmitMetrics(); } transport->pq_loop_metrics_prev_time = targ->current_time; @@ -416,13 +416,13 @@ int pq_loop_cb(picoquic_quic_t* quic, picoquic_packet_loop_cb_enum cb_mode, void if (targ->current_time - transport->pq_loop_prev_time > 100'000) { - transport->check_conns_for_congestion(); + transport->CheckConnsForCongestion(); transport->pq_loop_prev_time = targ->current_time; } // Stop loop if shutting down - if (transport->status() == TransportStatus::Shutdown) { + if (transport->Status() == TransportStatus::kShutdown) { LOGGER_INFO(transport->logger, "picoquic is shutting down"); picoquic_cnx_t* close_cnx = picoquic_get_first_cnx(quic); @@ -458,13 +458,13 @@ int pq_loop_cb(picoquic_quic_t* quic, picoquic_packet_loop_cb_enum cb_mode, void * ============================================================================ */ -TransportStatus PicoQuicTransport::status() const +TransportStatus PicoQuicTransport::Status() const { - return _transportStatus; + return transportStatus_; } TransportConnId -PicoQuicTransport::start(std::shared_ptr> metrics_conn_samples, +PicoQuicTransport::Start(std::shared_ptr> metrics_conn_samples, std::shared_ptr> metrics_data_samples) { this->metrics_conn_samples = std::move(metrics_conn_samples); @@ -476,25 +476,25 @@ PicoQuicTransport::start(std::shared_ptr> metrics_c debug_set_callback(&PicoQuicTransport::PicoQuicLogging, this); } - if (_tconfig.use_reset_wait_strategy) { + if (tconfig_.use_reset_wait_strategy) { LOGGER_INFO(logger, "Using Reset and Wait congestion control strategy"); } - if (_tconfig.use_bbr) { - (void)picoquic_config_set_option(&_config, picoquic_option_CC_ALGO, "bbr"); + if (tconfig_.use_bbr) { + (void)picoquic_config_set_option(&config_, picoquic_option_CC_ALGO, "bbr"); } else { LOGGER_INFO(logger, "Using NewReno congestion control"); - (void)picoquic_config_set_option(&_config, picoquic_option_CC_ALGO, "reno"); + (void)picoquic_config_set_option(&config_, picoquic_option_CC_ALGO, "reno"); } - (void)picoquic_config_set_option(&_config, picoquic_option_ALPN, QUICR_ALPN); - (void)picoquic_config_set_option(&_config, picoquic_option_CWIN_MIN, - std::to_string(_tconfig.quic_cwin_minimum).c_str()); - (void)picoquic_config_set_option(&_config, picoquic_option_MAX_CONNECTIONS, "100"); + (void)picoquic_config_set_option(&config_, picoquic_option_ALPN, quicr_alpn); + (void)picoquic_config_set_option(&config_, picoquic_option_CWIN_MIN, + std::to_string(tconfig_.quic_cwin_minimum).c_str()); + (void)picoquic_config_set_option(&config_, picoquic_option_MAX_CONNECTIONS, "100"); - _quic_ctx = picoquic_create_and_configure(&_config, pq_event_cb, this, current_time, NULL); + quic_ctx_ = picoquic_create_and_configure(&config_, PqEventCb, this, current_time, NULL); - if (_quic_ctx == NULL) { + if (quic_ctx_ == NULL) { LOGGER_CRITICAL(logger, "Unable to create picoquic context, check certificate and key filenames"); throw PicoQuicException("Unable to create picoquic context"); } @@ -504,63 +504,63 @@ PicoQuicTransport::start(std::shared_ptr> metrics_c * max datagram size is zero, preventing sending of datagrams. Setting this * also triggers PMTUD to run. This value will be the initial value. */ - picoquic_init_transport_parameters(&_local_tp_options, 1); - _local_tp_options.max_datagram_frame_size = 1280; + picoquic_init_transport_parameters(&local_tp_options_, 1); + local_tp_options_.max_datagram_frame_size = 1280; // local_tp_options.max_packet_size = 1450; - _local_tp_options.max_idle_timeout = _tconfig.idle_timeout_ms; - _local_tp_options.max_ack_delay = 100000; - _local_tp_options.min_ack_delay = 1000; + local_tp_options_.max_idle_timeout = tconfig_.idle_timeout_ms; + local_tp_options_.max_ack_delay = 100000; + local_tp_options_.min_ack_delay = 1000; - picoquic_set_default_handshake_timeout(_quic_ctx, (_tconfig.idle_timeout_ms * 1000) / 2); - picoquic_set_default_tp(_quic_ctx, &_local_tp_options); - picoquic_set_default_idle_timeout(_quic_ctx, _tconfig.idle_timeout_ms); - picoquic_set_default_priority(_quic_ctx, 2); - picoquic_set_default_datagram_priority(_quic_ctx, 1); + picoquic_set_default_handshake_timeout(quic_ctx_, (tconfig_.idle_timeout_ms * 1000) / 2); + picoquic_set_default_tp(quic_ctx_, &local_tp_options_); + picoquic_set_default_idle_timeout(quic_ctx_, tconfig_.idle_timeout_ms); + picoquic_set_default_priority(quic_ctx_, 2); + picoquic_set_default_datagram_priority(quic_ctx_, 1); - LOGGER_INFO(logger, "Setting idle timeout to {0}ms", _tconfig.idle_timeout_ms); + LOGGER_INFO(logger, "Setting idle timeout to {0}ms", tconfig_.idle_timeout_ms); //picoquic_set_default_wifi_shadow_rtt(quic_ctx, tconfig.quic_wifi_shadow_rtt_us); //logger->info << "Setting wifi shadow RTT to " << tconfig.quic_wifi_shadow_rtt_us << "us" << std::flush; - _picoquic_runner_queue.set_limit(2000); + picoquic_runner_queue_.SetLimit(2000); - _cbNotifyQueue.set_limit(2000); - _cbNotifyThread = std::thread(&PicoQuicTransport::cbNotifier, this); + cbNotifyQueue_.SetLimit(2000); + cbNotifyThread_ = std::thread(&PicoQuicTransport::CbNotifier, this); TransportConnId cid = 0; std::ostringstream log_msg; - if (_is_server_mode) { + if (is_server_mode) { - LOGGER_INFO(logger, "Starting server, listening on {0}:{1}", _serverInfo.host_or_ip, _serverInfo.port); + LOGGER_INFO(logger, "Starting server, listening on {0}:{1}", serverInfo_.host_or_ip, serverInfo_.port); - _picoQuicThread = std::thread(&PicoQuicTransport::server, this); + picoQuicThread_ = std::thread(&PicoQuicTransport::Server, this); } else { - LOGGER_INFO(logger, "Connecting to server {0}:{1}", _serverInfo.host_or_ip, _serverInfo.port); + LOGGER_INFO(logger, "Connecting to server {0}:{1}", serverInfo_.host_or_ip, serverInfo_.port); - if ((cid = createClient())) { - _picoQuicThread = std::thread(&PicoQuicTransport::client, this, cid); + if ((cid = CreateClient())) { + picoQuicThread_ = std::thread(&PicoQuicTransport::Client, this, cid); } } - if (!_tconfig.quic_qlog_path.empty()) { - LOGGER_INFO(logger, "Enabling qlog using '{0}' path", _tconfig.quic_qlog_path); - picoquic_set_qlog(_quic_ctx, _tconfig.quic_qlog_path.c_str()); + if (!tconfig_.quic_qlog_path.empty()) { + LOGGER_INFO(logger, "Enabling qlog using '{0}' path", tconfig_.quic_qlog_path); + picoquic_set_qlog(quic_ctx_, tconfig_.quic_qlog_path.c_str()); } return cid; } -bool PicoQuicTransport::getPeerAddrInfo(const TransportConnId& conn_id, +bool PicoQuicTransport::GetPeerAddrInfo(const TransportConnId& conn_id, sockaddr_storage* addr) { - std::lock_guard _(_state_mutex); + std::lock_guard _(state_mutex_); // Locate the specified transport connection context - auto it = _conn_context.find(conn_id); + auto it = conn_context_.find(conn_id); // If not found, return false - if (it == _conn_context.end()) return false; + if (it == conn_context_.end()) return false; // Copy the address std::memcpy(addr, &it->second.peer_addr, sizeof(sockaddr_storage)); @@ -569,7 +569,7 @@ bool PicoQuicTransport::getPeerAddrInfo(const TransportConnId& conn_id, } TransportError -PicoQuicTransport::enqueue(const TransportConnId& conn_id, +PicoQuicTransport::Enqueue(const TransportConnId& conn_id, const DataContextId& data_ctx_id, std::vector&& bytes, std::vector &&trace, @@ -580,23 +580,23 @@ PicoQuicTransport::enqueue(const TransportConnId& conn_id, { if (bytes.empty()) { LOGGER_ERROR(logger, "enqueue dropped due bytes empty, conn_id: {0} data_ctx_id: {1}", conn_id, data_ctx_id); - return TransportError::None; + return TransportError::kNone; } trace.push_back({"transport_quic:enqueue", trace.front().start_time}); - std::lock_guard _(_state_mutex); + std::lock_guard _(state_mutex_); trace.push_back({"transport_quic:enqueue:afterLock", trace.front().start_time}); - const auto conn_ctx_it = _conn_context.find(conn_id); - if (conn_ctx_it == _conn_context.end()) { - return TransportError::InvalidConnContextId; + const auto conn_ctx_it = conn_context_.find(conn_id); + if (conn_ctx_it == conn_context_.end()) { + return TransportError::kInvalidConnContextId; } const auto data_ctx_it = conn_ctx_it->second.active_data_contexts.find(data_ctx_id); if (data_ctx_it == conn_ctx_it->second.active_data_contexts.end()) { - return TransportError::InvalidDataContextId; + return TransportError::kInvalidDataContextId; } data_ctx_it->second.metrics.enqueued_objs++; @@ -610,49 +610,49 @@ PicoQuicTransport::enqueue(const TransportConnId& conn_id, if (flags.use_reliable) { if (flags.new_stream) { if (flags.use_reset) { - data_ctx_it->second.stream_action = DataContext::StreamAction::REPLACE_STREAM_USE_RESET; + data_ctx_it->second.stream_action = DataContext::StreamAction::kReplaceStreamUseReset; } else { - data_ctx_it->second.stream_action = DataContext::StreamAction::REPLACE_STREAM_USE_FIN; + data_ctx_it->second.stream_action = DataContext::StreamAction::kReplaceStreamUseFin; } } if (flags.clear_tx_queue) { - data_ctx_it->second.metrics.tx_queue_discards += data_ctx_it->second.tx_data->size(); - data_ctx_it->second.tx_data->clear(); + data_ctx_it->second.metrics.tx_queue_discards += data_ctx_it->second.tx_data->Size(); + data_ctx_it->second.tx_data->Clear(); } - data_ctx_it->second.tx_data->push(std::move(cd), ttl_ms, priority, 0); + data_ctx_it->second.tx_data->Push(std::move(cd), ttl_ms, priority, 0); if (! data_ctx_it->second.mark_stream_active) { data_ctx_it->second.mark_stream_active = true; - _picoquic_runner_queue.push([this, conn_id, data_ctx_id]() { - mark_stream_active(conn_id, data_ctx_id); + picoquic_runner_queue_.Push([this, conn_id, data_ctx_id]() { + MarkStreamActive(conn_id, data_ctx_id); }); } } else { // datagram - conn_ctx_it->second.dgram_tx_data->push(std::move(cd), ttl_ms, priority, 0); + conn_ctx_it->second.dgram_tx_data->Push(std::move(cd), ttl_ms, priority, 0); if (!conn_ctx_it->second.mark_dgram_ready ) { conn_ctx_it->second.mark_dgram_ready = true; - _picoquic_runner_queue.push([this, conn_id]() { - mark_dgram_ready(conn_id); + picoquic_runner_queue_.Push([this, conn_id]() { + MarkDgramReady(conn_id); }); } } - return TransportError::None; + return TransportError::kNone; } std::shared_ptr> -PicoQuicTransport::getStreamBuffer(TransportConnId conn_id, uint64_t stream_id) +PicoQuicTransport::GetStreamBuffer(TransportConnId conn_id, uint64_t stream_id) { - std::lock_guard _(_state_mutex); + std::lock_guard _(state_mutex_); - const auto conn_ctx_it = _conn_context.find(conn_id); - if (conn_ctx_it == _conn_context.end()) { + const auto conn_ctx_it = conn_context_.find(conn_id); + if (conn_ctx_it == conn_context_.end()) { return nullptr; } @@ -664,25 +664,25 @@ PicoQuicTransport::getStreamBuffer(TransportConnId conn_id, uint64_t stream_id) } std::optional> -PicoQuicTransport::dequeue(TransportConnId conn_id, +PicoQuicTransport::Dequeue(TransportConnId conn_id, [[maybe_unused]] std::optional data_ctx_id) { - std::lock_guard _(_state_mutex); + std::lock_guard _(state_mutex_); - const auto conn_ctx_it = _conn_context.find(conn_id); - if (conn_ctx_it == _conn_context.end()) { + const auto conn_ctx_it = conn_context_.find(conn_id); + if (conn_ctx_it == conn_context_.end()) { return std::nullopt; } - return conn_ctx_it->second.dgram_rx_data.pop(); + return conn_ctx_it->second.dgram_rx_data.Pop(); } DataContextId -PicoQuicTransport::createDataContext(const TransportConnId conn_id, +PicoQuicTransport::CreateDataContext(const TransportConnId conn_id, bool use_reliable_transport, uint8_t priority, bool bidir) { - std::lock_guard _(_state_mutex); + std::lock_guard _(state_mutex_); if (priority > 127) { /* @@ -692,8 +692,8 @@ PicoQuicTransport::createDataContext(const TransportConnId conn_id, throw std::runtime_error("Create stream priority cannot be greater than 127, range is 0 - 127"); } - const auto conn_it = _conn_context.find(conn_id); - if (conn_it == _conn_context.end()) { + const auto conn_it = conn_context_.find(conn_id); + if (conn_it == conn_context_.end()) { LOGGER_ERROR(logger, "Invalid conn_id: {0}, cannot create data context", conn_id); return 0; } @@ -709,14 +709,14 @@ PicoQuicTransport::createDataContext(const TransportConnId conn_id, data_ctx_it->second.priority = priority; - data_ctx_it->second.tx_data = std::make_unique>(_tconfig.time_queue_max_duration, - _tconfig.time_queue_bucket_interval, - _tick_service, - _tconfig.time_queue_init_queue_size); + data_ctx_it->second.tx_data = std::make_unique>(tconfig_.time_queue_max_duration, + tconfig_.time_queue_bucket_interval, + tick_service_, + tconfig_.time_queue_init_queue_size); // Create stream if (use_reliable_transport) { - create_stream(conn_it->second, &data_ctx_it->second); + CreateStream(conn_it->second, &data_ctx_it->second); } } @@ -724,13 +724,13 @@ PicoQuicTransport::createDataContext(const TransportConnId conn_id, } void -PicoQuicTransport::close(const TransportConnId& conn_id, uint64_t app_reason_code) +PicoQuicTransport::Close(const TransportConnId& conn_id, uint64_t app_reason_code) { - std::lock_guard _(_state_mutex); + std::lock_guard _(state_mutex_); - const auto conn_it = _conn_context.find(conn_id); + const auto conn_it = conn_context_.find(conn_id); - if (conn_it == _conn_context.end()) + if (conn_it == conn_context_.end()) return; // Remove pointer references in picoquic for active streams @@ -744,30 +744,30 @@ PicoQuicTransport::close(const TransportConnId& conn_id, uint64_t app_reason_cod } // Only one datagram context is per connection, if it's deleted, then the connection is to be terminated - on_connection_status(conn_id, TransportStatus::Disconnected); + OnConnectionStatus(conn_id, TransportStatus::kDisconnected); picoquic_close(conn_it->second.pq_cnx, app_reason_code); - if (not _is_server_mode) { - setStatus(TransportStatus::Shutdown); + if (not is_server_mode) { + SetStatus(TransportStatus::kShutdown); } - _conn_context.erase(conn_it); + conn_context_.erase(conn_it); } -void PicoQuicTransport::setRemoteDataCtxId([[maybe_unused]] const TransportConnId conn_id, +void PicoQuicTransport::SetRemoteDataCtxId([[maybe_unused]] const TransportConnId conn_id, [[maybe_unused]] const DataContextId data_ctx_id, [[maybe_unused]] const DataContextId remote_data_ctx_id) { return; } -void PicoQuicTransport::setDataCtxPriority(const TransportConnId conn_id, DataContextId data_ctx_id, uint8_t priority) +void PicoQuicTransport::SetDataCtxPriority(const TransportConnId conn_id, DataContextId data_ctx_id, uint8_t priority) { - std::lock_guard _(_state_mutex); + std::lock_guard _(state_mutex_); - const auto conn_it = _conn_context.find(conn_id); + const auto conn_it = conn_context_.find(conn_id); - if (conn_it == _conn_context.end()) + if (conn_it == conn_context_.end()) return; const auto data_ctx_it = conn_it->second.active_data_contexts.find(data_ctx_id); @@ -779,14 +779,14 @@ void PicoQuicTransport::setDataCtxPriority(const TransportConnId conn_id, DataCo data_ctx_it->second.priority = priority; } -void PicoQuicTransport::setStreamIdDataCtxId(const TransportConnId conn_id, +void PicoQuicTransport::SetStreamIdDataCtxId(const TransportConnId conn_id, DataContextId data_ctx_id, uint64_t stream_id) { - std::lock_guard _(_state_mutex); + std::lock_guard _(state_mutex_); - const auto conn_it = _conn_context.find(conn_id); + const auto conn_it = conn_context_.find(conn_id); - if (conn_it == _conn_context.end()) + if (conn_it == conn_context_.end()) return; const auto data_ctx_it = conn_it->second.active_data_contexts.find(data_ctx_id); @@ -797,7 +797,7 @@ void PicoQuicTransport::setStreamIdDataCtxId(const TransportConnId conn_id, data_ctx_it->second.current_stream_id = stream_id; - _picoquic_runner_queue.push([=]() { + picoquic_runner_queue_.Push([=]() { if (conn_it->second.pq_cnx != nullptr) picoquic_set_app_stream_ctx(conn_it->second.pq_cnx, stream_id, &data_ctx_it->second); }); @@ -808,22 +808,22 @@ void PicoQuicTransport::setStreamIdDataCtxId(const TransportConnId conn_id, * ============================================================================ */ -PicoQuicTransport::ConnectionContext* PicoQuicTransport::getConnContext(const TransportConnId& conn_id) +PicoQuicTransport::ConnectionContext* PicoQuicTransport::GetConnContext(const TransportConnId& conn_id) { // Locate the specified transport connection context - auto it = _conn_context.find(conn_id); + auto it = conn_context_.find(conn_id); // If not found, return empty context - if (it == _conn_context.end()) return nullptr; + if (it == conn_context_.end()) return nullptr; return &it->second; } -PicoQuicTransport::ConnectionContext& PicoQuicTransport::createConnContext(picoquic_cnx_t * pq_cnx) +PicoQuicTransport::ConnectionContext& PicoQuicTransport::CreateConnContext(picoquic_cnx_t * pq_cnx) { - auto [conn_it, is_new] = _conn_context.emplace(reinterpret_cast(pq_cnx), pq_cnx); + auto [conn_it, is_new] = conn_context_.emplace(reinterpret_cast(pq_cnx), pq_cnx); sockaddr* addr; @@ -858,11 +858,11 @@ PicoQuicTransport::ConnectionContext& PicoQuicTransport::createConnContext(picoq if (is_new) { LOGGER_INFO(logger, "Created new connection context for conn_id: {0}", conn_ctx.conn_id); - conn_ctx.dgram_rx_data.set_limit(_tconfig.time_queue_rx_size); - conn_ctx.dgram_tx_data = std::make_unique>(_tconfig.time_queue_max_duration, - _tconfig.time_queue_bucket_interval, - _tick_service, - _tconfig.time_queue_init_queue_size); + conn_ctx.dgram_rx_data.SetLimit(tconfig_.time_queue_rx_size); + conn_ctx.dgram_tx_data = std::make_unique>(tconfig_.time_queue_max_duration, + tconfig_.time_queue_bucket_interval, + tick_service_, + tconfig_.time_queue_init_queue_size); } return conn_ctx; @@ -871,52 +871,52 @@ PicoQuicTransport::ConnectionContext& PicoQuicTransport::createConnContext(picoq PicoQuicTransport::PicoQuicTransport(const TransportRemote& server, const TransportConfig& tcfg, TransportDelegate& delegate, - bool _is_server_mode, + bool is_server_mode, std::shared_ptr logger) : logger(std::move(logger)) - , _is_server_mode(_is_server_mode) - , _stop(false) - , _transportStatus(TransportStatus::Connecting) - , _serverInfo(server) - , _delegate(delegate) - , _tconfig(tcfg) + , is_server_mode(is_server_mode) + , stop_(false) + , transportStatus_(TransportStatus::kConnecting) + , serverInfo_(server) + , delegate_(delegate) + , tconfig_(tcfg) { debug = tcfg.debug; - picoquic_config_init(&_config); + picoquic_config_init(&config_); - if (_is_server_mode && tcfg.tls_cert_filename.empty()) { + if (is_server_mode && tcfg.tls_cert_filename.empty()) { throw InvalidConfigException("Missing cert filename"); } else if (!tcfg.tls_cert_filename.empty()) { - (void)picoquic_config_set_option(&_config, picoquic_option_CERT, tcfg.tls_cert_filename.c_str()); + (void)picoquic_config_set_option(&config_, picoquic_option_CERT, tcfg.tls_cert_filename.c_str()); if (!tcfg.tls_key_filename.empty()) { - (void)picoquic_config_set_option(&_config, picoquic_option_KEY, tcfg.tls_key_filename.c_str()); + (void)picoquic_config_set_option(&config_, picoquic_option_KEY, tcfg.tls_key_filename.c_str()); } else { throw InvalidConfigException("Missing cert key filename"); } } - _tick_service = std::make_shared(); + tick_service_ = std::make_shared(); } PicoQuicTransport::~PicoQuicTransport() { - setStatus(TransportStatus::Shutdown); - shutdown(); + SetStatus(TransportStatus::kShutdown); + Shutdown(); } void -PicoQuicTransport::setStatus(TransportStatus status) +PicoQuicTransport::SetStatus(TransportStatus status) { - _transportStatus = status; + transportStatus_ = status; } -PicoQuicTransport::DataContext* PicoQuicTransport::createDataContextBiDirRecv(TransportConnId conn_id, uint64_t stream_id) +PicoQuicTransport::DataContext* PicoQuicTransport::CreateDataContextBiDirRecv(TransportConnId conn_id, uint64_t stream_id) { - std::lock_guard _(_state_mutex); + std::lock_guard _(state_mutex_); - const auto conn_it = _conn_context.find(conn_id); - if (conn_it == _conn_context.end()) { + const auto conn_it = conn_context_.find(conn_id); + if (conn_it == conn_context_.end()) { LOGGER_ERROR(logger, "Invalid conn_id: {0}, cannot create data context", conn_id); return nullptr; } @@ -932,19 +932,19 @@ PicoQuicTransport::DataContext* PicoQuicTransport::createDataContextBiDirRecv(Tr data_ctx_it->second.priority = 10; // TODO: Need to get priority from remote - data_ctx_it->second.tx_data = std::make_unique>(_tconfig.time_queue_max_duration, - _tconfig.time_queue_bucket_interval, - _tick_service, - _tconfig.time_queue_init_queue_size); + data_ctx_it->second.tx_data = std::make_unique>(tconfig_.time_queue_max_duration, + tconfig_.time_queue_bucket_interval, + tick_service_, + tconfig_.time_queue_init_queue_size); data_ctx_it->second.current_stream_id = stream_id; #if __cplusplus >= 202002L _cbNotifyQueue.push([=, data_ctx_id = data_ctx_it->second.data_ctx_id, this]() { #else - _cbNotifyQueue.push([=, data_ctx_id = data_ctx_it->second.data_ctx_id]() { + cbNotifyQueue_.Push([=, data_ctx_id = data_ctx_it->second.data_ctx_id]() { #endif - _delegate.on_new_data_context(conn_id, data_ctx_id); }); + delegate_.OnNewDataContext(conn_id, data_ctx_id); }); LOGGER_INFO(logger, "Created new bidir data context conn_id: {0} data_ctx_id: {1} stream_id: {2}", conn_id, data_ctx_it->second.data_ctx_id, stream_id); @@ -954,23 +954,23 @@ PicoQuicTransport::DataContext* PicoQuicTransport::createDataContextBiDirRecv(Tr return nullptr; } -void PicoQuicTransport::pq_runner() { +void PicoQuicTransport::PqRunner() { - if (_picoquic_runner_queue.empty()) { + if (picoquic_runner_queue_.Empty()) { return; } // note: check before running move of optional, which is more CPU taxing when empty - while (auto cb = _picoquic_runner_queue.pop()) { + while (auto cb = picoquic_runner_queue_.Pop()) { (*cb)(); } } -void PicoQuicTransport::delete_data_context_internal(TransportConnId conn_id, DataContextId data_ctx_id) +void PicoQuicTransport::DeleteDataContextInternal(TransportConnId conn_id, DataContextId data_ctx_id) { - const auto conn_it = _conn_context.find(conn_id); + const auto conn_it = conn_context_.find(conn_id); - if (conn_it == _conn_context.end()) + if (conn_it == conn_context_.end()) return; LOGGER_INFO(logger, "Delete data context {0} in conn_id: {1}", data_ctx_id, conn_id); @@ -979,12 +979,12 @@ void PicoQuicTransport::delete_data_context_internal(TransportConnId conn_id, Da if (data_ctx_it == conn_it->second.active_data_contexts.end()) return; - close_stream(conn_it->second, &data_ctx_it->second, false); + CloseStream(conn_it->second, &data_ctx_it->second, false); conn_it->second.active_data_contexts.erase(data_ctx_it); } -void PicoQuicTransport::deleteDataContext(const TransportConnId& conn_id, DataContextId data_ctx_id) +void PicoQuicTransport::DeleteDataContext(const TransportConnId& conn_id, DataContextId data_ctx_id) { if (data_ctx_id == 0) { return; // use close() instead of deleting default/datagram context @@ -994,20 +994,20 @@ void PicoQuicTransport::deleteDataContext(const TransportConnId& conn_id, DataCo * Race conditions exist with picoquic thread callbacks that will cause a problem if the context (pointer context) * is deleted outside of the picoquic thread. Below schedules the delete to be done within the picoquic thread. */ - _picoquic_runner_queue.push([this, conn_id, data_ctx_id]() { - delete_data_context_internal(conn_id, data_ctx_id); + picoquic_runner_queue_.Push([this, conn_id, data_ctx_id]() { + DeleteDataContextInternal(conn_id, data_ctx_id); }); } void -PicoQuicTransport::send_next_datagram(ConnectionContext* conn_ctx, uint8_t* bytes_ctx, size_t max_len) +PicoQuicTransport::SendNextDatagram(ConnectionContext* conn_ctx, uint8_t* bytes_ctx, size_t max_len) { if (bytes_ctx == nullptr) { return; } - auto out_data = conn_ctx->dgram_tx_data->front(); + auto out_data = conn_ctx->dgram_tx_data->Front(); if (out_data.has_value) { const auto data_ctx_it = conn_ctx->active_data_contexts.find(out_data.value.data_ctx_id); if (data_ctx_it == conn_ctx->active_data_contexts.end()) { @@ -1016,11 +1016,11 @@ PicoQuicTransport::send_next_datagram(ConnectionContext* conn_ctx, uint8_t* byte return; } - check_callback_delta(&data_ctx_it->second); + CheckCallbackDelta(&data_ctx_it->second); if (out_data.value.data.size() == 0) { LOGGER_ERROR(logger, "conn_id: {0} data_ctx_id: {1} priority: {2} has ZERO data size", data_ctx_it->second.conn_id, data_ctx_it->second.data_ctx_id, static_cast(data_ctx_it->second.priority)); - data_ctx_it->second.tx_data->pop(); + data_ctx_it->second.tx_data->Pop(); return; } @@ -1028,11 +1028,11 @@ PicoQuicTransport::send_next_datagram(ConnectionContext* conn_ctx, uint8_t* byte data_ctx_it->second.metrics.tx_queue_expired += out_data.expired_count; if (out_data.value.data.size() <= max_len) { - conn_ctx->dgram_tx_data->pop(); + conn_ctx->dgram_tx_data->Pop(); out_data.value.trace.push_back({"transport_quic:send_dgram", out_data.value.trace.front().start_time}); - data_ctx_it->second.metrics.tx_object_duration_us.addValue(out_data.value.trace.back().delta); + data_ctx_it->second.metrics.tx_object_duration_us.AddValue(out_data.value.trace.back().delta); if (out_data.value.trace.back().delta > 60000) { std::ostringstream log_msg; @@ -1054,15 +1054,15 @@ PicoQuicTransport::send_next_datagram(ConnectionContext* conn_ctx, uint8_t* byte buf = picoquic_provide_datagram_buffer_ex(bytes_ctx, out_data.value.data.size(), - conn_ctx->dgram_tx_data->empty() ? picoquic_datagram_not_active : picoquic_datagram_active_any_path); + conn_ctx->dgram_tx_data->Empty() ? picoquic_datagram_not_active : picoquic_datagram_active_any_path); if (buf != nullptr) { std::memcpy(buf, out_data.value.data.data(), out_data.value.data.size()); } } else { - _picoquic_runner_queue.push([this, conn_id = conn_ctx->conn_id]() { - mark_dgram_ready(conn_id); + picoquic_runner_queue_.Push([this, conn_id = conn_ctx->conn_id]() { + MarkDgramReady(conn_id); }); /* TODO(tievens): picoquic_prepare_stream_and_datagrams() appears to ignore the @@ -1077,7 +1077,7 @@ PicoQuicTransport::send_next_datagram(ConnectionContext* conn_ctx, uint8_t* byte } void -PicoQuicTransport::send_stream_bytes(DataContext* data_ctx, uint8_t* bytes_ctx, size_t max_len) +PicoQuicTransport::SendStreamBytes(DataContext* data_ctx, uint8_t* bytes_ctx, size_t max_len) { if (bytes_ctx == NULL) { return; @@ -1087,26 +1087,26 @@ PicoQuicTransport::send_stream_bytes(DataContext* data_ctx, uint8_t* bytes_ctx, size_t offset = 0; int is_still_active = 0; - check_callback_delta(data_ctx); + CheckCallbackDelta(data_ctx); switch (data_ctx->stream_action) { - case DataContext::StreamAction::NO_ACTION: + case DataContext::StreamAction::kNoAction: [[fallthrough]]; default: if (!data_ctx->current_stream_id.has_value()) { LOGGER_INFO(logger, "Creating unset stream in conn_id: {0}", data_ctx->conn_id); - const auto conn_ctx = getConnContext(data_ctx->conn_id); - create_stream(*conn_ctx, data_ctx); + const auto conn_ctx = GetConnContext(data_ctx->conn_id); + CreateStream(*conn_ctx, data_ctx); return; } break; - case DataContext::StreamAction::REPLACE_STREAM_USE_RESET: { + case DataContext::StreamAction::kReplaceStreamUseReset: { data_ctx->uses_reset_wait = true; - std::lock_guard _(_state_mutex); - const auto conn_ctx = getConnContext(data_ctx->conn_id); + std::lock_guard _(state_mutex_); + const auto conn_ctx = GetConnContext(data_ctx->conn_id); // Keep stream in discard mode if still congested if (conn_ctx->is_congested && data_ctx->tx_reset_wait_discard) { @@ -1117,7 +1117,7 @@ PicoQuicTransport::send_stream_bytes(DataContext* data_ctx, uint8_t* bytes_ctx, data_ctx->metrics.tx_buffer_drops++; } - close_stream(*conn_ctx, data_ctx, true); + CloseStream(*conn_ctx, data_ctx, true); LOGGER_DEBUG(logger, "Replacing stream using RESET; conn_id: {0} data_ctx_id: {1} existing_stream: {2} " @@ -1128,8 +1128,8 @@ PicoQuicTransport::send_stream_bytes(DataContext* data_ctx, uint8_t* bytes_ctx, data_ctx->metrics.tx_buffer_drops, data_ctx->metrics.tx_queue_discards); - create_stream(*conn_ctx, data_ctx); - data_ctx->stream_action = DataContext::StreamAction::NO_ACTION; + CreateStream(*conn_ctx, data_ctx); + data_ctx->stream_action = DataContext::StreamAction::kNoAction; if (!conn_ctx->is_congested) { // Only clear reset wait if not congested data_ctx->tx_reset_wait_discard = false; // Allow new object to be sent @@ -1139,7 +1139,7 @@ PicoQuicTransport::send_stream_bytes(DataContext* data_ctx, uint8_t* bytes_ctx, return; // New stream requires PQ to callback again using that stream } - case DataContext::StreamAction::REPLACE_STREAM_USE_FIN: { + case DataContext::StreamAction::kReplaceStreamUseFin: { data_ctx->uses_reset_wait = true; if (data_ctx->stream_tx_object != nullptr) { @@ -1148,13 +1148,13 @@ PicoQuicTransport::send_stream_bytes(DataContext* data_ctx, uint8_t* bytes_ctx, LOGGER_INFO(logger, "Replacing stream using FIN; conn_id: {0} existing_stream: {1}", data_ctx->conn_id, *data_ctx->current_stream_id); - std::lock_guard _(_state_mutex); + std::lock_guard _(state_mutex_); - const auto conn_ctx = getConnContext(data_ctx->conn_id); - close_stream(*conn_ctx, data_ctx, false); - create_stream(*conn_ctx, data_ctx); + const auto conn_ctx = GetConnContext(data_ctx->conn_id); + CloseStream(*conn_ctx, data_ctx, false); + CreateStream(*conn_ctx, data_ctx); - data_ctx->stream_action = DataContext::StreamAction::NO_ACTION; + data_ctx->stream_action = DataContext::StreamAction::kNoAction; data_ctx->mark_stream_active = false; return; // New stream requires PQ to callback again using that stream @@ -1162,12 +1162,12 @@ PicoQuicTransport::send_stream_bytes(DataContext* data_ctx, uint8_t* bytes_ctx, } if (data_ctx->tx_reset_wait_discard) { // Drop TX objects till next reset/new stream - auto obj = data_ctx->tx_data->pop_front(); + auto obj = data_ctx->tx_data->PopFront(); if (obj.has_value) { data_ctx->metrics.tx_queue_discards++; - _picoquic_runner_queue.push([this, conn_id = data_ctx->conn_id, data_ctx_id = data_ctx->data_ctx_id]() { - mark_stream_active(conn_id, data_ctx_id); + picoquic_runner_queue_.Push([this, conn_id = data_ctx->conn_id, data_ctx_id = data_ctx->data_ctx_id]() { + MarkStreamActive(conn_id, data_ctx_id); }); } @@ -1176,7 +1176,7 @@ PicoQuicTransport::send_stream_bytes(DataContext* data_ctx, uint8_t* bytes_ctx, } if (data_ctx->stream_tx_object == nullptr) { - auto obj = data_ctx->tx_data->pop_front(); + auto obj = data_ctx->tx_data->PopFront(); data_ctx->metrics.tx_queue_expired += obj.expired_count; if (obj.has_value) { @@ -1188,7 +1188,7 @@ PicoQuicTransport::send_stream_bytes(DataContext* data_ctx, uint8_t* bytes_ctx, data_ctx->metrics.tx_stream_objects++; obj.value.trace.push_back({"transport_quic:send_stream", obj.value.trace.front().start_time}); - data_ctx->metrics.tx_object_duration_us.addValue(obj.value.trace.back().delta); + data_ctx->metrics.tx_object_duration_us.AddValue(obj.value.trace.back().delta); data_ctx->stream_tx_object = new uint8_t[obj.value.data.size()]; data_ctx->stream_tx_object_size = obj.value.data.size(); @@ -1230,7 +1230,7 @@ PicoQuicTransport::send_stream_bytes(DataContext* data_ctx, uint8_t* bytes_ctx, data_ctx->metrics.tx_stream_bytes += data_len; - if (!is_still_active && !data_ctx->tx_data->empty()) + if (!is_still_active && !data_ctx->tx_data->Empty()) is_still_active = 1; uint8_t *buf = nullptr; @@ -1251,29 +1251,29 @@ PicoQuicTransport::send_stream_bytes(DataContext* data_ctx, uint8_t* bytes_ctx, if (data_ctx->stream_tx_object_offset == 0 && data_ctx->stream_tx_object != nullptr) { // Zero offset at this point means the object was fully sent - data_ctx->reset_tx_object(); + data_ctx->ResetTxObject(); } } void -PicoQuicTransport::on_connection_status(const TransportConnId conn_id, const TransportStatus status) +PicoQuicTransport::OnConnectionStatus(const TransportConnId conn_id, const TransportStatus status) { - if (status == TransportStatus::Ready) { - auto conn_ctx = getConnContext(conn_id); + if (status == TransportStatus::kReady) { + auto conn_ctx = GetConnContext(conn_id); LOGGER_INFO(logger, "Connection established to server {0}", conn_ctx->peer_addr_text); } #if __cplusplus >= 202002L _cbNotifyQueue.push([=, this]() { _delegate.on_connection_status(conn_id, status); }); #else - _cbNotifyQueue.push([=]() { _delegate.on_connection_status(conn_id, status); }); + cbNotifyQueue_.Push([=]() { delegate_.OnConnectionStatus(conn_id, status); }); #endif } void -PicoQuicTransport::on_new_connection(const TransportConnId conn_id) +PicoQuicTransport::OnNewConnection(const TransportConnId conn_id) { - auto conn_ctx = getConnContext(conn_id); + auto conn_ctx = GetConnContext(conn_id); if (!conn_ctx) return; LOGGER_INFO(logger, "New Connection {0} port: {1} conn_id: {2}", conn_ctx->peer_addr_text, conn_ctx->peer_port, conn_id); @@ -1283,25 +1283,25 @@ PicoQuicTransport::on_new_connection(const TransportConnId conn_id) TransportRemote remote{ .host_or_ip = conn_ctx->peer_addr_text, .port = conn_ctx->peer_port, - .proto = TransportProtocol::QUIC }; + .proto = TransportProtocol::kQuic }; - picoquic_enable_keep_alive(conn_ctx->pq_cnx, _tconfig.idle_timeout_ms * 500); + picoquic_enable_keep_alive(conn_ctx->pq_cnx, tconfig_.idle_timeout_ms * 500); picoquic_set_feedback_loss_notification(conn_ctx->pq_cnx, 1); - if (_tconfig.quic_priority_limit > 0) { - LOGGER_INFO(logger, "Setting priority bypass limit to {0}", static_cast(_tconfig.quic_priority_limit)); - picoquic_set_priority_limit_for_bypass(conn_ctx->pq_cnx, _tconfig.quic_priority_limit); + if (tconfig_.quic_priority_limit > 0) { + LOGGER_INFO(logger, "Setting priority bypass limit to {0}", static_cast(tconfig_.quic_priority_limit)); + picoquic_set_priority_limit_for_bypass(conn_ctx->pq_cnx, tconfig_.quic_priority_limit); } #if __cplusplus >= 202002L _cbNotifyQueue.push([=, this]() { _delegate.on_new_connection(conn_id, remote); }); #else - _cbNotifyQueue.push([=]() { _delegate.on_new_connection(conn_id, remote); }); + cbNotifyQueue_.Push([=]() { delegate_.OnNewConnection(conn_id, remote); }); #endif } void -PicoQuicTransport::on_recv_datagram(ConnectionContext* conn_ctx, uint8_t* bytes, size_t length) +PicoQuicTransport::OnRecvDatagram(ConnectionContext* conn_ctx, uint8_t* bytes, size_t length) { if (length == 0) { LOGGER_DEBUG("On receive datagram has zero length, ignoring"); @@ -1315,27 +1315,27 @@ PicoQuicTransport::on_recv_datagram(ConnectionContext* conn_ctx, uint8_t* bytes, std::vector data(bytes, bytes + length); - conn_ctx->dgram_rx_data.push(data); + conn_ctx->dgram_rx_data.Push(data); conn_ctx->metrics.rx_dgrams++; conn_ctx->metrics.rx_dgrams_bytes += length; - if (_cbNotifyQueue.size() > 100) { - LOGGER_INFO(logger, "on_recv_datagram cbNotifyQueue size {0}", _cbNotifyQueue.size()); + if (cbNotifyQueue_.Size() > 100) { + LOGGER_INFO(logger, "on_recv_datagram cbNotifyQueue size {0}", cbNotifyQueue_.Size()); } #if __cplusplus >= 202002L if (conn_ctx->dgram_rx_data.size() < 10 && !_cbNotifyQueue.push([=, this]() { #else - if (conn_ctx->dgram_rx_data.size() < 10 && !_cbNotifyQueue.push([=]() { + if (conn_ctx->dgram_rx_data.Size() < 10 && !cbNotifyQueue_.Push([=]() { #endif - _delegate.on_recv_dgram(conn_ctx->conn_id,std::nullopt); + delegate_.OnRecvDgram(conn_ctx->conn_id,std::nullopt); })) { LOGGER_ERROR(logger, "conn_id: {0} DGRAM notify queue is full", conn_ctx->conn_id); } } -void PicoQuicTransport::on_recv_stream_bytes(ConnectionContext* conn_ctx, +void PicoQuicTransport::OnRecvStreamBytes(ConnectionContext* conn_ctx, DataContext* data_ctx, uint64_t stream_id, uint8_t* bytes, @@ -1348,7 +1348,7 @@ void PicoQuicTransport::on_recv_stream_bytes(ConnectionContext* conn_ctx, auto rx_buf_it = conn_ctx->rx_stream_buffer.find(stream_id); if (rx_buf_it == conn_ctx->rx_stream_buffer.end()) { - std::lock_guard _l(_state_mutex); + std::lock_guard l(state_mutex_); LOGGER_DEBUG(logger, "Adding received conn_id: {0} stream_id: {1} into RX buffer", conn_ctx->conn_id, stream_id); @@ -1359,7 +1359,7 @@ void PicoQuicTransport::on_recv_stream_bytes(ConnectionContext* conn_ctx, Span bytes_a(bytes, length); auto &rx_buf = rx_buf_it->second; - rx_buf.buf->push(bytes_a); + rx_buf.buf->Push(bytes_a); if (data_ctx != nullptr) { data_ctx->metrics.rx_stream_cb++; @@ -1368,9 +1368,9 @@ void PicoQuicTransport::on_recv_stream_bytes(ConnectionContext* conn_ctx, #if __cplusplus >= 202002L if (!_cbNotifyQueue.push([=, this]() { #else - if (!_cbNotifyQueue.push([=]() { + if (!cbNotifyQueue_.Push([=]() { #endif - _delegate.on_recv_stream(conn_ctx->conn_id, stream_id, data_ctx->data_ctx_id, data_ctx->is_bidir); + delegate_.OnRecvStream(conn_ctx->conn_id, stream_id, data_ctx->data_ctx_id, data_ctx->is_bidir); })) { LOGGER_ERROR(logger, "conn_id: {0} stream_id: {1} notify queue is full", conn_ctx->conn_id, stream_id); @@ -1380,9 +1380,9 @@ void PicoQuicTransport::on_recv_stream_bytes(ConnectionContext* conn_ctx, #if __cplusplus >= 202002L if (!_cbNotifyQueue.push([=, this]() { #else - if (!_cbNotifyQueue.push([=]() { + if (!cbNotifyQueue_.Push([=]() { #endif - _delegate.on_recv_stream(conn_ctx->conn_id, stream_id, std::nullopt); + delegate_.OnRecvStream(conn_ctx->conn_id, stream_id, std::nullopt); })) { LOGGER_ERROR(logger, "conn_id: {0} stream_id: {1} notify queue is full", conn_ctx->conn_id, stream_id); @@ -1390,36 +1390,36 @@ void PicoQuicTransport::on_recv_stream_bytes(ConnectionContext* conn_ctx, } } -void PicoQuicTransport::emit_metrics() +void PicoQuicTransport::EmitMetrics() { - for (auto& [conn_id, conn_ctx] : _conn_context) { + for (auto& [conn_id, conn_ctx] : conn_context_) { const auto sample_time = std::chrono::time_point_cast(std::chrono::steady_clock::now()); if (metrics_conn_samples) { - metrics_conn_samples->push({ sample_time, conn_id, conn_ctx.metrics }); + metrics_conn_samples->Push({ sample_time, conn_id, conn_ctx.metrics }); } for (auto& [data_ctx_id, data_ctx] : conn_ctx.active_data_contexts) { if (metrics_data_samples) { - metrics_data_samples->push({ sample_time, conn_id, data_ctx_id, data_ctx.metrics }); + metrics_data_samples->Push({ sample_time, conn_id, data_ctx_id, data_ctx.metrics }); } - data_ctx.metrics.resetPeriod(); + data_ctx.metrics.ResetPeriod(); } - conn_ctx.metrics.resetPeriod(); + conn_ctx.metrics.ResetPeriod(); } } -void PicoQuicTransport::remove_closed_streams() { - std::lock_guard _(_state_mutex); +void PicoQuicTransport::RemoveClosedStreams() { + std::lock_guard _(state_mutex_); std::vector closed_streams; - for (auto& [conn_id, conn_ctx] : _conn_context) { + for (auto& [conn_id, conn_ctx] : conn_context_) { std::vector closed_streams; for (auto& [stream_id, rx_buf]: conn_ctx.rx_stream_buffer) { - if (rx_buf.closed && (rx_buf.buf->empty() || rx_buf.checked_once)) { + if (rx_buf.closed && (rx_buf.buf->Empty() || rx_buf.checked_once)) { closed_streams.push_back(stream_id); } rx_buf.checked_once = true; @@ -1431,9 +1431,9 @@ void PicoQuicTransport::remove_closed_streams() { } } -void PicoQuicTransport::check_conns_for_congestion() +void PicoQuicTransport::CheckConnsForCongestion() { - std::lock_guard _(_state_mutex); + std::lock_guard _(state_mutex_); /* * A sign of congestion is when transmit queues are not being serviced (e.g., have a backlog). @@ -1442,9 +1442,9 @@ void PicoQuicTransport::check_conns_for_congestion() * Check each queue size to determine if there is possible congestion */ - for (auto& [conn_id, conn_ctx] : _conn_context) { + for (auto& [conn_id, conn_ctx] : conn_context_) { int congested_count { 0 }; - uint16_t cwin_congested_count = conn_ctx.metrics.cwin_congested - conn_ctx.metrics._prev_cwin_congested; + uint16_t cwin_congested_count = conn_ctx.metrics.cwin_congested - conn_ctx.metrics.prev_cwin_congested; picoquic_path_quality_t path_quality; picoquic_get_path_quality(conn_ctx.pq_cnx, conn_ctx.pq_cnx->path[0]->unique_path_id, &path_quality); @@ -1453,18 +1453,18 @@ void PicoQuicTransport::check_conns_for_congestion() * Update metrics */ conn_ctx.metrics.tx_lost_pkts = path_quality.lost; - conn_ctx.metrics.tx_cwin_bytes.addValue(path_quality.cwin); - conn_ctx.metrics.tx_in_transit_bytes.addValue(path_quality.bytes_in_transit); + conn_ctx.metrics.tx_cwin_bytes.AddValue(path_quality.cwin); + conn_ctx.metrics.tx_in_transit_bytes.AddValue(path_quality.bytes_in_transit); conn_ctx.metrics.tx_spurious_losses = path_quality.spurious_losses; conn_ctx.metrics.tx_timer_losses = path_quality.timer_losses; - conn_ctx.metrics.rtt_us.addValue(path_quality.rtt_sample); - conn_ctx.metrics.srtt_us.addValue(path_quality.rtt); - conn_ctx.metrics.tx_rate_bps.addValue(path_quality.pacing_rate * 8); - conn_ctx.metrics.rx_rate_bps.addValue(path_quality.receive_rate_estimate * 8); + conn_ctx.metrics.rtt_us.AddValue(path_quality.rtt_sample); + conn_ctx.metrics.srtt_us.AddValue(path_quality.rtt); + conn_ctx.metrics.tx_rate_bps.AddValue(path_quality.pacing_rate * 8); + conn_ctx.metrics.rx_rate_bps.AddValue(path_quality.receive_rate_estimate * 8); // Is CWIN congested? - if (cwin_congested_count > 5 || (path_quality.cwin < PQ_CC_LOW_CWIN + if (cwin_congested_count > 5 || (path_quality.cwin < kPqCcLowCwin && path_quality.bytes_in_transit)) { /* TODO(tievens): comem back to this later. Right now it's too loud @@ -1483,7 +1483,7 @@ void PicoQuicTransport::check_conns_for_congestion() */ //congested_count++; /* TODO(tievens): DO NOT react to this right now, causing issue with low latency wired networks */ } - conn_ctx.metrics._prev_cwin_congested = conn_ctx.metrics.cwin_congested; + conn_ctx.metrics.prev_cwin_congested = conn_ctx.metrics.cwin_congested; // All other data flows (streams) uint64_t reset_wait_data_ctx_id {0}; // Positive value indicates the data_ctx_id that can be set to reset_wait @@ -1497,32 +1497,32 @@ void PicoQuicTransport::check_conns_for_congestion() // Don't include control stream in delayed callbacks check. Control stream should be priority 0 or 1 if (data_ctx.priority >= 2 - && data_ctx.metrics.tx_delayed_callback - data_ctx.metrics._prev_tx_delayed_callback > 1) { + && data_ctx.metrics.tx_delayed_callback - data_ctx.metrics.prev_tx_delayed_callback > 1) { LOGGER_WARN(logger, "CC: Stream congested, callback count greater than 1 conn_id: {0} data_ctx_id: {1} " "tx_data_queue: {2} congested_callbacks: {3}", data_ctx.conn_id, data_ctx.data_ctx_id, - data_ctx.tx_data->size(), - data_ctx.metrics.tx_delayed_callback - data_ctx.metrics._prev_tx_delayed_callback); + data_ctx.tx_data->Size(), + data_ctx.metrics.tx_delayed_callback - data_ctx.metrics.prev_tx_delayed_callback); congested_count++; } - data_ctx.metrics._prev_tx_delayed_callback = data_ctx.metrics.tx_delayed_callback; + data_ctx.metrics.prev_tx_delayed_callback = data_ctx.metrics.tx_delayed_callback; - data_ctx.metrics.tx_queue_size.addValue(data_ctx.tx_data->size()); + data_ctx.metrics.tx_queue_size.AddValue(data_ctx.tx_data->Size()); // TODO(tievens): size of TX is based on rate; adjust based on burst rates - if (data_ctx.tx_data->size() >= 50) { + if (data_ctx.tx_data->Size() >= 50) { LOGGER_WARN( logger, "CC: Stream congested, queue backlog conn_id: {0} data_ctx_id: {1} tx_data_queue: {2}", data_ctx.conn_id, data_ctx.data_ctx_id, - data_ctx.tx_data->size()); + data_ctx.tx_data->Size()); congested_count++; } - if (data_ctx.priority >= PQ_REST_WAIT_MIN_PRIORITY + if (data_ctx.priority >= kPqRestWaitMinPriority && data_ctx.uses_reset_wait && reset_wait_data_ctx_id == 0 && !data_ctx.tx_reset_wait_discard) { @@ -1557,7 +1557,7 @@ void PicoQuicTransport::check_conns_for_congestion() conn_ctx.metrics.tx_retransmits, conn_ctx.metrics.cwin_congested); - if (_tconfig.use_reset_wait_strategy && reset_wait_data_ctx_id > 0) { + if (tconfig_.use_reset_wait_strategy && reset_wait_data_ctx_id > 0) { auto& data_ctx = conn_ctx.active_data_contexts[reset_wait_data_ctx_id]; LOGGER_INFO(logger, "CC: conn_id: {0} setting reset and wait to data_ctx_id: {1} priority: {2}", @@ -1595,21 +1595,21 @@ void PicoQuicTransport::check_conns_for_congestion() * Private methods * ============================================================================ */ -void PicoQuicTransport::server() +void PicoQuicTransport::Server() { - int ret = picoquic_packet_loop(_quic_ctx, _serverInfo.port, PF_UNSPEC, 0, 2000000, 0, pq_loop_cb, this); + int ret = picoquic_packet_loop(quic_ctx_, serverInfo_.port, PF_UNSPEC, 0, 2000000, 0, PqLoopCb, this); - if (_quic_ctx != NULL) { - picoquic_free(_quic_ctx); - _quic_ctx = NULL; + if (quic_ctx_ != NULL) { + picoquic_free(quic_ctx_); + quic_ctx_ = NULL; } LOGGER_INFO(logger, "picoquic packet loop ended with {0}", ret); - setStatus(TransportStatus::Shutdown); + SetStatus(TransportStatus::kShutdown); } -TransportConnId PicoQuicTransport::createClient() +TransportConnId PicoQuicTransport::CreateClient() { struct sockaddr_storage server_address; char const* sni = "cisco.webex.com"; @@ -1617,31 +1617,31 @@ TransportConnId PicoQuicTransport::createClient() int is_name = 0; - ret = picoquic_get_server_address(_serverInfo.host_or_ip.c_str(), _serverInfo.port, &server_address, &is_name); + ret = picoquic_get_server_address(serverInfo_.host_or_ip.c_str(), serverInfo_.port, &server_address, &is_name); if (ret != 0 || server_address.ss_family == 0) { - LOGGER_ERROR(logger, "Failed to get server: {0} port: {1}", _serverInfo.host_or_ip, _serverInfo.port); - setStatus(TransportStatus::Disconnected); + LOGGER_ERROR(logger, "Failed to get server: {0} port: {1}", serverInfo_.host_or_ip, serverInfo_.port); + SetStatus(TransportStatus::kDisconnected); return 0; } else if (is_name) { - sni = _serverInfo.host_or_ip.c_str(); + sni = serverInfo_.host_or_ip.c_str(); } - if (_tconfig.use_bbr) { - picoquic_set_default_congestion_algorithm(_quic_ctx, picoquic_bbr_algorithm); + if (tconfig_.use_bbr) { + picoquic_set_default_congestion_algorithm(quic_ctx_, picoquic_bbr_algorithm); } else { - picoquic_set_default_congestion_algorithm(_quic_ctx, picoquic_newreno_algorithm); + picoquic_set_default_congestion_algorithm(quic_ctx_, picoquic_newreno_algorithm); } uint64_t current_time = picoquic_current_time(); - picoquic_cnx_t* cnx = picoquic_create_cnx(_quic_ctx, + picoquic_cnx_t* cnx = picoquic_create_cnx(quic_ctx_, picoquic_null_connection_id, picoquic_null_connection_id, reinterpret_cast(&server_address), current_time, 0, sni, - _config.alpn, + config_.alpn, 1); if (cnx == NULL) { @@ -1650,12 +1650,12 @@ TransportConnId PicoQuicTransport::createClient() } // Using default TP - picoquic_set_transport_parameters(cnx, &_local_tp_options); + picoquic_set_transport_parameters(cnx, &local_tp_options_); picoquic_set_feedback_loss_notification(cnx, 1); - if (_tconfig.quic_priority_limit > 0) { - LOGGER_INFO(logger, "Setting priority bypass limit to {0}", static_cast(_tconfig.quic_priority_limit)); - picoquic_set_priority_limit_for_bypass(cnx, _tconfig.quic_priority_limit); + if (tconfig_.quic_priority_limit > 0) { + LOGGER_INFO(logger, "Setting priority bypass limit to {0}", static_cast(tconfig_.quic_priority_limit)); + picoquic_set_priority_limit_for_bypass(cnx, tconfig_.quic_priority_limit); } else { LOGGER_INFO(logger, "No priority bypass"); } @@ -1663,20 +1663,20 @@ TransportConnId PicoQuicTransport::createClient() // picoquic_subscribe_pacing_rate_updates(cnx, tconfig.pacing_decrease_threshold_Bps, // tconfig.pacing_increase_threshold_Bps); - auto &_ = createConnContext(cnx); + auto &_ = CreateConnContext(cnx); return reinterpret_cast(cnx); } -void PicoQuicTransport::client(const TransportConnId conn_id) +void PicoQuicTransport::Client(const TransportConnId conn_id) { int ret; - auto conn_ctx = getConnContext(conn_id); + auto conn_ctx = GetConnContext(conn_id); if (conn_ctx == nullptr) { LOGGER_ERROR(logger, "Client connection does not exist, check connection settings."); - setStatus(TransportStatus::Disconnected); + SetStatus(TransportStatus::kDisconnected); return; } @@ -1685,61 +1685,61 @@ void PicoQuicTransport::client(const TransportConnId conn_id) if (conn_ctx->pq_cnx == NULL) { LOGGER_ERROR(logger, "Could not create picoquic connection client context"); } else { - picoquic_set_callback(conn_ctx->pq_cnx, pq_event_cb, this); + picoquic_set_callback(conn_ctx->pq_cnx, PqEventCb, this); - picoquic_enable_keep_alive(conn_ctx->pq_cnx, _tconfig.idle_timeout_ms * 500); + picoquic_enable_keep_alive(conn_ctx->pq_cnx, tconfig_.idle_timeout_ms * 500); ret = picoquic_start_client_cnx(conn_ctx->pq_cnx); if (ret < 0) { LOGGER_ERROR(logger, "Could not activate connection"); return; } - ret = picoquic_packet_loop(_quic_ctx, 0, PF_UNSPEC, 0, 2000000, 0, pq_loop_cb, this); + ret = picoquic_packet_loop(quic_ctx_, 0, PF_UNSPEC, 0, 2000000, 0, PqLoopCb, this); LOGGER_INFO(logger, "picoquic ended with {0}", ret); } - if (_quic_ctx != NULL) { - picoquic_free(_quic_ctx); - _quic_ctx = NULL; + if (quic_ctx_ != NULL) { + picoquic_free(quic_ctx_); + quic_ctx_ = NULL; } - setStatus(TransportStatus::Disconnected); + SetStatus(TransportStatus::kDisconnected); } -void PicoQuicTransport::shutdown() +void PicoQuicTransport::Shutdown() { - if (_stop) // Already stopped + if (stop_) // Already stopped return; - _stop = true; + stop_ = true; - if (_picoQuicThread.joinable()) { + if (picoQuicThread_.joinable()) { LOGGER_INFO(logger, "Closing transport pico thread"); - _picoQuicThread.join(); + picoQuicThread_.join(); } - _picoquic_runner_queue.stop_waiting(); - _cbNotifyQueue.stop_waiting(); + picoquic_runner_queue_.StopWaiting(); + cbNotifyQueue_.StopWaiting(); - if (_cbNotifyThread.joinable()) { + if (cbNotifyThread_.joinable()) { LOGGER_INFO(logger, "Closing transport callback notifier thread"); - _cbNotifyThread.join(); + cbNotifyThread_.join(); } - _tick_service.reset(); + tick_service_.reset(); LOGGER_INFO(logger, "done closing transport threads"); - picoquic_config_clear(&_config); + picoquic_config_clear(&config_); // If logging picoquic events, stop those debug_set_callback(NULL, NULL); } -void PicoQuicTransport::check_callback_delta(DataContext* data_ctx, bool tx) { +void PicoQuicTransport::CheckCallbackDelta(DataContext* data_ctx, bool tx) { if (!tx) return; - const auto current_tick = _tick_service->get_ticks(std::chrono::milliseconds(1)); + const auto current_tick = tick_service_->GetTicks(std::chrono::milliseconds(1)); if (data_ctx->last_tx_tick == 0) { data_ctx->last_tx_tick = current_tick; @@ -1749,14 +1749,14 @@ void PicoQuicTransport::check_callback_delta(DataContext* data_ctx, bool tx) { const auto delta_ms = current_tick - data_ctx->last_tx_tick; data_ctx->last_tx_tick = current_tick; - data_ctx->metrics.tx_callback_ms.addValue(delta_ms); + data_ctx->metrics.tx_callback_ms.AddValue(delta_ms); - if (data_ctx->priority > 0 && delta_ms > 50 && data_ctx->tx_data->size() >= 20) { + if (data_ctx->priority > 0 && delta_ms > 50 && data_ctx->tx_data->Size() >= 20) { data_ctx->metrics.tx_delayed_callback++; picoquic_path_quality_t path_quality; - if (const auto conn_it = getConnContext(data_ctx->conn_id)) { + if (const auto conn_it = GetConnContext(data_ctx->conn_id)) { picoquic_get_path_quality(conn_it->pq_cnx, conn_it->pq_cnx->path[0]->unique_path_id, &path_quality); } @@ -1785,12 +1785,12 @@ void PicoQuicTransport::check_callback_delta(DataContext* data_ctx, bool tx) { } } -void PicoQuicTransport::cbNotifier() +void PicoQuicTransport::CbNotifier() { LOGGER_INFO(logger, "Starting transport callback notifier thread"); - while (not _stop) { - auto cb = std::move(_cbNotifyQueue.block_pop()); + while (not stop_) { + auto cb = std::move(cbNotifyQueue_.BlockPop()); if (cb) { (*cb)(); } else { @@ -1801,14 +1801,14 @@ void PicoQuicTransport::cbNotifier() LOGGER_INFO(logger, "Done with transport callback notifier thread"); } -void PicoQuicTransport::create_stream(ConnectionContext& conn_ctx, DataContext *data_ctx) +void PicoQuicTransport::CreateStream(ConnectionContext& conn_ctx, DataContext *data_ctx) { conn_ctx.last_stream_id = picoquic_get_next_local_stream_id(conn_ctx.pq_cnx, !data_ctx->is_bidir); LOGGER_DEBUG(logger, "conn_id: {0} data_ctx_id: {1} create new stream with stream_id: {2}" << conn_ctx.conn_id, data_ctx->data_ctx_id, conn_ctx.last_stream_id); if (data_ctx->current_stream_id) { - close_stream(conn_ctx, data_ctx, false); + CloseStream(conn_ctx, data_ctx, false); } data_ctx->current_stream_id = conn_ctx.last_stream_id; @@ -1821,14 +1821,14 @@ void PicoQuicTransport::create_stream(ConnectionContext& conn_ctx, DataContext * data_ctx->mark_stream_active = true; - _picoquic_runner_queue.push([this, conn_id = conn_ctx.conn_id, data_ctx_id = data_ctx->data_ctx_id]() { - mark_stream_active(conn_id, data_ctx_id); + picoquic_runner_queue_.Push([this, conn_id = conn_ctx.conn_id, data_ctx_id = data_ctx->data_ctx_id]() { + MarkStreamActive(conn_id, data_ctx_id); }); } -void PicoQuicTransport::close_stream(ConnectionContext& conn_ctx, DataContext* data_ctx, const bool send_reset) +void PicoQuicTransport::CloseStream(ConnectionContext& conn_ctx, DataContext* data_ctx, const bool send_reset) { if (!data_ctx->current_stream_id.has_value()) { return; // stream already closed @@ -1850,12 +1850,12 @@ void PicoQuicTransport::close_stream(ConnectionContext& conn_ctx, DataContext* d picoquic_add_to_stream(conn_ctx.pq_cnx, *data_ctx->current_stream_id, &empty, 0, 1); } - data_ctx->reset_tx_object(); + data_ctx->ResetTxObject(); if (data_ctx->current_stream_id) { const auto rx_buf_it = conn_ctx.rx_stream_buffer.find(*data_ctx->current_stream_id); if (rx_buf_it != conn_ctx.rx_stream_buffer.end()) { - std::lock_guard _(_state_mutex); + std::lock_guard _(state_mutex_); conn_ctx.rx_stream_buffer.erase(rx_buf_it); } } @@ -1863,11 +1863,11 @@ void PicoQuicTransport::close_stream(ConnectionContext& conn_ctx, DataContext* d data_ctx->current_stream_id = std::nullopt; } -void PicoQuicTransport::mark_stream_active(const TransportConnId conn_id, const DataContextId data_ctx_id) { - std::lock_guard _(_state_mutex); +void PicoQuicTransport::MarkStreamActive(const TransportConnId conn_id, const DataContextId data_ctx_id) { + std::lock_guard _(state_mutex_); - const auto conn_it = _conn_context.find(conn_id); - if (conn_it == _conn_context.end()) { + const auto conn_it = conn_context_.find(conn_id); + if (conn_it == conn_context_.end()) { return; } @@ -1888,11 +1888,11 @@ void PicoQuicTransport::mark_stream_active(const TransportConnId conn_id, const &data_ctx_it->second); } -void PicoQuicTransport::mark_dgram_ready(const TransportConnId conn_id) { - std::lock_guard _(_state_mutex); +void PicoQuicTransport::MarkDgramReady(const TransportConnId conn_id) { + std::lock_guard _(state_mutex_); - const auto conn_it = _conn_context.find(conn_id); - if (conn_it == _conn_context.end()) { + const auto conn_it = conn_context_.find(conn_id); + if (conn_it == conn_context_.end()) { return; } diff --git a/src/transport_picoquic.h b/src/transport_picoquic.h index 0b83b0b..ec81a26 100644 --- a/src/transport_picoquic.h +++ b/src/transport_picoquic.h @@ -31,17 +31,16 @@ namespace qtransport { - constexpr int PQ_LOOP_MAX_DELAY_US = 500; /// The max microseconds that pq_loop will be ran again - constexpr int PQ_REST_WAIT_MIN_PRIORITY = 4; /// Minimum priority value to consider for RESET and WAIT - constexpr int PQ_CC_LOW_CWIN = 4000; /// Bytes less than this value are considered a low/congested CWIN + constexpr int kPqLoopMaxDelayUs = 500; /// The max microseconds that pq_loop will be ran again + constexpr int kPqRestWaitMinPriority = 4; /// Minimum priority value to consider for RESET and WAIT + constexpr int kPqCcLowCwin = 4000; /// Bytes less than this value are considered a low/congested CWIN class PicoQuicTransport : public ITransport { public: - const char* QUICR_ALPN = "moq-00"; + const char* quicr_alpn = "moq-00"; - using bytes_t = std::vector; - using timeQueue = TimeQueue; + using BytesT = std::vector; using DataContextId = uint64_t; /** @@ -60,10 +59,10 @@ class PicoQuicTransport : public ITransport TransportConnId conn_id {0}; /// The connection ID this context is under enum class StreamAction : uint8_t { /// Stream action that should be done by send/receive processing - NO_ACTION=0, - REPLACE_STREAM_USE_RESET, - REPLACE_STREAM_USE_FIN, - } stream_action {StreamAction::NO_ACTION}; + kNoAction=0, + kReplaceStreamUseReset, + kReplaceStreamUseFin, + } stream_action {StreamAction::kNoAction}; std::optional current_stream_id; /// Current active stream if the value is >= 4 @@ -99,7 +98,7 @@ class PicoQuicTransport : public ITransport /** * Reset the TX object buffer */ - void reset_tx_object() { + void ResetTxObject() { if (stream_tx_object != nullptr) { delete [] stream_tx_object; } @@ -124,7 +123,7 @@ class PicoQuicTransport : public ITransport std::unique_ptr> dgram_tx_data; /// Datagram pending objects to be written to the network - SafeQueue dgram_rx_data; /// Buffered datagrams received from the network + SafeQueue dgram_rx_data; /// Buffered datagrams received from the network /** * Active stream buffers for received unidirectional streams @@ -191,7 +190,7 @@ class PicoQuicTransport : public ITransport static void PicoQuicLogging(const char *message, void *argp) { auto instance = reinterpret_cast(argp); - if (!instance->_stop && instance->logger) + if (!instance->stop_ && instance->logger) { instance->logger->info(message); } @@ -201,27 +200,27 @@ class PicoQuicTransport : public ITransport PicoQuicTransport(const TransportRemote& server, const TransportConfig& tcfg, TransportDelegate& delegate, - bool _is_server_mode, + bool is_server_mode, std::shared_ptr logger); virtual ~PicoQuicTransport(); - TransportStatus status() const override; - TransportConnId start(std::shared_ptr> metrics_conn_samples, + TransportStatus Status() const override; + TransportConnId Start(std::shared_ptr> metrics_conn_samples, std::shared_ptr> metrics_data_samples) override; - void close(const TransportConnId& conn_id, uint64_t app_reason_code=0) override; + void Close(const TransportConnId& conn_id, uint64_t app_reason_code=0) override; - virtual bool getPeerAddrInfo(const TransportConnId& conn_id, + virtual bool GetPeerAddrInfo(const TransportConnId& conn_id, sockaddr_storage* addr) override; - DataContextId createDataContext(TransportConnId conn_id, + DataContextId CreateDataContext(TransportConnId conn_id, bool use_reliable_transport, uint8_t priority, bool bidir) override; - void deleteDataContext(const TransportConnId& conn_id, DataContextId data_ctx_id) override; - void delete_data_context_internal(TransportConnId conn_id, DataContextId data_ctx_id); + void DeleteDataContext(const TransportConnId& conn_id, DataContextId data_ctx_id) override; + void DeleteDataContextInternal(TransportConnId conn_id, DataContextId data_ctx_id); - TransportError enqueue(const TransportConnId& conn_id, + TransportError Enqueue(const TransportConnId& conn_id, const DataContextId& data_ctx_id, std::vector&& bytes, std::vector &&trace, @@ -230,23 +229,23 @@ class PicoQuicTransport : public ITransport uint32_t delay_ms, EnqueueFlags flags) override; - std::optional> dequeue(TransportConnId conn_id, + std::optional> Dequeue(TransportConnId conn_id, std::optional data_ctx_id) override; - std::shared_ptr> getStreamBuffer(TransportConnId conn_id, uint64_t stream_id) override; + std::shared_ptr> GetStreamBuffer(TransportConnId conn_id, uint64_t stream_id) override; - void setRemoteDataCtxId(TransportConnId conn_id, + void SetRemoteDataCtxId(TransportConnId conn_id, DataContextId data_ctx_id, DataContextId remote_data_ctx_id) override; - void setStreamIdDataCtxId(TransportConnId conn_id, DataContextId data_ctx_id, uint64_t stream_id) override; - void setDataCtxPriority(TransportConnId conn_id, DataContextId data_ctx_id, uint8_t priority) override; + void SetStreamIdDataCtxId(TransportConnId conn_id, DataContextId data_ctx_id, uint64_t stream_id) override; + void SetDataCtxPriority(TransportConnId conn_id, DataContextId data_ctx_id, uint8_t priority) override; /* * Internal public methods */ - ConnectionContext* getConnContext(const TransportConnId& conn_id); - void setStatus(TransportStatus status); + ConnectionContext* GetConnContext(const TransportConnId& conn_id); + void SetStatus(TransportStatus status); /** * @brief Create bidirectional data context for received new stream @@ -259,25 +258,25 @@ class PicoQuicTransport : public ITransport * * @returns DataContext pointer to the created context, nullptr if invalid connection id */ - DataContext* createDataContextBiDirRecv(TransportConnId conn_id, uint64_t stream_id); + DataContext* CreateDataContextBiDirRecv(TransportConnId conn_id, uint64_t stream_id); - ConnectionContext& createConnContext(picoquic_cnx_t * pq_cnx); + ConnectionContext& CreateConnContext(picoquic_cnx_t * pq_cnx); - void send_next_datagram(ConnectionContext* conn_ctx, uint8_t* bytes_ctx, size_t max_len); - void send_stream_bytes(DataContext* data_ctx, uint8_t* bytes_ctx, size_t max_len); + void SendNextDatagram(ConnectionContext* conn_ctx, uint8_t* bytes_ctx, size_t max_len); + void SendStreamBytes(DataContext* data_ctx, uint8_t* bytes_ctx, size_t max_len); - void on_connection_status(TransportConnId conn_id, + void OnConnectionStatus(TransportConnId conn_id, TransportStatus status); - void on_new_connection(TransportConnId conn_id); - void on_recv_datagram(ConnectionContext* conn_ctx, + void OnNewConnection(TransportConnId conn_id); + void OnRecvDatagram(ConnectionContext* conn_ctx, uint8_t* bytes, size_t length); - void on_recv_stream_bytes(ConnectionContext *conn_ctx, DataContext* data_ctx, uint64_t stream_id, + void OnRecvStreamBytes(ConnectionContext *conn_ctx, DataContext* data_ctx, uint64_t stream_id, uint8_t* bytes, size_t length); - void check_conns_for_congestion(); - void emit_metrics(); - void remove_closed_streams(); + void CheckConnsForCongestion(); + void EmitMetrics(); + void RemoveClosedStreams(); /** * @brief Function run the queue functions within the picoquic thread via the pq_loop_cb @@ -286,39 +285,39 @@ class PicoQuicTransport : public ITransport * the event loop. This allows picoquic to be thread safe. All picoquic functions that * other threads want to call should queue those in `picoquic_runner_queue`. */ - void pq_runner(); + void PqRunner(); /* * Internal Public Variables */ std::shared_ptr logger; - bool _is_server_mode; - bool _is_unidirectional{ false }; + bool is_server_mode; + bool is_unidirectional{ false }; bool debug {false}; private: - TransportConnId createClient(); - void shutdown(); + TransportConnId CreateClient(); + void Shutdown(); - void server(); - void client(TransportConnId conn_id); - void cbNotifier(); + void Server(); + void Client(TransportConnId conn_id); + void CbNotifier(); - void check_callback_delta(DataContext* data_ctx, bool tx=true); + void CheckCallbackDelta(DataContext* data_ctx, bool tx=true); /** * @brief Mark a stream active * @details This method MUST only be called within the picoquic thread. Enqueue and other * thread methods can call this via the pq_runner. */ - void mark_stream_active(TransportConnId conn_id, DataContextId data_ctx_id); + void MarkStreamActive(TransportConnId conn_id, DataContextId data_ctx_id); /** * @brief Mark datagram ready * @details This method MUST only be called within the picoquic thread. Enqueue and other * thread methods can call this via the pq_runner. */ - void mark_dgram_ready(TransportConnId conn_id); + void MarkDgramReady(TransportConnId conn_id); /** * @brief Create a new stream @@ -326,7 +325,7 @@ class PicoQuicTransport : public ITransport * @param conn_ctx Connection context to create stream under * @param data_ctx Data context in connection context to create streams */ - void create_stream(ConnectionContext&conn_ctx, DataContext *data_ctx); + void CreateStream(ConnectionContext&conn_ctx, DataContext *data_ctx); /** * @brief App initiated Close stream @@ -337,31 +336,31 @@ class PicoQuicTransport : public ITransport * @param data_ctx Data context for the stream * @param send_reset Indicates if the stream should be closed by RESET, otherwise FIN */ - void close_stream(ConnectionContext& conn_ctx, DataContext *data_ctx, bool send_reset); + void CloseStream(ConnectionContext& conn_ctx, DataContext *data_ctx, bool send_reset); /* * Variables */ - picoquic_quic_config_t _config; - picoquic_quic_t* _quic_ctx; - picoquic_tp_t _local_tp_options; - SafeQueue> _cbNotifyQueue; + picoquic_quic_config_t config_; + picoquic_quic_t* quic_ctx_; + picoquic_tp_t local_tp_options_; + SafeQueue> cbNotifyQueue_; - SafeQueue> _picoquic_runner_queue; /// Threads queue functions that picoquic will call via the pq_loop_cb call + SafeQueue> picoquic_runner_queue_; /// Threads queue functions that picoquic will call via the pq_loop_cb call - std::atomic _stop; - std::mutex _state_mutex; /// Used for stream/context/state updates - std::atomic _transportStatus; - std::thread _picoQuicThread; - std::thread _cbNotifyThread; + std::atomic stop_; + std::mutex state_mutex_; /// Used for stream/context/state updates + std::atomic transportStatus_; + std::thread picoQuicThread_; + std::thread cbNotifyThread_; - TransportRemote _serverInfo; - TransportDelegate& _delegate; - TransportConfig _tconfig; + TransportRemote serverInfo_; + TransportDelegate& delegate_; + TransportConfig tconfig_; - std::map _conn_context; - std::shared_ptr _tick_service; + std::map conn_context_; + std::shared_ptr tick_service_; }; } // namespace qtransport diff --git a/src/transport_udp.cpp b/src/transport_udp.cpp index 0095d36..f42558e 100644 --- a/src/transport_udp.cpp +++ b/src/transport_udp.cpp @@ -76,14 +76,14 @@ UDPTransport::~UDPTransport() { // TODO: Close all streams and connections // Stop threads - _stop = true; + stop_ = true; // Close socket fd - if (_fd >= 0) - ::close(_fd); + if (fd_ >= 0) + ::close(fd_); - LOGGER_INFO(_logger, "Closing transport threads"); - for (auto &thread: _running_threads) { + LOGGER_INFO(logger_, "Closing transport threads"); + for (auto &thread: running_threads_) { if (thread.joinable()) thread.join(); } @@ -92,38 +92,38 @@ UDPTransport::~UDPTransport() { UDPTransport::UDPTransport(const TransportRemote &server, const TransportConfig& tcfg, TransportDelegate &delegate, - bool isServerMode, + bool is_server_mode, std::shared_ptr logger) - : _stop(false), - _logger(std::move(logger)), - _tconfig(tcfg), - _fd(-1), - _isServerMode(isServerMode), - _serverInfo(server), _delegate(delegate) { - _tick_service = std::make_shared(); + : stop_(false), + logger_(std::move(logger)), + tconfig_(tcfg), + fd_(-1), + isServerMode_(is_server_mode), + serverInfo_(server), delegate_(delegate) { + tick_service_ = std::make_shared(); } -TransportStatus UDPTransport::status() const { - if (_stop) { - return TransportStatus::Shutdown; - } else if (_isServerMode && _fd > 0) { - return TransportStatus::Ready; +TransportStatus UDPTransport::Status() const { + if (stop_) { + return TransportStatus::kShutdown; + } else if (isServerMode_ && fd_ > 0) { + return TransportStatus::kReady; } - return _clientStatus; + return clientStatus_; } -DataContextId UDPTransport::createDataContext(const qtransport::TransportConnId conn_id, +DataContextId UDPTransport::CreateDataContext(const qtransport::TransportConnId conn_id, [[maybe_unused]] bool use_reliable_transport, uint8_t priority, [[maybe_unused]] bool bidir) { - [[maybe_unused]] const std::lock_guard wl(_writer_mutex); - [[maybe_unused]] const std::lock_guard rl(_reader_mutex); + [[maybe_unused]] const std::lock_guard wl(writer_mutex_); + [[maybe_unused]] const std::lock_guard rl(reader_mutex_); - const auto conn_it = _conn_contexts.find(conn_id); + const auto conn_it = conn_contexts_.find(conn_id); - if (conn_it == _conn_contexts.end()) { - LOGGER_ERROR(_logger, "Failed to create data context, invalid connection id: {0}", conn_id); + if (conn_it == conn_contexts_.end()) { + LOGGER_ERROR(logger_, "Failed to create data context, invalid connection id: {0}", conn_id); return 0; // Error } @@ -134,67 +134,67 @@ DataContextId UDPTransport::createDataContext(const qtransport::TransportConnId const auto& [data_ctx_it, is_new] = conn.data_contexts.try_emplace(data_ctx_id); if (is_new) { - LOGGER_INFO(_logger, "Creating data context conn_id: {0} data_ctx_id: {1}", conn_id, data_ctx_id); + LOGGER_INFO(logger_, "Creating data context conn_id: {0} data_ctx_id: {1}", conn_id, data_ctx_id); data_ctx_it->second.data_ctx_id = data_ctx_id; data_ctx_it->second.priority = priority; - data_ctx_it->second.rx_data.set_limit(_tconfig.time_queue_rx_size); + data_ctx_it->second.rx_data.SetLimit(tconfig_.time_queue_rx_size); } return data_ctx_id; } -TransportConnId UDPTransport::start(std::shared_ptr> metrics_conn_samples, +TransportConnId UDPTransport::Start(std::shared_ptr> metrics_conn_samples, std::shared_ptr> metrics_data_samples) { this->metrics_conn_samples = std::move(metrics_conn_samples); this->metrics_data_samples = std::move(metrics_data_samples); - if (_isServerMode) { - return connect_server(); + if (isServerMode_) { + return ConnectServer(); } - return connect_client(); + return ConnectClient(); } -void UDPTransport::deleteDataContext(const TransportConnId& conn_id, DataContextId data_ctx_id) { - [[maybe_unused]] const std::lock_guard wl(_writer_mutex); - [[maybe_unused]] const std::lock_guard rl(_reader_mutex); +void UDPTransport::DeleteDataContext(const TransportConnId& conn_id, DataContextId data_ctx_id) { + [[maybe_unused]] const std::lock_guard wl(writer_mutex_); + [[maybe_unused]] const std::lock_guard rl(reader_mutex_); - auto conn_it = _conn_contexts.find(conn_id); - if (conn_it != _conn_contexts.end()) { - LOGGER_INFO(_logger, "Delete data context id: {0} in conn_id: {1}", data_ctx_id, conn_id); + auto conn_it = conn_contexts_.find(conn_id); + if (conn_it != conn_contexts_.end()) { + LOGGER_INFO(logger_, "Delete data context id: {0} in conn_id: {1}", data_ctx_id, conn_id); conn_it->second->data_contexts.erase(data_ctx_id); } } -void UDPTransport::setRemoteDataCtxId(const TransportConnId conn_id, +void UDPTransport::SetRemoteDataCtxId(const TransportConnId conn_id, const DataContextId data_ctx_id, const DataContextId remote_data_ctx_id) { - const std::lock_guard _(_writer_mutex); + const std::lock_guard _(writer_mutex_); - auto conn_it = _conn_contexts.find(conn_id); - if (conn_it != _conn_contexts.end()) { + auto conn_it = conn_contexts_.find(conn_id); + if (conn_it != conn_contexts_.end()) { const auto data_ctx_it = conn_it->second->data_contexts.find(data_ctx_id); if (data_ctx_it != conn_it->second->data_contexts.end()) { - LOGGER_DEBUG(_logger, + LOGGER_DEBUG(logger_, "Setting remote data context id conn_id: {0} data_ctx_id: {1} remote_data_ctx_id: {2}", conn_id, data_ctx_id, remote_data_ctx_id); data_ctx_it->second.remote_data_ctx_id = remote_data_ctx_id; - data_ctx_it->second.remote_data_ctx_id_V = std::move(to_uintV(remote_data_ctx_id)); + data_ctx_it->second.remote_data_ctx_id_v = std::move(ToUintV(remote_data_ctx_id)); } } } -bool UDPTransport::getPeerAddrInfo(const TransportConnId &conn_id, +bool UDPTransport::GetPeerAddrInfo(const TransportConnId &conn_id, sockaddr_storage *addr) { // Locate the given transport context - auto it = _conn_contexts.find(conn_id); + auto it = conn_contexts_.find(conn_id); // If not found, return false - if (it == _conn_contexts.end()) return false; + if (it == conn_contexts_.end()) return false; // Copy the address information std::memcpy(addr, &it->second->addr, sizeof(it->second->addr)); @@ -202,35 +202,35 @@ bool UDPTransport::getPeerAddrInfo(const TransportConnId &conn_id, return true; } -void UDPTransport::close(const TransportConnId &conn_id, uint64_t app_reason_code) { +void UDPTransport::Close(const TransportConnId &conn_id, uint64_t app_reason_code) { - LOGGER_DEBUG(_logger, "Close UDP conn_id: {0}", conn_id); + LOGGER_DEBUG(logger_, "Close UDP conn_id: {0}", conn_id); - std::unique_lock wlock(_writer_mutex); - std::unique_lock rlock(_reader_mutex); + std::unique_lock wlock(writer_mutex_); + std::unique_lock rlock(reader_mutex_); - auto conn_it = _conn_contexts.find(conn_id); - if (conn_it != _conn_contexts.end()) { + auto conn_it = conn_contexts_.find(conn_id); + if (conn_it != conn_contexts_.end()) { - if (conn_it->second->status == TransportStatus::Ready) { - send_disconnect(conn_it->second->id, conn_it->second->addr); + if (conn_it->second->status == TransportStatus::kReady) { + SendDisconnect(conn_it->second->id, conn_it->second->addr); } - _addr_conn_contexts.erase(conn_it->second->addr.id); - _conn_contexts.erase(conn_it); + addr_conn_contexts_.erase(conn_it->second->addr.id); + conn_contexts_.erase(conn_it); - if (!_isServerMode) { - _stop = true; + if (!isServerMode_) { + stop_ = true; } wlock.unlock(); // Make sure to not lock when calling delegates rlock.unlock(); // Make sure to not lock when calling delegates - _delegate.on_connection_status(conn_id, TransportStatus::Disconnected); + delegate_.OnConnectionStatus(conn_id, TransportStatus::kDisconnected); return; } } -AddrId UDPTransport::create_addr_id(const sockaddr_storage &addr) { +AddrId UDPTransport::CreateAddrId(const sockaddr_storage &addr) { AddrId id; switch (addr.ss_family) { @@ -256,12 +256,12 @@ AddrId UDPTransport::create_addr_id(const sockaddr_storage &addr) { return id; } -TransportRemote UDPTransport::create_addr_remote(const sockaddr_storage &addr) { +TransportRemote UDPTransport::CreateAddrRemote(const sockaddr_storage &addr) { TransportRemote remote; char ip[INET6_ADDRSTRLEN]; - remote.proto = TransportProtocol::UDP; + remote.proto = TransportProtocol::kUdp; switch (addr.ss_family) { case AF_INET: { @@ -280,19 +280,19 @@ TransportRemote UDPTransport::create_addr_remote(const sockaddr_storage &addr) { break; } default: - LOGGER_ERROR(_logger, "Unknown AFI: {0}", static_cast(addr.ss_family)); + LOGGER_ERROR(logger_, "Unknown AFI: {0}", static_cast(addr.ss_family)); break; } return std::move(remote); } -bool UDPTransport::send_connect(const TransportConnId conn_id, const Addr& addr) { - UdpProtocol::ConnectMsg chdr {}; +bool UDPTransport::SendConnect(const TransportConnId conn_id, const Addr& addr) { + udp_protocol::ConnectMsg chdr {}; chdr.idle_timeout = 20; - int numSent = sendto(_fd, + int num_sent = sendto(fd_, (uint8_t *)&chdr, sizeof(chdr), 0 /*flags*/, @@ -300,23 +300,23 @@ bool UDPTransport::send_connect(const TransportConnId conn_id, const Addr& addr) addr.addr_len); - if (numSent < 0) { - LOGGER_ERROR(_logger, "conn_id: {0} Error sending CONNECT to UDP socket: {1}", conn_id, strerror(errno)); + if (num_sent < 0) { + LOGGER_ERROR(logger_, "conn_id: {0} Error sending CONNECT to UDP socket: {1}", conn_id, strerror(errno)); return false; - } else if (numSent != sizeof(chdr)) { - LOGGER_WARN(_logger, "conn_id: {0} Failed to send CONNECT message, sent: {1}", conn_id, numSent); + } else if (num_sent != sizeof(chdr)) { + LOGGER_WARN(logger_, "conn_id: {0} Failed to send CONNECT message, sent: {1}", conn_id, num_sent); return false; } return true; } -bool UDPTransport::send_connect_ok(const TransportConnId conn_id, const Addr& addr) { - UdpProtocol::ConnectOkMsg hdr {}; +bool UDPTransport::SendConnectOk(const TransportConnId conn_id, const Addr& addr) { + udp_protocol::ConnectOkMsg hdr {}; - int numSent = sendto(_fd, + int num_sent = sendto(fd_, (uint8_t *)&hdr, sizeof(hdr), 0 /*flags*/, @@ -324,23 +324,23 @@ bool UDPTransport::send_connect_ok(const TransportConnId conn_id, const Addr& ad addr.addr_len); - if (numSent < 0) { - LOGGER_ERROR(_logger, "conn_id: {0} Error sending CONNECT_OK to UDP socket: {1}", conn_id, strerror(errno)); + if (num_sent < 0) { + LOGGER_ERROR(logger_, "conn_id: {0} Error sending CONNECT_OK to UDP socket: {1}", conn_id, strerror(errno)); return false; - } else if (numSent != sizeof(hdr)) { - LOGGER_WARN(_logger, "conn_id: {0} Failed to send CONNECT_OK message, sent: {1}", conn_id, numSent); + } else if (num_sent != sizeof(hdr)) { + LOGGER_WARN(logger_, "conn_id: {0} Failed to send CONNECT_OK message, sent: {1}", conn_id, num_sent); return false; } return true; } -bool UDPTransport::send_disconnect(const TransportConnId conn_id, const Addr& addr) { - UdpProtocol::DisconnectMsg dhdr {}; +bool UDPTransport::SendDisconnect(const TransportConnId conn_id, const Addr& addr) { + udp_protocol::DisconnectMsg dhdr {}; - int numSent = sendto(_fd, + int num_sent = sendto(fd_, (uint8_t *)&dhdr, sizeof(dhdr), 0 /*flags*/, @@ -348,28 +348,28 @@ bool UDPTransport::send_disconnect(const TransportConnId conn_id, const Addr& ad addr.addr_len); - if (numSent < 0) { - LOGGER_ERROR(_logger, "conn_id: {0} Error sending DISCONNECT to UDP socket: {1}", conn_id, strerror(errno)); + if (num_sent < 0) { + LOGGER_ERROR(logger_, "conn_id: {0} Error sending DISCONNECT to UDP socket: {1}", conn_id, strerror(errno)); return false; - } else if (numSent != sizeof(dhdr)) { - LOGGER_WARN(_logger, "conn_id: {0} Failed to send DISCONNECT message, sent: {1}", conn_id, numSent); + } else if (num_sent != sizeof(dhdr)) { + LOGGER_WARN(logger_, "conn_id: {0} Failed to send DISCONNECT message, sent: {1}", conn_id, num_sent); return false; } return true; } -bool UDPTransport::send_keepalive(ConnectionContext& conn) { - UdpProtocol::KeepaliveMsg khdr {}; +bool UDPTransport::SendKeepalive(ConnectionContext& conn) { + udp_protocol::KeepaliveMsg khdr {}; - const auto current_tick = _tick_service->get_ticks(std::chrono::milliseconds(1)); + const auto current_tick = tick_service_->GetTicks(std::chrono::milliseconds(1)); khdr.ticks_ms = current_tick - conn.tx_next_report_tick; - LOGGER_DEBUG(_logger, "conn_id: {0} send KEEPALIVE", conn.id); + LOGGER_DEBUG(logger_, "conn_id: {0} send KEEPALIVE", conn.id); - int numSent = sendto(_fd, + int num_sent = sendto(fd_, (uint8_t *)&khdr, sizeof(khdr), 0 /*flags*/, @@ -377,21 +377,21 @@ bool UDPTransport::send_keepalive(ConnectionContext& conn) { conn.addr.addr_len); - if (numSent < 0) { - LOGGER_ERROR(_logger, "conn_id: {0} Error sending KEEPALIVE to UDP socket: {1}", conn.id, strerror(errno)); + if (num_sent < 0) { + LOGGER_ERROR(logger_, "conn_id: {0} Error sending KEEPALIVE to UDP socket: {1}", conn.id, strerror(errno)); return false; - } else if (numSent != sizeof(khdr)) { - LOGGER_WARN(_logger, "conn_id: {0} Failed to send KEEPALIVE message, sent: {1}", conn.id, numSent); + } else if (num_sent != sizeof(khdr)) { + LOGGER_WARN(logger_, "conn_id: {0} Failed to send KEEPALIVE message, sent: {1}", conn.id, num_sent); return false; } return true; } -bool UDPTransport::send_report(ConnectionContext& conn) { - int numSent = sendto(_fd, +bool UDPTransport::SendReport(ConnectionContext& conn) { + int num_sent = sendto(fd_, (uint8_t *)&conn.report, sizeof(conn.report), 0 /*flags*/, @@ -399,13 +399,13 @@ bool UDPTransport::send_report(ConnectionContext& conn) { conn.addr.addr_len); - if (numSent < 0) { - LOGGER_ERROR(_logger, "conn_id: {0} Error sending REPORT to UDP socket: {1}", conn.id, strerror(errno)); + if (num_sent < 0) { + LOGGER_ERROR(logger_, "conn_id: {0} Error sending REPORT to UDP socket: {1}", conn.id, strerror(errno)); return false; - } else if (numSent != sizeof(conn.report)) { - LOGGER_WARN(_logger, "conn_id: {0} Failed to send REPORT message, sent: {1}", conn.id, numSent); + } else if (num_sent != sizeof(conn.report)) { + LOGGER_WARN(logger_, "conn_id: {0} Failed to send REPORT message, sent: {1}", conn.id, num_sent); return false; } @@ -417,15 +417,15 @@ bool UDPTransport::send_report(ConnectionContext& conn) { } -bool UDPTransport::send_data(ConnectionContext& conn, DataContext& data_ctx, const ConnData& cd, bool discard) { - UdpProtocol::DataMsg dhdr {}; - uint8_t data[UDP_MAX_PACKET_SIZE] {0}; +bool UDPTransport::SendData(ConnectionContext& conn, DataContext& data_ctx, const ConnData& cd, bool discard) { + udp_protocol::DataMsg dhdr {}; + uint8_t data[kUdpMaxPacketSize] {0}; if (discard) { dhdr.flags.discard = 1; } - const auto current_tick = _tick_service->get_ticks(std::chrono::milliseconds(1)); + const auto current_tick = tick_service_->GetTicks(std::chrono::milliseconds(1)); if (current_tick >= conn.tx_next_report_tick) { // New report ID @@ -443,10 +443,10 @@ bool UDPTransport::send_data(ConnectionContext& conn, DataContext& data_ctx, con dhdr.ticks_ms = current_tick - conn.tx_report_start_tick; auto data_len = sizeof(dhdr) + cd.data.size(); - data_len += discard ? 1 : data_ctx.remote_data_ctx_id_V.size(); + data_len += discard ? 1 : data_ctx.remote_data_ctx_id_v.size(); if (data_len > sizeof(data)) { - LOGGER_ERROR(_logger, "conn_id: {0} data_len: {1} is too large", conn.id, data_len); + LOGGER_ERROR(logger_, "conn_id: {0} data_len: {1} is too large", conn.id, data_len); return false; } @@ -459,31 +459,31 @@ bool UDPTransport::send_data(ConnectionContext& conn, DataContext& data_ctx, con uint8_t zero = 0; conn.metrics.tx_discard_objects++; - LOGGER_DEBUG(_logger, "Sending discard data size: {0}", cd.data.size()); + LOGGER_DEBUG(logger_, "Sending discard data size: {0}", cd.data.size()); memcpy(data_p, &zero, 1); data_p++; } else { - memcpy(data_p, data_ctx.remote_data_ctx_id_V.data(), data_ctx.remote_data_ctx_id_V.size()); - data_p += data_ctx.remote_data_ctx_id_V.size(); + memcpy(data_p, data_ctx.remote_data_ctx_id_v.data(), data_ctx.remote_data_ctx_id_v.size()); + data_p += data_ctx.remote_data_ctx_id_v.size(); } memcpy(data_p, cd.data.data(), cd.data.size()); - int numSent = sendto(_fd, + int num_sent = sendto(fd_, data, data_len, 0 /*flags*/, (struct sockaddr *) &conn.addr.addr, conn.addr.addr_len); - if (numSent < 0) { - LOGGER_ERROR(_logger, "conn_id: {0} Error sending DATA to UDP socket: {1}", conn.id, strerror(errno)); + if (num_sent < 0) { + LOGGER_ERROR(logger_, "conn_id: {0} Error sending DATA to UDP socket: {1}", conn.id, strerror(errno)); return false; - } else if (numSent != data_len) { - LOGGER_WARN(_logger, "conn_id: {0} Failed to send DATA len: {1}, sent: {2}", conn.id, data_len, numSent); + } else if (num_sent != data_len) { + LOGGER_WARN(logger_, "conn_id: {0} Failed to send DATA len: {1}, sent: {2}", conn.id, data_len, num_sent); return false; } @@ -503,32 +503,32 @@ bool UDPTransport::send_data(ConnectionContext& conn, DataContext& data_ctx, con * Writer will perform the following: * - loop reads data from fd_write_queue and writes it to the socket */ -void UDPTransport::fd_writer() { +void UDPTransport::FdWriter() { timeval to; // NOLINT (include). to.tv_usec = 1000; to.tv_sec = 0; - LOGGER_INFO(_logger, "Starting transport writer thread"); + LOGGER_INFO(logger_, "Starting transport writer thread"); bool sent_data = false; int all_empty_count = 0; - std::unique_lock lock(_writer_mutex); + std::unique_lock lock(writer_mutex_); - while (not _stop) { + while (not stop_) { sent_data = false; bool unlock = true; // Check each connection context for data to send - for (const auto& [conn_id, conn]: _conn_contexts) { - const auto current_tick = _tick_service->get_ticks(std::chrono::milliseconds (1)); + for (const auto& [conn_id, conn]: conn_contexts_) { + const auto current_tick = tick_service_->GetTicks(std::chrono::milliseconds (1)); // Check if idle if (conn->last_rx_msg_tick && current_tick - conn->last_rx_msg_tick >= conn->idle_timeout_ms) { - LOGGER_ERROR(_logger, "conn_id: {0} TIME OUT, disconnecting connection", conn_id); + LOGGER_ERROR(logger_, "conn_id: {0} TIME OUT, disconnecting connection", conn_id); unlock = false; lock.unlock(); - close(conn_id); + Close(conn_id); break; // Don't continue with for loop since iterator will be invalidated upon close } @@ -537,22 +537,22 @@ void UDPTransport::fd_writer() { continue; } - if (conn->tx_data->empty()) { // No data, go to next connection + if (conn->tx_data->Empty()) { // No data, go to next connection // Send keepalive if needed if (conn->last_tx_msg_tick && current_tick - conn->last_tx_msg_tick > conn->ka_interval_ms) { conn->last_tx_msg_tick = current_tick; - send_keepalive(*conn); + SendKeepalive(*conn); } continue; } - auto cd = conn->tx_data->pop_front(); + auto cd = conn->tx_data->PopFront(); if (!cd.has_value) { // Send keepalive if needed if (conn->last_tx_msg_tick && current_tick - conn->last_tx_msg_tick > conn->ka_interval_ms) { conn->last_tx_msg_tick = current_tick; - send_keepalive(*conn); + SendKeepalive(*conn); } sent_data = true; // Don't treat this as data not sent, which causes a pause @@ -561,7 +561,7 @@ void UDPTransport::fd_writer() { const auto data_ctx_it = conn->data_contexts.find(cd.value.data_ctx_id); if (data_ctx_it == conn->data_contexts.end()) { - LOGGER_WARN(_logger, "No data context, ignoring conn_id: {0} data_ctx_id: {1}", conn_id, cd.value.data_ctx_id); + LOGGER_WARN(logger_, "No data context, ignoring conn_id: {0} data_ctx_id: {1}", conn_id, cd.value.data_ctx_id); conn->metrics.tx_no_context++; continue; } @@ -581,10 +581,10 @@ void UDPTransport::fd_writer() { log_msg << " total_duration: " << cd.value.trace.back().delta; - LOGGER_INFO(_logger, log_msg.str()); + LOGGER_INFO(logger_, log_msg.str()); } - if (! send_data(*conn, data_ctx_it->second, cd.value, (cd.value.priority ? false : true))) { + if (! SendData(*conn, data_ctx_it->second, cd.value, (cd.value.priority ? false : true))) { continue; } @@ -621,7 +621,7 @@ void UDPTransport::fd_writer() { lock.lock(); } - LOGGER_INFO(_logger, "Done transport writer thread"); + LOGGER_INFO(logger_, "Done transport writer thread"); } /* @@ -638,108 +638,108 @@ void UDPTransport::fd_writer() { * StreamId */ void -UDPTransport::fd_reader() { - LOGGER_INFO(_logger, "Starting transport reader thread"); +UDPTransport::FdReader() { + LOGGER_INFO(logger_, "Starting transport reader thread"); #if defined(PLATFORM_ESP) // TODO (Suhas): Revisit this once we have basic esp functionality working const int dataSize = 2048; #else - const int dataSize = UDP_MAX_PACKET_SIZE; // TODO Add config var to set this value. Sizes + const int data_size = kUdpMaxPacketSize; // TODO Add config var to set this value. Sizes // larger than actual MTU require IP frags #endif - uint8_t data[dataSize]; + uint8_t data[data_size]; - std::unique_lock lock(_reader_mutex); + std::unique_lock lock(reader_mutex_); lock.unlock(); // Will lock later in while loop - while (not _stop) { + while (not stop_) { Addr remote_addr; - int rLen = recvfrom(_fd, + int r_len = recvfrom(fd_, data, - dataSize, + data_size, 0 /*flags*/, (struct sockaddr *) &remote_addr.addr, &remote_addr.addr_len); - if (rLen < 0 || _stop) { - if ((errno == EAGAIN) || (_stop)) { + if (r_len < 0 || stop_) { + if ((errno == EAGAIN) || (stop_)) { // timeout on read or stop issued continue; } else { - LOGGER_ERROR(_logger, "Error reading from UDP socket: {0}", strerror(errno)); + LOGGER_ERROR(logger_, "Error reading from UDP socket: {0}", strerror(errno)); break; } } - if (rLen == 0) { + if (r_len == 0) { continue; } - if (data[0] != UdpProtocol::PROTOCOL_VERSION) { + if (data[0] != udp_protocol::kProtocolVersion) { // TODO: Add metrics to track discards on invalid received message continue; } - const auto current_tick = _tick_service->get_ticks(std::chrono::milliseconds(1)); + const auto current_tick = tick_service_->GetTicks(std::chrono::milliseconds(1)); - remote_addr.id = create_addr_id(remote_addr.addr); + remote_addr.id = CreateAddrId(remote_addr.addr); lock.lock(); - const auto a_conn_it = _addr_conn_contexts.find(remote_addr.id); + const auto a_conn_it = addr_conn_contexts_.find(remote_addr.id); - switch (static_cast(data[1])) { // Process based on type of message - case UdpProtocol::ProtocolType::CONNECT: { - UdpProtocol::ConnectMsg chdr; + switch (static_cast(data[1])) { // Process based on type of message + case udp_protocol::ProtocolType::kConnect: { + udp_protocol::ConnectMsg chdr; memcpy(&chdr, data, sizeof(chdr)); if (chdr.idle_timeout == 0) { // TODO: Add metric for invalid idle_timeout - LOGGER_DEBUG(_logger, "Invalid zero idle timeout for new connection, ignoring"); + LOGGER_DEBUG(logger_, "Invalid zero idle timeout for new connection, ignoring"); lock.unlock(); continue; } - if (a_conn_it == _addr_conn_contexts.end()) { // New connection - if (_isServerMode) { - ++_last_conn_id; + if (a_conn_it == addr_conn_contexts_.end()) { // New connection + if (isServerMode_) { + ++last_conn_id_; - send_connect_ok(_last_conn_id, remote_addr); + SendConnectOk(last_conn_id_, remote_addr); - const auto [conn_it, _] = _conn_contexts.emplace(_last_conn_id, + const auto [conn_it, _] = conn_contexts_.emplace(last_conn_id_, std::make_shared()); auto &conn = *conn_it->second; - conn.tx_data = std::make_unique>(_tconfig.time_queue_max_duration, - _tconfig.time_queue_bucket_interval, - _tick_service, - _tconfig.time_queue_init_queue_size); + conn.tx_data = std::make_unique>(tconfig_.time_queue_max_duration, + tconfig_.time_queue_bucket_interval, + tick_service_, + tconfig_.time_queue_init_queue_size); conn.addr = remote_addr; - conn.id = _last_conn_id; + conn.id = last_conn_id_; - conn.tx_report_interval_ms = _tconfig.time_queue_rx_size; // TODO: this temp to set this via UI + conn.tx_report_interval_ms = tconfig_.time_queue_rx_size; // TODO: this temp to set this via UI - conn.last_rx_msg_tick = _tick_service->get_ticks(std::chrono::milliseconds(1)); + conn.last_rx_msg_tick = tick_service_->GetTicks(std::chrono::milliseconds(1)); conn.idle_timeout_ms = chdr.idle_timeout * 1000; conn.ka_interval_ms = conn.idle_timeout_ms / 3; // TODO: Consider adding BW in connect message to convey what the receiver would like to receive - conn.set_KBps(6250); // Set to 50Mbps connection rate + conn.SetKBps(6250); // Set to 50Mbps connection rate - _addr_conn_contexts.emplace(remote_addr.id, conn_it->second); // Add to the addr lookup map + addr_conn_contexts_.emplace(remote_addr.id, conn_it->second); // Add to the addr lookup map lock.unlock(); // no need to hold lock, especially with a call to a delegate - createDataContext(conn.id, false, 2, false); + CreateDataContext(conn.id, false, 2, false); // New remote address/connection - const TransportRemote remote = create_addr_remote(remote_addr.addr); + const TransportRemote remote = CreateAddrRemote(remote_addr.addr); - LOGGER_INFO(_logger, "New Connection from {0} port: {1}", remote.host_or_ip, remote.port); + LOGGER_INFO(logger_, "New Connection from {0} port: {1}", remote.host_or_ip, remote.port); // Notify caller that there is a new connection - _delegate.on_new_connection(_last_conn_id, remote); + delegate_.OnNewConnection(last_conn_id_, remote); continue; } else { @@ -759,51 +759,51 @@ UDPTransport::fd_reader() { } break; } - case UdpProtocol::ProtocolType::CONNECT_OK: { - if (!_isServerMode) { - _clientStatus = TransportStatus::Ready; + case udp_protocol::ProtocolType::kConnectOk: { + if (!isServerMode_) { + clientStatus_ = TransportStatus::kReady; } - if (a_conn_it != _addr_conn_contexts.end()) { - LOGGER_INFO(_logger, "conn_id: {0} received CONNECT_OK", a_conn_it->second->id); + if (a_conn_it != addr_conn_contexts_.end()) { + LOGGER_INFO(logger_, "conn_id: {0} received CONNECT_OK", a_conn_it->second->id); - a_conn_it->second->status = TransportStatus::Ready; + a_conn_it->second->status = TransportStatus::kReady; } break; } - case UdpProtocol::ProtocolType::DISCONNECT: { - if (!_isServerMode) { - _clientStatus = TransportStatus::Disconnected; + case udp_protocol::ProtocolType::kDisconnect: { + if (!isServerMode_) { + clientStatus_ = TransportStatus::kDisconnected; } - if (a_conn_it != _addr_conn_contexts.end()) { - LOGGER_INFO(_logger, "conn_id: {0} received DISCONNECT", a_conn_it->second->id); + if (a_conn_it != addr_conn_contexts_.end()) { + LOGGER_INFO(logger_, "conn_id: {0} received DISCONNECT", a_conn_it->second->id); - a_conn_it->second->status = TransportStatus::Disconnected; + a_conn_it->second->status = TransportStatus::kDisconnected; lock.unlock(); const auto conn_id = a_conn_it->second->id; - close(conn_id); + Close(conn_id); continue; } break; } - case UdpProtocol::ProtocolType::KEEPALIVE: { - if (a_conn_it != _addr_conn_contexts.end()) { - a_conn_it->second->last_rx_msg_tick = _tick_service->get_ticks(std::chrono::milliseconds(1)); + case udp_protocol::ProtocolType::kKeepalive: { + if (a_conn_it != addr_conn_contexts_.end()) { + a_conn_it->second->last_rx_msg_tick = tick_service_->GetTicks(std::chrono::milliseconds(1)); - UdpProtocol::KeepaliveMsg hdr; + udp_protocol::KeepaliveMsg hdr; memcpy(&hdr, data, sizeof(hdr)); a_conn_it->second->last_rx_hdr_tick = hdr.ticks_ms; } break; } - case UdpProtocol::ProtocolType::REPORT: { - if (a_conn_it != _addr_conn_contexts.end()) { - a_conn_it->second->last_rx_msg_tick = _tick_service->get_ticks(std::chrono::milliseconds(1)); + case udp_protocol::ProtocolType::kReport: { + if (a_conn_it != addr_conn_contexts_.end()) { + a_conn_it->second->last_rx_msg_tick = tick_service_->GetTicks(std::chrono::milliseconds(1)); - UdpProtocol::ReportMessage hdr; + udp_protocol::ReportMessage hdr; memcpy(&hdr, data, sizeof(hdr)); const auto& report_id = hdr.report_id; @@ -817,7 +817,7 @@ UDPTransport::fd_reader() { const auto& prev_report = a_conn_it->second->tx_prev_reports[(hdr.report_id % a_conn_it->second->tx_prev_reports.size())]; if (prev_report.report_id != hdr.report_id) { LOGGER_WARN( - _logger, + logger_, "Received report id: {0} is not previous id: {1} sizeof array: {2} prev_index: {3}", report_id, prev_report.report_id, @@ -827,15 +827,15 @@ UDPTransport::fd_reader() { continue; } - const auto send_KBps = static_cast(prev_report.metrics.total_bytes / prev_report.metrics.duration_ms); + const auto send_k_bps = static_cast(prev_report.metrics.total_bytes / prev_report.metrics.duration_ms); //const auto ack_KBps = static_cast(metrics.total_bytes / metrics.duration_ms); - const auto ack_KBps = static_cast(metrics.total_bytes / metrics.duration_ms); //std::max(prev_report.metrics.duration_ms, metrics.duration_ms)); - const auto prev_KBps = (a_conn_it->second->bytes_per_us * 1'000'000 / 1024); + const auto ack_k_bps = static_cast(metrics.total_bytes / metrics.duration_ms); //std::max(prev_report.metrics.duration_ms, metrics.duration_ms)); + const auto prev_k_bps = (a_conn_it->second->bytes_per_us * 1'000'000 / 1024); const auto loss_pct = 1.0 - static_cast(metrics.total_packets) / prev_report.metrics.total_packets; a_conn_it->second->tx_report_ott = metrics.recv_ott_ms; if (loss_pct >= 0.01 && metrics.total_packets > 10) { - LOGGER_INFO(_logger, + LOGGER_INFO(logger_, "Received REPORT (decrease) conn_id: {0} tx_report_id: {1} duration_ms: {2} " "({3}) total_bytes: {4} ({5}) total_packets: {6} ({7}) send/ack Kbps: {8} / " "{9} prev_Kbps: {10} Loss: {11}% TX-OTT: {12}ms RX-OTT: {13}ms", @@ -847,25 +847,25 @@ UDPTransport::fd_reader() { prev_report.metrics.total_bytes, metrics.total_packets, prev_report.metrics.total_packets, - send_KBps * 8, - ack_KBps * 8, - prev_KBps * 8, + send_k_bps * 8, + ack_k_bps * 8, + prev_k_bps * 8, loss_pct, metrics.recv_ott_ms, a_conn_it->second->rx_report_ott); a_conn_it->second->tx_zero_loss_count = 0; - a_conn_it->second->set_KBps(ack_KBps * .95); + a_conn_it->second->SetKBps(ack_k_bps * .95); } else if (metrics.total_packets > 10 && loss_pct == 0) { a_conn_it->second->tx_zero_loss_count++; // Only increase bandwidth if there is no loss for a little while if (a_conn_it->second->tx_zero_loss_count > 5 - && a_conn_it->second->set_KBps(ack_KBps * 1.03, true)) { + && a_conn_it->second->SetKBps(ack_k_bps * 1.03, true)) { LOGGER_INFO( - _logger, + logger_, "Received REPORT (increase) conn_id: {0} prev_report_id: {1} tx_report_id: {2} " "duration_ms: {3} " "({4}) total_bytes: {5} ({6}) total_packets: {7} ({8}) send/ack Kbps: {9} / " @@ -879,9 +879,9 @@ UDPTransport::fd_reader() { prev_report.metrics.total_bytes, metrics.total_packets, prev_report.metrics.total_packets, - send_KBps * 8, - ack_KBps * 8, - prev_KBps * 8, + send_k_bps * 8, + ack_k_bps * 8, + prev_k_bps * 8, loss_pct, metrics.recv_ott_ms, a_conn_it->second->rx_report_ott); @@ -899,7 +899,7 @@ UDPTransport::fd_reader() { for (int i=0; i < send_count; i++) { ConnData cd { a_conn_it->second->id, 0, 0, discard_data, trace}; - a_conn_it->second->tx_data->push(cd, 6, 0, 0); + a_conn_it->second->tx_data->Push(cd, 6, 0, 0); } a_conn_it->second->tx_zero_loss_count = 2; @@ -909,23 +909,23 @@ UDPTransport::fd_reader() { break; } - case UdpProtocol::ProtocolType::DATA: { + case udp_protocol::ProtocolType::kData: { auto data_p = data; - UdpProtocol::DataMsg hdr; + udp_protocol::DataMsg hdr; memcpy(&hdr, data_p, sizeof(hdr)); data_p += sizeof(hdr); - rLen -= sizeof(hdr); + r_len -= sizeof(hdr); const auto& report_id = hdr.report_id; - const auto remote_data_ctx_id_len = uintV_size(*data_p); - uintV_t remote_data_ctx_V (data_p, data_p + remote_data_ctx_id_len); + const auto remote_data_ctx_id_len = UintVSize(*data_p); + UintVT remote_data_ctx_v (data_p, data_p + remote_data_ctx_id_len); data_p += remote_data_ctx_id_len; - rLen -= remote_data_ctx_id_len; + r_len -= remote_data_ctx_id_len; - const auto data_ctx_id = to_uint64(remote_data_ctx_V); + const auto data_ctx_id = ToUint64(remote_data_ctx_v); - if (a_conn_it != _addr_conn_contexts.end()) { + if (a_conn_it != addr_conn_contexts_.end()) { if (report_id != a_conn_it->second->report.report_id && (report_id > a_conn_it->second->report.report_id || report_id == 0 || a_conn_it->second->report.report_id - hdr.report_id > 1)) { @@ -936,18 +936,18 @@ UDPTransport::fd_reader() { a_conn_it->second->rx_report_ott = a_conn_it->second->report.metrics.recv_ott_ms; } - send_report(*a_conn_it->second); + SendReport(*a_conn_it->second); // Init metrics with this packet/data a_conn_it->second->report_rx_start_tick = current_tick; a_conn_it->second->report.report_id = hdr.report_id; a_conn_it->second->report.metrics.duration_ms = current_tick - a_conn_it->second->last_rx_msg_tick; - a_conn_it->second->report.metrics.total_bytes = rLen; + a_conn_it->second->report.metrics.total_bytes = r_len; a_conn_it->second->report.metrics.total_packets = 1; } else if (hdr.report_id == a_conn_it->second->report.report_id) { a_conn_it->second->report.metrics.duration_ms += current_tick - a_conn_it->second->last_rx_msg_tick; - a_conn_it->second->report.metrics.total_bytes += rLen; + a_conn_it->second->report.metrics.total_bytes += r_len; a_conn_it->second->report.metrics.total_packets++; } @@ -958,14 +958,14 @@ UDPTransport::fd_reader() { if (!hdr.flags.discard) { const auto data_ctx_it = a_conn_it->second->data_contexts.find(data_ctx_id); if (data_ctx_it == a_conn_it->second->data_contexts.end()) { - LOGGER_DEBUG(_logger, "Data context not found for RX object conn_id: {0} data_ctx_id: {1}", a_conn_it->second->id, data_ctx_id); + LOGGER_DEBUG(logger_, "Data context not found for RX object conn_id: {0} data_ctx_id: {1}", a_conn_it->second->id, data_ctx_id); a_conn_it->second->metrics.rx_no_context++; lock.unlock(); continue; } - std::vector buffer(data_p, data_p + rLen); + std::vector buffer(data_p, data_p + r_len); std::vector trace; const auto start_time = std::chrono::time_point_cast(std::chrono::steady_clock::now()); @@ -976,13 +976,13 @@ UDPTransport::fd_reader() { cd.trace.reserve(10); - data_ctx_it->second.rx_data.push(cd); + data_ctx_it->second.rx_data.Push(cd); lock.unlock(); - if ( data_ctx_it->second.rx_data.size() < 10 + if ( data_ctx_it->second.rx_data.Size() < 10 || data_ctx_it->second.in_data_cb_skip_count > 20) { - _delegate.on_recv_dgram(cd.conn_id, cd.data_ctx_id); + delegate_.OnRecvDgram(cd.conn_id, cd.data_ctx_id); } else { data_ctx_it->second.in_data_cb_skip_count++; } @@ -998,10 +998,10 @@ UDPTransport::fd_reader() { lock.unlock(); } - LOGGER_INFO(_logger, "Done transport reader thread"); + LOGGER_INFO(logger_, "Done transport reader thread"); } -TransportError UDPTransport::enqueue(const TransportConnId &conn_id, +TransportError UDPTransport::Enqueue(const TransportConnId &conn_id, const DataContextId &data_ctx_id, std::vector &&bytes, std::vector &&trace, @@ -1010,26 +1010,26 @@ TransportError UDPTransport::enqueue(const TransportConnId &conn_id, const uint32_t delay_ms, [[maybe_unused]] const EnqueueFlags flags) { if (bytes.empty()) { - return TransportError::None; + return TransportError::kNone; } trace.push_back({"transport_udp:enqueue", trace.front().start_time}); - std::lock_guard _(_writer_mutex); + std::lock_guard _(writer_mutex_); trace.push_back({"transport_udp:enqueue:afterLock", trace.front().start_time}); - const auto conn_it = _conn_contexts.find(conn_id); + const auto conn_it = conn_contexts_.find(conn_id); - if (conn_it == _conn_contexts.end()) { + if (conn_it == conn_contexts_.end()) { // Invalid connection id - return TransportError::InvalidConnContextId; + return TransportError::kInvalidConnContextId; } const auto data_ctx_it = conn_it->second->data_contexts.find(data_ctx_id); if (data_ctx_it == conn_it->second->data_contexts.end()) { // Invalid data context id - return TransportError::InvalidDataContextId; + return TransportError::kInvalidDataContextId; } data_ctx_it->second.metrics.enqueued_objs++; @@ -1041,33 +1041,33 @@ TransportError UDPTransport::enqueue(const TransportConnId &conn_id, std::move(bytes), std::move(trace)}; - conn_it->second->tx_data->push(std::move(cd), ttl_ms, priority, delay_ms); + conn_it->second->tx_data->Push(std::move(cd), ttl_ms, priority, delay_ms); - return TransportError::None; + return TransportError::kNone; } -std::optional> UDPTransport::dequeue(TransportConnId conn_id, +std::optional> UDPTransport::Dequeue(TransportConnId conn_id, std::optional data_ctx_id) { if (!data_ctx_id) return std::nullopt; - std::lock_guard _(_reader_mutex); + std::lock_guard _(reader_mutex_); - const auto conn_it = _conn_contexts.find(conn_id); - if (conn_it == _conn_contexts.end()) { - LOGGER_WARN(_logger, "dequeue: invalid conn_id: {0}", conn_id); + const auto conn_it = conn_contexts_.find(conn_id); + if (conn_it == conn_contexts_.end()) { + LOGGER_WARN(logger_, "dequeue: invalid conn_id: {0}", conn_id); // Invalid context id return std::nullopt; } const auto data_ctx_it = conn_it->second->data_contexts.find(*data_ctx_id); if (data_ctx_it == conn_it->second->data_contexts.end()) { - LOGGER_ERROR(_logger, "dequeue: invalid stream for conn_id: {0} data_ctx_id: {1}", conn_id , *data_ctx_id); + LOGGER_ERROR(logger_, "dequeue: invalid stream for conn_id: {0} data_ctx_id: {1}", conn_id , *data_ctx_id); return std::nullopt; } - if (auto cd = data_ctx_it->second.rx_data.pop()) { + if (auto cd = data_ctx_it->second.rx_data.Pop()) { cd->trace.push_back({"transport_udp:dequeue", cd->trace.front().start_time}); if (!cd->trace.empty() && cd->trace.back().delta > 1500) { @@ -1080,7 +1080,7 @@ std::optional> UDPTransport::dequeue(TransportConnId conn_i } log_msg << " total_duration: " << cd->trace.back().delta; - LOGGER_INFO(_logger, log_msg.str()); + LOGGER_INFO(logger_, log_msg.str()); } return std::move(cd.value().data); @@ -1089,13 +1089,13 @@ std::optional> UDPTransport::dequeue(TransportConnId conn_i return std::nullopt; } -TransportConnId UDPTransport::connect_client() { +TransportConnId UDPTransport::ConnectClient() { std::ostringstream s_log; - _clientStatus = TransportStatus::Connecting; + clientStatus_ = TransportStatus::kConnecting; - _fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); - if (_fd == -1) { + fd_ = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + if (fd_ == -1) { #if defined(PLATFORM_ESP) // TODO: Suhas: Figure out better API than aborting abort(); @@ -1107,32 +1107,32 @@ TransportConnId UDPTransport::connect_client() { int err = 0; #if not defined(PLATFORM_ESP) // TODO: Add config for these values - size_t snd_rcv_max = UDP_MAX_PACKET_SIZE * 16; + size_t snd_rcv_max = kUdpMaxPacketSize * 16; timeval rcv_timeout { .tv_sec = 0, .tv_usec = 1000 }; - err = setsockopt(_fd, SOL_SOCKET, SO_SNDBUF, &snd_rcv_max, sizeof(snd_rcv_max)); + err = setsockopt(fd_, SOL_SOCKET, SO_SNDBUF, &snd_rcv_max, sizeof(snd_rcv_max)); if (err != 0) { s_log << "client_connect: Unable to set send buffer size: " << strerror(errno); - LOGGER_CRITICAL(_logger, s_log.str()); + LOGGER_CRITICAL(logger_, s_log.str()); throw std::runtime_error(s_log.str()); } - snd_rcv_max = UDP_MAX_PACKET_SIZE * 16; // TODO: Add config for value - err = setsockopt(_fd, SOL_SOCKET, SO_RCVBUF, &snd_rcv_max, sizeof(snd_rcv_max)); + snd_rcv_max = kUdpMaxPacketSize * 16; // TODO: Add config for value + err = setsockopt(fd_, SOL_SOCKET, SO_RCVBUF, &snd_rcv_max, sizeof(snd_rcv_max)); if (err != 0) { s_log << "client_connect: Unable to set receive buffer size: " << strerror(errno); - LOGGER_CRITICAL(_logger, s_log.str()); + LOGGER_CRITICAL(logger_, s_log.str()); throw std::runtime_error(s_log.str()); } #endif - err = setsockopt(_fd, SOL_SOCKET, SO_RCVTIMEO, &rcv_timeout, sizeof(rcv_timeout)); + err = setsockopt(fd_, SOL_SOCKET, SO_RCVTIMEO, &rcv_timeout, sizeof(rcv_timeout)); if (err != 0) { s_log << "client_connect: Unable to set receive timeout: " << strerror(errno); - LOGGER_CRITICAL(_logger, s_log.str()); + LOGGER_CRITICAL(logger_, s_log.str()); #if not defined(PLATFORM_ESP) throw std::runtime_error(s_log.str()); #else @@ -1141,14 +1141,14 @@ int err = 0; } - struct sockaddr_in srvAddr; - srvAddr.sin_family = AF_INET; - srvAddr.sin_addr.s_addr = htonl(INADDR_ANY); // NOLINT (include). - srvAddr.sin_port = 0; - err = bind(_fd, (struct sockaddr *) &srvAddr, sizeof(srvAddr)); + struct sockaddr_in srv_addr; + srv_addr.sin_family = AF_INET; + srv_addr.sin_addr.s_addr = htonl(INADDR_ANY); // NOLINT (include). + srv_addr.sin_port = 0; + err = bind(fd_, (struct sockaddr *) &srv_addr, sizeof(srv_addr)); if (err) { s_log << "client_connect: Unable to bind to socket: " << strerror(errno); - LOGGER_CRITICAL(_logger, s_log.str()); + LOGGER_CRITICAL(logger_, s_log.str()); #if not defined(PLATFORM_ESP) throw std::runtime_error(s_log.str()); #else @@ -1156,18 +1156,18 @@ int err = 0; #endif } - std::string sPort = std::to_string(htons(_serverInfo.port)); // NOLINT (include). + std::string sPort = std::to_string(htons(serverInfo_.port)); // NOLINT (include). struct addrinfo hints = {}, *address_list = NULL; hints.ai_family = AF_INET; hints.ai_socktype = SOCK_DGRAM; hints.ai_protocol = IPPROTO_UDP; err = getaddrinfo( - _serverInfo.host_or_ip.c_str(), sPort.c_str(), &hints, &address_list); + serverInfo_.host_or_ip.c_str(), sPort.c_str(), &hints, &address_list); if (err) { strerror(1); s_log << "client_connect: Unable to resolve remote ip address: " << strerror(errno); - LOGGER_CRITICAL(_logger, s_log.str()); + LOGGER_CRITICAL(logger_, s_log.str()); #if not defined(PLATFORM_ESP) throw std::runtime_error(s_log.str()); #else @@ -1185,7 +1185,7 @@ int err = 0; } if (found_addr == nullptr) { - LOGGER_CRITICAL(_logger, "client_connect: No IP address found"); + LOGGER_CRITICAL(logger_, "client_connect: No IP address found"); #if not defined(PLATFORM_ESP) throw std::runtime_error(s_log.str()); #else @@ -1193,40 +1193,40 @@ int err = 0; #endif } - struct sockaddr_in *ipv4 = (struct sockaddr_in *) &_serverAddr.addr; + struct sockaddr_in *ipv4 = (struct sockaddr_in *) &serverAddr_.addr; memcpy(ipv4, found_addr->ai_addr, found_addr->ai_addrlen); - ipv4->sin_port = htons(_serverInfo.port); - _serverAddr.addr_len = sizeof(sockaddr_in); + ipv4->sin_port = htons(serverInfo_.port); + serverAddr_.addr_len = sizeof(sockaddr_in); freeaddrinfo(address_list); - _serverAddr.id = create_addr_id(_serverAddr.addr); + serverAddr_.id = CreateAddrId(serverAddr_.addr); - ++_last_conn_id; + ++last_conn_id_; - const auto& [conn_it, is_new] = _conn_contexts.emplace(_last_conn_id, + const auto& [conn_it, is_new] = conn_contexts_.emplace(last_conn_id_, std::make_shared()); auto &conn = *conn_it->second; - conn.addr = _serverAddr; - conn.id = _last_conn_id; - conn.tx_data = std::make_unique>(_tconfig.time_queue_max_duration, - _tconfig.time_queue_bucket_interval, - _tick_service, - _tconfig.time_queue_init_queue_size); + conn.addr = serverAddr_; + conn.id = last_conn_id_; + conn.tx_data = std::make_unique>(tconfig_.time_queue_max_duration, + tconfig_.time_queue_bucket_interval, + tick_service_, + tconfig_.time_queue_init_queue_size); - conn.tx_report_interval_ms = _tconfig.time_queue_rx_size; // TODO: this temp to set this via UI + conn.tx_report_interval_ms = tconfig_.time_queue_rx_size; // TODO: this temp to set this via UI - conn.set_KBps(2000); // Set to 16Mbps=2000KBps connection rate + conn.SetKBps(2000); // Set to 16Mbps=2000KBps connection rate - _addr_conn_contexts.emplace(_serverAddr.id, conn_it->second); // Add to the addr lookup map - createDataContext(conn.id, false, 2, false); + addr_conn_contexts_.emplace(serverAddr_.id, conn_it->second); // Add to the addr lookup map + CreateDataContext(conn.id, false, 2, false); - send_connect(conn.id, conn.addr); + SendConnect(conn.id, conn.addr); // Notify caller that the connection is now ready - _delegate.on_connection_status(_last_conn_id, TransportStatus::Ready); + delegate_.OnConnectionStatus(last_conn_id_, TransportStatus::kReady); #if defined(PLATFORM_ESP) @@ -1237,7 +1237,7 @@ int err = 0; } #endif - _running_threads.emplace_back(&UDPTransport::fd_reader, this); + running_threads_.emplace_back(&UDPTransport::FdReader, this); #if defined(PLATFORM_ESP) cfg = create_config("FDWriter", 1, 12 * 1024, 5); @@ -1247,18 +1247,18 @@ int err = 0; } #endif - _running_threads.emplace_back(&UDPTransport::fd_writer, this); + running_threads_.emplace_back(&UDPTransport::FdWriter, this); - return _last_conn_id; + return last_conn_id_; } -TransportConnId UDPTransport::connect_server() { +TransportConnId UDPTransport::ConnectServer() { std::stringstream s_log; - _fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); - if (_fd < 0) { + fd_ = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + if (fd_ < 0) { s_log << "connect_server: Unable to create socket: " << strerror(errno); - LOGGER_CRITICAL(_logger, s_log.str()); + LOGGER_CRITICAL(logger_, s_log.str()); #if not defined(PLATFORM_ESP) throw std::runtime_error(s_log.str()); #else @@ -1268,10 +1268,10 @@ TransportConnId UDPTransport::connect_server() { // set for re-use int one = 1; - int err = setsockopt(_fd, SOL_SOCKET, SO_REUSEADDR, (const char *) &one, sizeof(one)); + int err = setsockopt(fd_, SOL_SOCKET, SO_REUSEADDR, (const char *) &one, sizeof(one)); if (err != 0) { s_log << "connect_server: setsockopt error: " << strerror(errno); - LOGGER_CRITICAL(_logger, s_log.str()); + LOGGER_CRITICAL(logger_, s_log.str()); #if not defined(PLATFORM_ESP) throw std::runtime_error(s_log.str()); #else @@ -1281,14 +1281,14 @@ TransportConnId UDPTransport::connect_server() { } // TODO: Add config for this value - size_t snd_rcv_max = UDP_MAX_PACKET_SIZE * 16; + size_t snd_rcv_max = kUdpMaxPacketSize * 16; timeval rcv_timeout{.tv_sec = 0, .tv_usec = 1000}; - err = setsockopt(_fd, SOL_SOCKET, SO_SNDBUF, &snd_rcv_max, sizeof(snd_rcv_max)); + err = setsockopt(fd_, SOL_SOCKET, SO_SNDBUF, &snd_rcv_max, sizeof(snd_rcv_max)); if (err != 0) { s_log << "client_connect: Unable to set send buffer size: " << strerror(errno); - LOGGER_CRITICAL(_logger, s_log.str()); + LOGGER_CRITICAL(logger_, s_log.str()); #if not defined(PLATFORM_ESP) throw std::runtime_error(s_log.str()); #else @@ -1296,11 +1296,11 @@ TransportConnId UDPTransport::connect_server() { #endif } - err = setsockopt(_fd, SOL_SOCKET, SO_RCVBUF, &snd_rcv_max, sizeof(snd_rcv_max)); + err = setsockopt(fd_, SOL_SOCKET, SO_RCVBUF, &snd_rcv_max, sizeof(snd_rcv_max)); if (err != 0) { s_log << "client_connect: Unable to set receive buffer size: " << strerror(errno); - LOGGER_CRITICAL(_logger, s_log.str()); + LOGGER_CRITICAL(logger_, s_log.str()); #if not defined(PLATFORM_ESP) throw std::runtime_error(s_log.str()); #else @@ -1309,11 +1309,11 @@ TransportConnId UDPTransport::connect_server() { } - err = setsockopt(_fd, SOL_SOCKET, SO_RCVTIMEO, &rcv_timeout, sizeof(rcv_timeout)); + err = setsockopt(fd_, SOL_SOCKET, SO_RCVTIMEO, &rcv_timeout, sizeof(rcv_timeout)); if (err != 0) { s_log << "client_connect: Unable to set receive timeout: " << strerror(errno); - LOGGER_CRITICAL(_logger, s_log.str()); + LOGGER_CRITICAL(logger_, s_log.str()); #if not defined(PLATFORM_ESP) throw std::runtime_error(s_log.str()); #else @@ -1324,18 +1324,18 @@ TransportConnId UDPTransport::connect_server() { struct sockaddr_in srv_addr; memset((char *) &srv_addr, 0, sizeof(srv_addr)); - srv_addr.sin_port = htons(_serverInfo.port); + srv_addr.sin_port = htons(serverInfo_.port); srv_addr.sin_family = AF_INET; srv_addr.sin_addr.s_addr = htonl(INADDR_ANY); - err = bind(_fd, (struct sockaddr *) &srv_addr, sizeof(srv_addr)); + err = bind(fd_, (struct sockaddr *) &srv_addr, sizeof(srv_addr)); if (err < 0) { s_log << "connect_server: unable to bind to socket: " << strerror(errno); - LOGGER_CRITICAL(_logger, s_log.str()); + LOGGER_CRITICAL(logger_, s_log.str()); throw std::runtime_error(s_log.str()); } - LOGGER_INFO(_logger, "connect_server: port: {0} fd: {1}", _serverInfo.port, _fd); + LOGGER_INFO(logger_, "connect_server: port: {0} fd: {1}", serverInfo_.port, fd_); #if defined(PLATFORM_ESP) cfg = create_config("FDServerReader", 1, 12 * 1024, 5); @@ -1344,7 +1344,7 @@ TransportConnId UDPTransport::connect_server() { abort(); } #endif - _running_threads.emplace_back(&UDPTransport::fd_reader, this); + running_threads_.emplace_back(&UDPTransport::FdReader, this); #if defined(PLATFORM_ESP) cfg = create_config("FDServerWriter", 1, 12 * 1024, 5); @@ -1354,7 +1354,7 @@ TransportConnId UDPTransport::connect_server() { } #endif - _running_threads.emplace_back(&UDPTransport::fd_writer, this); + running_threads_.emplace_back(&UDPTransport::FdWriter, this); - return _last_conn_id; + return last_conn_id_; } diff --git a/src/transport_udp.h b/src/transport_udp.h index 74a1223..8aa7d30 100644 --- a/src/transport_udp.h +++ b/src/transport_udp.h @@ -24,8 +24,8 @@ #include "transport/transport_metrics.h" namespace qtransport { - constexpr size_t UDP_MAX_PACKET_SIZE = 64000; - constexpr size_t UDP_MIN_KBPS = 62; /// Minimum KB bytes per second 62 = 500Kbps + constexpr size_t kUdpMaxPacketSize = 64000; + constexpr size_t kUdpMinKbps = 62; /// Minimum KB bytes per second 62 = 500Kbps struct AddrId { uint64_t ip_hi; @@ -52,28 +52,28 @@ namespace qtransport { UDPTransport(const TransportRemote &server, const TransportConfig &tcfg, TransportDelegate &delegate, - bool isServerMode, + bool is_server_mode, std::shared_ptr logger); virtual ~UDPTransport(); - TransportStatus status() const override; + TransportStatus Status() const override; - TransportConnId start(std::shared_ptr> metrics_conn_samples, + TransportConnId Start(std::shared_ptr> metrics_conn_samples, std::shared_ptr> metrics_data_samples) override; - void close(const TransportConnId &conn_id, uint64_t app_reason_code=0) override; + void Close(const TransportConnId &conn_id, uint64_t app_reason_code=0) override; - virtual bool getPeerAddrInfo(const TransportConnId &conn_id, + virtual bool GetPeerAddrInfo(const TransportConnId &conn_id, sockaddr_storage *addr) override; - DataContextId createDataContext(TransportConnId conn_id, + DataContextId CreateDataContext(TransportConnId conn_id, bool use_reliable_transport, uint8_t priority, bool bidir) override; - void deleteDataContext(const TransportConnId &conn_id, DataContextId data_ctx_id) override; + void DeleteDataContext(const TransportConnId &conn_id, DataContextId data_ctx_id) override; - TransportError enqueue(const TransportConnId &conn_id, + TransportError Enqueue(const TransportConnId &conn_id, const DataContextId &data_ctx_id, std::vector &&bytes, std::vector &&trace, @@ -82,38 +82,38 @@ namespace qtransport { uint32_t delay_ms, EnqueueFlags flags) override; - std::optional> dequeue(TransportConnId conn_id, + std::optional> Dequeue(TransportConnId conn_id, std::optional data_ctx_id) override; - std::shared_ptr> getStreamBuffer(TransportConnId conn_id, uint64_t stream_id) override { return nullptr;} + std::shared_ptr> GetStreamBuffer(TransportConnId conn_id, uint64_t stream_id) override { return nullptr;} - void setRemoteDataCtxId(TransportConnId conn_id, + void SetRemoteDataCtxId(TransportConnId conn_id, DataContextId data_ctx_id, DataContextId remote_data_ctx_id) override; - void setStreamIdDataCtxId([[maybe_unused]] const TransportConnId conn_id, + void SetStreamIdDataCtxId([[maybe_unused]] const TransportConnId conn_id, [[maybe_unused]] DataContextId data_ctx_id, [[maybe_unused]] uint64_t stream_id) override {} - void setDataCtxPriority([[maybe_unused]] const TransportConnId conn_id, + void SetDataCtxPriority([[maybe_unused]] const TransportConnId conn_id, [[maybe_unused]] DataContextId data_ctx_id, [[maybe_unused]] uint8_t priority) override {} private: - TransportConnId connect_client(); - TransportConnId connect_server(); + TransportConnId ConnectClient(); + TransportConnId ConnectServer(); - TransportRemote create_addr_remote(const sockaddr_storage& addr); - AddrId create_addr_id(const sockaddr_storage& addr); + TransportRemote CreateAddrRemote(const sockaddr_storage& addr); + AddrId CreateAddrId(const sockaddr_storage& addr); /* Threads */ - void fd_reader(); - void fd_writer(); + void FdReader(); + void FdWriter(); - std::atomic _stop; - std::vector _running_threads; + std::atomic stop_; + std::vector running_threads_; struct Addr { socklen_t addr_len; @@ -131,7 +131,7 @@ namespace qtransport { uint8_t priority {10}; DataContextId remote_data_ctx_id {0}; /// Remote data context ID to use for this context - uintV_t remote_data_ctx_id_V {0}; /// Remote data context ID as variable length integer + UintVT remote_data_ctx_id_v {0}; /// Remote data context ID as variable length integer UdpDataContextMetrics metrics; @@ -148,7 +148,7 @@ namespace qtransport { UdpConnectionMetrics metrics; - TransportStatus status { TransportStatus::Disconnected }; + TransportStatus status { TransportStatus::kDisconnected }; std::unique_ptr> tx_data; // TX priority queue uint64_t last_rx_msg_tick { 0 }; /// Tick value (ms) when last message was received @@ -174,11 +174,11 @@ namespace qtransport { uint64_t tx_report_start_tick { 0 }; // Tick value on report change (new report interval) uint64_t tx_next_report_tick {0}; // Tick value to start a new report ID - UdpProtocol::ReportMessage report; // Report to be sent back to sender upon received tx_report_id change + udp_protocol::ReportMessage report; // Report to be sent back to sender upon received tx_report_id change uint64_t report_rx_start_tick { 0 }; // Tick value at start of the RX report interval - UdpProtocol::ReportMetrics tx_report_metrics; - std::array tx_prev_reports; + udp_protocol::ReportMetrics tx_report_metrics; + std::array tx_prev_reports; /* * Shaping variables @@ -188,12 +188,12 @@ namespace qtransport { double bytes_per_us {6.4}; // Default to 50Mbps - bool set_KBps(uint32_t KBps, bool max_of= false) { - if (KBps < UDP_MIN_KBPS) return false; + bool SetKBps(uint32_t k_bps, bool max_of= false) { + if (k_bps < kUdpMinKbps) return false; - const auto bpUs = (KBps * 1024) / 1'000'000.0 /* 1 second double value */; - if (!max_of || bpUs > bytes_per_us) { - bytes_per_us = bpUs; + const auto bp_us = (k_bps * 1024) / 1'000'000.0 /* 1 second double value */; + if (!max_of || bp_us > bytes_per_us) { + bytes_per_us = bp_us; return true; } @@ -210,7 +210,7 @@ namespace qtransport { * * @return True if sent, false if not sent/error */ - bool send_connect(TransportConnId conn_id, const Addr& addr); + bool SendConnect(TransportConnId conn_id, const Addr& addr); /** * @brief Send UDP protocol connect OK message @@ -220,7 +220,7 @@ namespace qtransport { * * @return True if sent, false if not sent/error */ - bool send_connect_ok(TransportConnId conn_id, const Addr& addr); + bool SendConnectOk(TransportConnId conn_id, const Addr& addr); /** * @brief Send UDP protocol disconnect message @@ -230,7 +230,7 @@ namespace qtransport { * * @return True if sent, false if not sent/error */ - bool send_disconnect(TransportConnId conn_id, const Addr& addr); + bool SendDisconnect(TransportConnId conn_id, const Addr& addr); /** * @brief Send UDP protocol keepalive message @@ -239,7 +239,7 @@ namespace qtransport { * * @return True if sent, false if not sent/error */ - bool send_keepalive(ConnectionContext& conn); + bool SendKeepalive(ConnectionContext& conn); /** * @brief Send UDP protocol data message @@ -253,7 +253,7 @@ namespace qtransport { * * @return True if sent, false if not sent/error */ - bool send_data(ConnectionContext& conn, DataContext& data_ctx, const ConnData& cd, bool discard=false); + bool SendData(ConnectionContext& conn, DataContext& data_ctx, const ConnData& cd, bool discard=false); /** * @brief Send UDP protocol report message @@ -264,27 +264,27 @@ namespace qtransport { * * @return True if sent, false if not sent/error */ - bool send_report(ConnectionContext& conn); + bool SendReport(ConnectionContext& conn); - std::shared_ptr _logger; - int _fd; // UDP socket - bool _isServerMode; + std::shared_ptr logger_; + int fd_; // UDP socket + bool isServerMode_; - std::atomic _clientStatus {TransportStatus::Disconnected }; + std::atomic clientStatus_ {TransportStatus::kDisconnected }; - TransportRemote _serverInfo; - Addr _serverAddr; - TransportConfig _tconfig; + TransportRemote serverInfo_; + Addr serverAddr_; + TransportConfig tconfig_; - TransportDelegate &_delegate; - std::mutex _writer_mutex; /// Mutex for writer - std::mutex _reader_mutex; /// Mutex for reader + TransportDelegate &delegate_; + std::mutex writer_mutex_; /// Mutex for writer + std::mutex reader_mutex_; /// Mutex for reader - TransportConnId _last_conn_id{0}; - std::map> _conn_contexts; - std::map> _addr_conn_contexts; + TransportConnId last_conn_id_{0}; + std::map> conn_contexts_; + std::map> addr_conn_contexts_; - std::shared_ptr _tick_service; + std::shared_ptr tick_service_; }; } // namespace qtransport diff --git a/src/transport_udp_protocol.h b/src/transport_udp_protocol.h index 5373d5d..8c1ea42 100644 --- a/src/transport_udp_protocol.h +++ b/src/transport_udp_protocol.h @@ -13,25 +13,25 @@ */ namespace qtransport { - namespace UdpProtocol { + namespace udp_protocol { /* ------------------------------------------------------------------------ * Wire messages * ------------------------------------------------------------------------ */ - constexpr uint8_t PROTOCOL_VERSION = 1; + constexpr uint8_t kProtocolVersion = 1; /** * @brief UDP Protocol Types * @details Each UDP packet is encoded with a common header, which includes a type. */ enum class ProtocolType : uint8_t { - CONNECT = 0, - CONNECT_OK = 1, - DISCONNECT = 2, - REPORT = 3, - KEEPALIVE = 4, + kConnect = 0, + kConnectOk = 1, + kDisconnect = 2, + kReport = 3, + kKeepalive = 4, - DATA = 10, + kData = 10, }; /** @@ -39,7 +39,7 @@ namespace qtransport { * @brief Every UDP packet starts with this common header. The data that follows is defined by the type */ struct CommonHeader { - uint8_t version {PROTOCOL_VERSION}; /// Protocol version + uint8_t version {kProtocolVersion}; /// Protocol version ProtocolType type; /// Indicates this is a peering message }; @@ -50,7 +50,7 @@ namespace qtransport { * until the new connection sends a connect message. */ struct ConnectMsg : CommonHeader { - ConnectMsg() { type = ProtocolType::CONNECT; } + ConnectMsg() { type = ProtocolType::kConnect; } uint16_t idle_timeout { 120 }; /// Idle timeout in seconds. Must not be zero @@ -60,7 +60,7 @@ namespace qtransport { * @brief Connect OK Message */ struct ConnectOkMsg : CommonHeader { - ConnectOkMsg() { type = ProtocolType::CONNECT_OK; } + ConnectOkMsg() { type = ProtocolType::kConnectOk; } } __attribute__((__packed__, aligned(1))); /** @@ -69,7 +69,7 @@ namespace qtransport { * @details Disconnect notification. Remote will immediately purge/close the active connection */ struct DisconnectMsg : CommonHeader { - DisconnectMsg() { type = ProtocolType::DISCONNECT; } + DisconnectMsg() { type = ProtocolType::kDisconnect; } } __attribute__((__packed__, aligned(1))); /** @@ -78,7 +78,7 @@ namespace qtransport { * @details Keepalive message. Sent only when no other messages have been sent in idle_timeout / 3. */ struct KeepaliveMsg : CommonHeader { - KeepaliveMsg() { type = ProtocolType::KEEPALIVE; } + KeepaliveMsg() { type = ProtocolType::kKeepalive; } uint16_t ticks_ms { 0 }; /// Senders Tick millisecond value from start of report period, reset to zero on new report @@ -92,7 +92,7 @@ namespace qtransport { * @note Can be either type of DATA */ struct DataMsg : CommonHeader { - DataMsg() { type = ProtocolType::DATA; } + DataMsg() { type = ProtocolType::kData; } struct { #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ @@ -132,7 +132,7 @@ namespace qtransport { * @details Report message. The remote will send a report message upon */ struct ReportMessage : CommonHeader { - ReportMessage() { type = ProtocolType::REPORT; } + ReportMessage() { type = ProtocolType::kReport; } uint16_t report_id { 0 }; /// Report ID of this report ReportMetrics metrics; From 070eb85e9a131b5dad62d58f52612d54826d7333 Mon Sep 17 00:00:00 2001 From: Rich Logan Date: Mon, 26 Aug 2024 10:25:03 -0500 Subject: [PATCH 2/2] Ignore rename diff --- .git-blame-ignore-revs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs index bd7868b..2737015 100644 --- a/.git-blame-ignore-revs +++ b/.git-blame-ignore-revs @@ -1,3 +1,2 @@ # Rename -d67b913f5a8cf5c5a869c70862b857f4f99093bd -38cd7b58bfb93ea996f5ca348ea903f0c5463a8b +b42d453d603e54e395efe9b537f9687cc33b4315