UPD | stopping mechanism

xiadnoring · xiadnoring · commit 34a492fd36f2 · 2025-08-29T17:27:15.000+05:00
diff --git a/.gitignore b/.gitignore
@@ -1,5 +1,6 @@
 cmake-build-debug
 cmake-build-release
+cmake-build-exe
 examples/CMakeFiles
 examples/CMakeCache.txt
 examples/cmake_install.cmake
diff --git a/include/http/ManapiHttpConfig.hpp b/include/http/ManapiHttpConfig.hpp
@@ -100,9 +100,6 @@ namespace manapi::net::http {
          */
         static manapi::error::status_or<http::versions::http> parse_http_version (std::string_view version) MANAPIHTTP_NOEXCEPT;
 
-        // settings
-        int max_working_streams;
-
         /**
          * For Http/2 and QUIC
          * Max concurrent streams by the connection
@@ -259,6 +256,14 @@ namespace manapi::net::http {
          * Sets the minimum limit rate every 'speed_check_delay' seconds
          */
         ssize_t speed_check_bytes;
+        /**
+         * Sets the speed check delay interval
+         */
+        ssize_t speed_stream_check_delay;
+        /**
+         * Sets the minimum limit rate every 'speed_check_delay' seconds
+         */
+        ssize_t speed_stream_check_bytes;
 
         /**
          * Sets the maximum limit rate every second
diff --git a/include/worker/ManapiBaseUtils.hpp b/include/worker/ManapiBaseUtils.hpp
@@ -8,6 +8,11 @@ auto const prev = std::exchange(n__->flags, ((n__->flags >> 2) << 2) | (flags &
 if (n__->flags & CONN_EVENT_LOCKED) return prev; \
 n__->flags |= CONN_EVENT_LOCKED; auto status = n__->flags; \
 while (true)
+#define MANAPIHTTP_WORKER_EVENT_LOOP_STREAM(n__) n__->speed_min_delay = static_cast<int>(this->config()->speed_stream_check_delay); \
+auto const prev = std::exchange(n__->flags, ((n__->flags >> 2) << 2) | (flags & CONN_MASK_UPDATE)); \
+if (n__->flags & CONN_EVENT_LOCKED) return prev; \
+n__->flags |= CONN_EVENT_LOCKED; auto status = n__->flags; \
+while (true)
 #define MANAPIHTTP_WORKER_EVENT_BREAK(n__) if (status != n__->flags) { status = n__->flags; continue; }\
 assert (n__->flags & CONN_EVENT_LOCKED); n__->flags ^= CONN_EVENT_LOCKED;  break;
 
@@ -89,6 +94,8 @@ namespace manapi::net::worker {
 
         void feed_event (worker::base *w, const shared_conn &conn, int flags, const char *buff, ssize_t size, ibuffpool_t *p) MANAPIHTTP_NOEXCEPT;
 
+        void update_limit_rate_connection (const shared_conn &sconn, connection_prepared_base_t *data, worker::base *w, http::config *config, ssize_t speed_check_delay, ssize_t speed_check_bytes, wrk_interface_global_t *global) MANAPIHTTP_NOEXCEPT;
+
         void update_limit_rate_connection (const shared_conn &sconn, connection_prepared_base_t *data, worker::base *w, http::config *config, wrk_interface_global_t *global) MANAPIHTTP_NOEXCEPT;
 
         void update_limit_rate_connection (const shared_conn &sconn, worker::base *w, http::config *config, wrk_interface_global_t *global) MANAPIHTTP_NOEXCEPT;
diff --git a/src/http/ManapiHttp2.cpp b/src/http/ManapiHttp2.cpp
@@ -1370,7 +1370,7 @@ int manapi::net::http::http_v2_work(http_v2_t *ctx, http::config *config, const
                                 sdata = s->second->as<http_v2_stream_t>();
                                 sdata->req = std::move(req_tmp);
                                 sdata->top = std::move(top_tmp);
-                                sdata->speed_min_delay = static_cast<int>(config->speed_check_delay);
+                                sdata->speed_min_delay = static_cast<int>(config->speed_stream_check_delay);
 
                                 sdata->req->divided = -1;
                                 sdata->req->http = http::versions::http::HTTP_v2;
diff --git a/src/http/ManapiHttpConfig.cpp b/src/http/ManapiHttpConfig.cpp
@@ -23,7 +23,6 @@ enum http_version_bits {
 manapi::net::http::config::config(const json &config) {
     this->http_versions = 0;
     this->server_len = 0;
-    this->max_working_streams = get_config_param<ssize_t> (config, "max_working_streams", 6);
     this->window_stream_size = get_config_param<ssize_t> (config, "window_stream_size", 2000000);
     this->window_connection_size = get_config_param<ssize_t> (config, "window_connection_size", 4000000);
     this->max_concurrent_streams = get_config_param<ssize_t> (config, "max_concurrent_streams", -1);
@@ -46,6 +45,8 @@ manapi::net::http::config::config(const json &config) {
     this->tcp_no_delay = get_config_param<bool>(config, "tcp_no_delay", false);
     this->speed_check_delay = get_config_param<ssize_t>(config, "speed_check_delay", 5);
     this->speed_check_bytes = get_config_param<ssize_t>(config, "speed_check_bytes", 1048576);
+    this->speed_stream_check_delay = get_config_param<ssize_t>(config, "speed_stream_check_delay", 5);
+    this->speed_stream_check_bytes = get_config_param<ssize_t>(config, "speed_stream_check_bytes", 1048576);
     this->simultaneous_accepts = get_config_param<bool>(config, "simultaneous_accepts", false);
     this->max_headers_size = get_config_param<ssize_t>(config, "max_headers_size", 16384);
     this->max_header_key_size = get_config_param<ssize_t>(config, "max_header_key_size", 64);
diff --git a/src/http/ManapiNgHttp2Interface.cpp b/src/http/ManapiNgHttp2Interface.cpp
@@ -530,7 +530,7 @@ static int ng_wrk_http2_on_begin_headers_callback(nghttp2_session *session, cons
         auto const id = frame->hd.stream_id;
 
         auto tp = std::make_unique<http_v2_stream_t>();
-        tp->speed_min_delay = static_cast<decltype(tp->speed_min_delay)>(sess->gctx->worker->config()->speed_check_delay);
+        tp->speed_min_delay = static_cast<decltype(tp->speed_min_delay)>(sess->gctx->worker->config()->speed_stream_check_delay);
         tp->id = id;
         tp->top = std::make_unique<manapi::net::worker::connection_io>();
         tp->req = std::make_unique<manapi::net::http::request_data_t>();
diff --git a/src/http/ManapiNgHttp3Interface.cpp b/src/http/ManapiNgHttp3Interface.cpp
@@ -1323,16 +1323,16 @@ static int ng_wrk_http3_rst (const manapi::net::worker::shared_conn &conn, int c
         }
 
         if (s->s)
-            s->ctx->gctx->worker->close_connection(s->s, manapi::net::worker::CLOSE_CONN_ERR);
+            s->ctx->gctx->worker->close_connection(s->s, manapi::net::worker::CLOSE_CONN_SHUTDOWN);
 
         ng_wrk_http3_flush_close(s->ctx);
     }
     else {
         if (s->s)
-            s->ctx->gctx->worker->close_connection(s->s, manapi::net::worker::CLOSE_CONN_ERR);
+            s->ctx->gctx->worker->close_connection(s->s, manapi::net::worker::CLOSE_CONN_SHUTDOWN);
 
         if (!s->ctx->active_connections)
-            s->ctx->gctx->worker->close_connection(s->ctx->conn, manapi::net::worker::CLOSE_CONN_ERR);
+            s->ctx->gctx->worker->close_connection(s->ctx->conn, manapi::net::worker::CLOSE_CONN_SHUTDOWN);
     }
 
     return manapi::ERR_OK;
diff --git a/src/worker/ManapiBaseUtils.cpp b/src/worker/ManapiBaseUtils.cpp
@@ -175,7 +175,7 @@ void manapi::net::worker::prepared::feed_event(worker::base *w, const shared_con
     return feed_event(w, conn, data, flags, buff, size, p);
 }
 
-void manapi::net::worker::prepared::update_limit_rate_connection(const shared_conn &sconn, connection_prepared_base_t *data, worker::base *w, http::config *config, wrk_interface_global_t *global) MANAPIHTTP_NOEXCEPT {
+void manapi::net::worker::prepared::update_limit_rate_connection(const shared_conn &sconn, connection_prepared_base_t *data, worker::base *w, http::config *config, ssize_t speed_check_delay, ssize_t speed_check_bytes, wrk_interface_global_t *global) MANAPIHTTP_NOEXCEPT {
     if (data->transfered >= config->speed_limit_rate
         && data->ev_callback) {
         data->transfered = 0;
@@ -186,19 +186,19 @@ void manapi::net::worker::prepared::update_limit_rate_connection(const shared_co
                 return;
             }
         }
-    }
+        }
     else {
         data->transfered_k += data->transfered;
 
         if (--data->speed_min_delay <= 0) {
             if (data->flags & (base::CONN_IO_WAITING)
-                && (data->transfered_k < config->speed_check_bytes)) {
+                && (data->transfered_k < speed_check_bytes)) {
                 w->close_connection(sconn, CLOSE_CONN_ERR);
                 return;
-            }
+                }
 
             data->transfered_k = 0;
-            data->speed_min_delay = static_cast<int>(config->speed_check_delay);
+            data->speed_min_delay = static_cast<int>(speed_check_delay);
         }
 
         data->transfered = 0;
@@ -208,6 +208,10 @@ void manapi::net::worker::prepared::update_limit_rate_connection(const shared_co
         global->update_limit_rate(sconn, global, w);
 }
 
+void manapi::net::worker::prepared::update_limit_rate_connection(const shared_conn &sconn, connection_prepared_base_t *data, worker::base *w, http::config *config, wrk_interface_global_t *global) MANAPIHTTP_NOEXCEPT {
+    return update_limit_rate_connection(sconn, data, w, config, config->speed_check_delay, config->speed_check_delay, global);
+}
+
 void manapi::net::worker::prepared::update_limit_rate_connection(const shared_conn &sconn, worker::base *w, http::config *config, wrk_interface_global_t *global) MANAPIHTTP_NOEXCEPT {
     update_limit_rate_connection(sconn, sconn->as<connection_prepared_base_t>(), w, config, global);
 }
diff --git a/src/worker/ManapiHttp2Worker.cpp b/src/worker/ManapiHttp2Worker.cpp
@@ -65,7 +65,7 @@ void manapi::net::worker::http_v2::close_connection(shared_conn conn, int flags)
         return;
 
     /* got something wrong */
-    this->callbacks->http_v2_rst_stream(conn, HTTP2_ERROR_REFUSED_STREAM);
+    this->callbacks->http_v2_rst_stream(conn, HTTP2_ERROR_NO_ERROR);
 }
 
 int manapi::net::worker::http_v2::event_flags(const shared_conn & conn) MANAPIHTTP_NOEXCEPT {
@@ -75,7 +75,7 @@ int manapi::net::worker::http_v2::event_flags(const shared_conn & conn) MANAPIHT
 int manapi::net::worker::http_v2::event_flags(const shared_conn & conn, int flags) MANAPIHTTP_NOEXCEPT {
     auto const data = conn->as<http_v2_stream_base_t>();
 
-    MANAPIHTTP_WORKER_EVENT_LOOP(data) {
+    MANAPIHTTP_WORKER_EVENT_LOOP_STREAM(data) {
         if (data->ev_callback) {
             if (data->flags & CONN_CLOSED) {
                 if (http_v2::call_user_callback(&data->ev_callback, conn, CONN_CLOSED, nullptr, 0, nullptr))
@@ -135,7 +135,8 @@ ssize_t manapi::net::worker::http_v2::sync_write_ex(const shared_conn &conn, ev:
 }
 
 void manapi::net::worker::http_v2::update_limit_rate_stream(const shared_conn &conn) MANAPIHTTP_NOEXCEPT {
-    return prepared::update_limit_rate_connection(conn, this, this->config(), this->wrk_global());
+    auto const c = this->config();
+    return prepared::update_limit_rate_connection(conn, conn->as<connection_prepared_base_t>(), this, c, c->speed_stream_check_delay, c->speed_stream_check_bytes, this->wrk_global());
 }
 
 std::size_t manapi::net::worker::http_v2::recv_count(const shared_conn &conn) const MANAPIHTTP_NOEXCEPT {
diff --git a/src/worker/ManapiHttp3Worker.cpp b/src/worker/ManapiHttp3Worker.cpp
@@ -67,7 +67,7 @@ void manapi::net::worker::http_v3::close_connection(shared_conn conn, int flags)
         return;
 
     /* got something wrong */
-    this->callbacks->http_v3_rst_stream(conn, HTTP3_ERROR_REQUEST_CANCELLED);
+    this->callbacks->http_v3_rst_stream(conn, HTTP3_ERROR_NO_ERROR);
 }
 
 int manapi::net::worker::http_v3::event_flags(const shared_conn &conn) MANAPIHTTP_NOEXCEPT {
@@ -77,7 +77,7 @@ int manapi::net::worker::http_v3::event_flags(const shared_conn &conn) MANAPIHTT
 int manapi::net::worker::http_v3::event_flags(const shared_conn &conn, int flags) MANAPIHTTP_NOEXCEPT {
     auto const data = MANAPI_AS_STREAM(conn->wrk.data);
 
-    MANAPIHTTP_WORKER_EVENT_LOOP(data) {
+    MANAPIHTTP_WORKER_EVENT_LOOP_STREAM(data) {
         if (data->ev_callback) {
             if (data->flags & CONN_CLOSED) {
                 if (http_v3::call_user_callback(&data->ev_callback, conn, CONN_CLOSED, nullptr, 0, nullptr))
@@ -137,7 +137,8 @@ ssize_t manapi::net::worker::http_v3::sync_write_ex(const shared_conn &conn, ev:
 }
 
 void manapi::net::worker::http_v3::update_limit_rate_stream(const shared_conn &conn) MANAPIHTTP_NOEXCEPT {
-    prepared::update_limit_rate_connection(conn, MANAPI_AS_STREAM(conn->wrk.data), this, this->config(), this->wrk_global());
+    auto const c = this->config();
+    return prepared::update_limit_rate_connection(conn, MANAPI_AS_STREAM(conn->wrk.data), this, c, c->speed_stream_check_delay, c->speed_stream_check_bytes, this->wrk_global());
 }
 
 std::size_t manapi::net::worker::http_v3::recv_count(const shared_conn &conn) const MANAPIHTTP_NOEXCEPT {
diff --git a/src/worker/ManapiQuicOpenSsl.cpp b/src/worker/ManapiQuicOpenSsl.cpp
@@ -620,7 +620,7 @@ int manapi::net::worker::openssl_quic::event_flags(const shared_conn &conn) MANA
 int manapi::net::worker::openssl_quic::event_flags(const shared_conn &conn, int flags) MANAPIHTTP_NOEXCEPT {
     auto const data = conn->as<quic_stream_t>();
 
-    MANAPIHTTP_WORKER_EVENT_LOOP(data) {
+    MANAPIHTTP_WORKER_EVENT_LOOP_STREAM(data) {
         if ((status & (ev::READ|ev::DISCONNECT)) == ev::READ && data->ev_callback) {
             if (conn->wrk.flags & WRK_INTERFACE_CUSTOM_READ)
                 this->global_.flush_custom_read_cb(conn, &this->global_, this);
@@ -1219,7 +1219,7 @@ void manapi::net::worker::openssl_quic::update_limit_rate_connection(const share
                 data->transfered_k += data->transfered;
 
                 if (--data->speed_min_delay <= 0) {
-                    if (data->flags & (base::CONN_IO_WAITING) && (data->transfered_k < config->speed_check_bytes)) {
+                    if (data->flags & (base::CONN_IO_WAITING) && (data->transfered_k < config->speed_stream_check_bytes)) {
                         manapi::async::current()->etaskpool()->append_task([conn = it->second] () -> void {
                             auto data = conn->as<quic_stream_t>();
                             assert(data && data->parent);
@@ -1231,7 +1231,7 @@ void manapi::net::worker::openssl_quic::update_limit_rate_connection(const share
                         continue;
                     }
                     data->transfered_k = 0;
-                    data->speed_min_delay = static_cast<int>(config->speed_check_delay);
+                    data->speed_min_delay = static_cast<int>(config->speed_stream_check_delay);
                 }
                 data->transfered = 0;
             }
diff --git a/src/worker/ManapiTcp.cpp b/src/worker/ManapiTcp.cpp
@@ -861,7 +861,7 @@ void manapi::net::worker::TCP::timeout_(shared_conn conn) MANAPIHTTP_NOEXCEPT {
     if (conn->wrk.flags & WRK_INTERFACE_TCP_KEEP_ALIVE)
         conn->wrk.flags ^= WRK_INTERFACE_TCP_KEEP_ALIVE;
 
-    this->close_connection(conn, CLOSE_CONN_ERR);
+    this->close_connection(conn, CLOSE_CONN_SHUTDOWN);
 }
 
 void manapi::net::worker::TCP::update_limit_rate_connection(const shared_conn &sconn) MANAPIHTTP_NOEXCEPT {
diff --git a/src/worker/ManapiTlsOverTcp.cpp b/src/worker/ManapiTlsOverTcp.cpp
@@ -70,7 +70,7 @@ void manapi::net::worker::TLS::close_connection(shared_conn conn, int flags) MAN
 
     if (!this->config_->force_conn_shutdown
         && (
-            (flags & (CLOSE_CONN_SHUTDOWN))
+            (flags & (CLOSE_CONN_SHUTDOWN|CLOSE_CONN_ERR))
             || (!flags
                 && (!this->config_->keep_alive
                     || !(conn->wrk.flags & WRK_INTERFACE_TCP_KEEP_ALIVE)
@@ -351,6 +351,15 @@ void manapi::net::worker::TLS::shutdown_async_(shared_conn conn) {
     if (s->accept_timer) {
         s->accept_timer.stop();
         s->accept_timer = nullptr;
+
+    }
+    auto accept_timer_res = manapi::async::current()->timerpool()->append_timer_sync(5000, [wconn = std::weak_ptr (conn)] (manapi::timer t)
+        -> void { auto conn = wconn.lock(); if (conn) { auto w = conn->as<tcp_connection_t>(); w->worker->close_connection(conn, CLOSE_CONN_EOF); } });
+    if (accept_timer_res)
+        s->accept_timer = accept_timer_res.unwrap();
+    else {
+        this->close_connection(conn, CLOSE_CONN_EOF);
+        return;
     }
 
     bool flg = false;
@@ -557,7 +566,7 @@ void manapi::net::worker::TLS::onrecv(const std::shared_ptr<ev::tcp> &watcher, c
         cdata->flags |= ev::DISCONNECT;
         conn->cancellation.cancel();
 
-        this->close_connection(conn, CLOSE_CONN_EOF);
+        this->close_connection(conn, CLOSE_CONN_SHUTDOWN);
 
         return;
     }
@@ -585,8 +594,11 @@ manapi::net::worker::shared_conn manapi::net::worker::TLS::connection_init_cb(vo
             return nullptr;
 
         auto rhs = manapi::async::current()->timerpool()->append_timer_sync(8000,
-            [ms] (const manapi::timer &t) mutable
+            [ms_w = std::weak_ptr (ms)] (const manapi::timer &t) mutable
             -> void {
+                auto ms = ms_w.lock();
+                if (!ms)
+                    return;
                 auto w = ms->as<tcp_connection_t>();
                 auto conn = std::move(ms);
                 w->worker->close_connection(std::move(conn), CLOSE_CONN_ERR);
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.10)
 
 set(MANAPIHTTP_TEST_TOOL_FILES "utest.h" "tools.hpp")
 
-set(MANAPIHTTP_TESTS_SOURCES test_bigint.cpp test_fs.cpp test_http_and_fetch.cpp test_json.cpp test_json_masks.cpp test_parse.cpp)
+set(MANAPIHTTP_TESTS_SOURCES test_bigint.cpp test_fs.cpp test_http_and_fetch.cpp test_json.cpp test_json_masks.cpp test_parse.cpp test_http_and_fetch_keep_alive.cpp)
 foreach(test ${MANAPIHTTP_TESTS_SOURCES})
     set(test_name ${test}_ctest)
     include_directories(${test_name} "../include" "${CMAKE_BINARY_DIR}/include")
diff --git a/tests/test_http_and_fetch.cpp b/tests/test_http_and_fetch.cpp
@@ -30,7 +30,7 @@ UTEST(http, http_router_exists) {
 #ifdef MANAPIHTTP_FETCH_SUPPORT
 
 UTEST(http_and_fetch, simple_request) {
-    auto ctx = init_ctx();
+    auto ctx = init_ctx(utest_result);
     auto router = init_router({
         {"http1", true}
     }, [&] () -> manapi::future<> {
@@ -57,7 +57,7 @@ UTEST(http_and_fetch, simple_request) {
 UTEST(http_and_fetch, simple_post_request) {
     using http = manapi::net::http::server;
 
-    auto ctx = init_ctx();
+    auto ctx = init_ctx(utest_result);
     auto router = init_router({
         {"http1", true}
     }, [&] () -> manapi::future<> {
@@ -92,7 +92,7 @@ UTEST(http_and_fetch, simple_post_request) {
 UTEST(http_and_fetch, callback_sync_get_request) {
     using http = manapi::net::http::server;
 
-    auto ctx = init_ctx();
+    auto ctx = init_ctx(utest_result);
     auto router = init_router({
         {"http1", true}
     }, [&] () -> manapi::future<> {
@@ -137,7 +137,7 @@ UTEST(http_and_fetch, callback_sync_get_request) {
 UTEST(http_and_fetch, callback_async_get_request) {
     using http = manapi::net::http::server;
 
-    auto ctx = init_ctx();
+    auto ctx = init_ctx(utest_result);
     auto router = init_router({
         {"http1", true}
     }, [&] () -> manapi::future<> {
@@ -227,7 +227,7 @@ UTEST(http_and_fetch, callback_async_get_request) {
 UTEST(http_and_fetch, formdata_request) {
     using http = manapi::net::http::server;
 
-    auto ctx = init_ctx();
+    auto ctx = init_ctx(utest_result);
     auto router = init_router({
         {"http1", true}
     }, [&] () -> manapi::future<> {
@@ -299,7 +299,7 @@ UTEST(http_and_fetch, formdata_request) {
 UTEST(http_and_fetch, formdata_response) {
     using http = manapi::net::http::server;
 
-    auto ctx = init_ctx();
+    auto ctx = init_ctx(utest_result);
     auto router = init_router({
         {"http1", true}
     }, [&] () -> manapi::future<> {
@@ -336,7 +336,7 @@ UTEST(http_and_fetch, formdata_response) {
 UTEST(http_and_fetch, formdata_bad_response__no_data) {
     using http = manapi::net::http::server;
 
-    auto ctx = init_ctx();
+    auto ctx = init_ctx(utest_result);
     auto router = init_router({
         {"http1", true}
     }, [&] () -> manapi::future<> {
@@ -384,7 +384,7 @@ UTEST(http_and_fetch, formdata_bad_response__no_data) {
 UTEST(http_and_fetch, formdata_bad_response) {
     using http = manapi::net::http::server;
 
-    auto ctx = init_ctx();
+    auto ctx = init_ctx(utest_result);
     auto router = init_router({
         {"http1", true}
     }, [&] () -> manapi::future<> {
@@ -420,7 +420,7 @@ UTEST(http_and_fetch, formdata_bad_response) {
 UTEST(http_and_fetch, chunked_request) {
     using http = manapi::net::http::server;
 
-    auto ctx = init_ctx();
+    auto ctx = init_ctx(utest_result);
     auto router = init_router({
         {"http1", true}
     }, [&] () -> manapi::future<> {
@@ -478,7 +478,7 @@ UTEST(http_and_fetch, chunked_request) {
 UTEST(http_and_fetch, chunked_response) {
     using http = manapi::net::http::server;
 
-    auto ctx = init_ctx();
+    auto ctx = init_ctx(utest_result);
     auto router = init_router({
         {"http1", true}
     }, [&] () -> manapi::future<> {
@@ -537,7 +537,7 @@ UTEST(http_and_fetch, user_data) {
         std::string msg;
     };
 
-    auto ctx = init_ctx();
+    auto ctx = init_ctx(utest_result);
     auto router = init_router({
         {"http1", true}
     }, [&] () -> manapi::future<> {
diff --git a/tests/test_http_and_fetch_keep_alive.cpp b/tests/test_http_and_fetch_keep_alive.cpp
diff --git a/tests/tools.hpp b/tests/tools.hpp

Original file line number	Diff line number	Diff line change
`@@ -1323,16 +1323,16 @@ static int ng_wrk_http3_rst (const manapi::net::worker::shared_conn &conn, int c`
`1323`	`1323`	`}`
`1324`	`1324`
`1325`	`1325`	`if (s->s)`
`1326`		`- s->ctx->gctx->worker->close_connection(s->s, manapi::net::worker::CLOSE_CONN_ERR);`
	`1326`	`+ s->ctx->gctx->worker->close_connection(s->s, manapi::net::worker::CLOSE_CONN_SHUTDOWN);`
`1327`	`1327`
`1328`	`1328`	`ng_wrk_http3_flush_close(s->ctx);`
`1329`	`1329`	`}`
`1330`	`1330`	`else {`
`1331`	`1331`	`if (s->s)`
`1332`		`- s->ctx->gctx->worker->close_connection(s->s, manapi::net::worker::CLOSE_CONN_ERR);`
	`1332`	`+ s->ctx->gctx->worker->close_connection(s->s, manapi::net::worker::CLOSE_CONN_SHUTDOWN);`
`1333`	`1333`
`1334`	`1334`	`if (!s->ctx->active_connections)`
`1335`		`- s->ctx->gctx->worker->close_connection(s->ctx->conn, manapi::net::worker::CLOSE_CONN_ERR);`
	`1335`	`+ s->ctx->gctx->worker->close_connection(s->ctx->conn, manapi::net::worker::CLOSE_CONN_SHUTDOWN);`
`1336`	`1336`	`}`
`1337`	`1337`
`1338`	`1338`	`return manapi::ERR_OK;`