Merge branch 'master' into v13 branch

gittiver · gittiver · commit abbb2dea3b66 · 2026-02-03T22:58:22.000+01:00
diff --git a/.github/workflows/build_and_test.yml b/.github/workflows/build_and_test.yml
@@ -31,13 +31,15 @@ jobs:
           - { os: windows-latest, compiler: msvc, cxx_stdlib: msvc }
 
     steps:
+
     - name: Output Infos
       run: |
         echo $GIT_REF
         echo $GIT_EVENT_REF
         echo $GIT_EVENT_TYPE
 
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v6
+
     - name: Prepare dependencies
       run: |
          if [ "$RUNNER_OS" == "Linux" ]; then
@@ -135,8 +137,8 @@ jobs:
       shell: bash
 
     - name: Save report
-      uses: actions/upload-artifact@v4
-      if: matrix.os == 'ubuntu-latest' && matrix.compiler == 'gcc' && matrix.cxx_stdlib == 'libstdc++' && matrix.asio_type == 'boost' && !startsWith(github.ref, 'refs/heads/v')
+      uses: actions/upload-artifact@v6
+      if: matrix.os == 'ubuntu-latest' && matrix.compiler == 'gcc' && matrix.cxx_stdlib == 'libstdc++' && matrix.asio_type == 'boost' && !startsWith(github.ref, 'refs/tags/v')
       with:
         name: coveralls.json
         path: coveralls.json
@@ -157,8 +159,8 @@ jobs:
       shell: bash
 
     - name: Upload Linux packages
-      uses: actions/upload-artifact@v4
-      if: matrix.os == 'ubuntu-latest' && matrix.compiler == 'gcc' && matrix.cxx_stdlib == 'libstdc++' && matrix.asio_type == 'boost' && startsWith(github.ref, 'refs/heads/v')
+    - uses: actions/upload-artifact@v6
+      if: matrix.os == 'ubuntu-latest' && matrix.compiler == 'gcc' && matrix.cxx_stdlib == 'libstdc++' && matrix.asio_type == 'boost' && startsWith(github.ref, 'refs/tags/v')
       with:
         name: packages
         overwrite: true
diff --git a/.github/workflows/build_bazel.yml b/.github/workflows/build_bazel.yml
@@ -26,7 +26,7 @@ jobs:
             # ubuntu-18.04 & mac-os do not work due to compile error on asio
             # windows-2019 not included to spare free minutes
     steps:
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v6
     - name: Prepare dependencies
       run: |
          if [ "$RUNNER_OS" == "Linux" ]; then
diff --git a/.github/workflows/cifuzz.yml b/.github/workflows/cifuzz.yml
@@ -25,7 +25,7 @@ jobs:
         fuzz-seconds: 800
         output-sarif: true
     - name: Upload Crash
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v6
       if: failure() && steps.build.outcome == 'success'
       with:
         name: artifacts
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
@@ -58,7 +58,7 @@ jobs:
         # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v5
+      uses: actions/checkout@v6
 
     # Install dependencies
     - name: Prepare dependencies
diff --git a/.github/workflows/doxygen-gh-pages.yml b/.github/workflows/doxygen-gh-pages.yml
@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout 🛎️
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Prepare dependencies
         run: sudo apt-get update && sudo apt-get -yq install libasio-dev doxygen mkdocs graphviz zlib1g-dev gcc clang make cmake python3 python3-pip git openssl libssl-dev
       - name: prepate pip dependencies
diff --git a/.github/workflows/submit_coverage.yml b/.github/workflows/submit_coverage.yml
@@ -16,7 +16,7 @@ jobs:
     if: github.event.workflow_run.conclusion == 'success'
     steps:
       - name: Download artifact
-        uses: dawidd6/action-download-artifact@v11
+        uses: dawidd6/action-download-artifact@v14
         with:
           workflow: ${{ github.event.workflow_run.workflow_id }}
           workflow_conclusion: success
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -11,8 +11,6 @@ project(Crow
 
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
-include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/CPM.cmake)
-
 # Make sure Findasio.cmake module is found
 list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 
@@ -59,12 +57,17 @@ option(CROW_RETURNS_OK_ON_HTTP_OPTIONS_REQUEST
 
 option(CROW_ENABLE_SSL "Enable Crow's SSL feature for supporting https" OFF)
 option(CROW_ENABLE_COMPRESSION "Enable Crow's Compression feature for supporting compressed http content" OFF)
+option(CROW_ENABLE_TSAN "Enable ThreadSanitizer" OFF)
+
+if(CROW_GENERATE_SBOM OR CROW_BUILD_TESTS)
+	include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/CPM.cmake)
+endif ()
 
 if(CROW_GENERATE_SBOM)
   CPMAddPackage(
     NAME cmake-sbom
     GITHUB_REPOSITORY DEMCON/cmake-sbom
-    GIT_TAG v1.3.0
+    GIT_TAG v1.4.0
     DOWNLOAD_ONLY YES
   )
   list(APPEND CMAKE_MODULE_PATH "${CMAKE_BINARY_DIR}/_deps/cmake-sbom-src/cmake")
@@ -80,6 +83,16 @@ if(CROW_GENERATE_SBOM)
 	)
 endif()
 
+if(CROW_ENABLE_TSAN)
+  if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    message(STATUS "ThreadSanitizer enabled")
+    add_compile_options(-fsanitize=thread -fno-omit-frame-pointer)
+    add_link_options(-fsanitize=thread)
+  else()
+    message(WARNING "ThreadSanitizer is exclusive to Clang and cannot be used with any other compilers")
+  endif()
+endif()
+
 #####################################
 # Define Targets
 #####################################
diff --git a/include/crow/app.h b/include/crow/app.h
@@ -619,6 +619,7 @@ namespace crow
 
         void close_websockets()
         {
+            std::lock_guard<std::mutex> lock{websockets_mutex_};
             for (auto websocket : websockets_)
             {
                 CROW_LOG_INFO << "Quitting Websocket: " << websocket;
@@ -629,11 +630,13 @@ namespace crow
 
         void add_websocket(std::shared_ptr<websocket::connection> conn)
         {
+            std::lock_guard<std::mutex> lock{websockets_mutex_};
             websockets_.push_back(conn);
         }
 
         void remove_websocket(std::shared_ptr<websocket::connection> conn)
         {
+            std::lock_guard<std::mutex> lock{websockets_mutex_};
             websockets_.erase(std::remove(websockets_.begin(), websockets_.end(), conn), websockets_.end());
         }
 
@@ -846,6 +849,7 @@ namespace crow
         bool server_started_{false};
         std::condition_variable cv_started_;
         std::mutex start_mutex_;
+        std::mutex websockets_mutex_; ///< \brief mutex to protect websockets_
         std::vector<std::shared_ptr<websocket::connection>> websockets_;
     };
 
diff --git a/include/crow/common.h b/include/crow/common.h
@@ -280,19 +280,19 @@ namespace crow
     struct routing_handle_result
     {
         bool catch_all{false};
-        uint16_t rule_index;
-        std::vector<uint16_t> blueprint_indices;
+        size_t rule_index;
+        std::vector<size_t> blueprint_indices;
         routing_params r_params;
         HTTPMethod method;
 
         routing_handle_result() {}
 
-        routing_handle_result(uint16_t rule_index_, std::vector<uint16_t> blueprint_indices_, routing_params r_params_):
+        routing_handle_result(size_t rule_index_, std::vector<size_t> blueprint_indices_, routing_params r_params_):
           rule_index(rule_index_),
           blueprint_indices(blueprint_indices_),
           r_params(r_params_) {}
 
-        routing_handle_result(uint16_t rule_index_, std::vector<uint16_t> blueprint_indices_, routing_params r_params_, HTTPMethod method_):
+        routing_handle_result(size_t rule_index_, std::vector<size_t> blueprint_indices_, routing_params r_params_, HTTPMethod method_):
           rule_index(rule_index_),
           blueprint_indices(blueprint_indices_),
           r_params(r_params_),
diff --git a/include/crow/http_connection.h b/include/crow/http_connection.h
@@ -128,9 +128,13 @@ namespace crow
             {
                 continue_requested = true;
                 buffers_.clear();
-                static std::string expect_100_continue = "HTTP/1.1 100 Continue\r\n\r\n";
+                static const std::string expect_100_continue = "HTTP/1.1 100 Continue\r\n\r\n";
                 buffers_.emplace_back(expect_100_continue.data(), expect_100_continue.size());
-                do_write_sync(buffers_);
+                error_code ec = do_write_sync(buffers_);
+                if (ec)
+                {
+                    CROW_LOG_ERROR << ec << " buffer write error happened while handling sending continuation buffer header";
+                }
             }
         }
 
@@ -299,7 +303,12 @@ namespace crow
                 while (is.gcount() > 0)
                 {
                     buffers[0] = asio::buffer(buf, is.gcount());
-                    do_write_sync(buffers);
+                    error_code ec = do_write_sync(buffers);
+                    if (ec) {
+                        CROW_LOG_ERROR << ec << " - buffer write error happened while sending content of file "
+                                       << res.file_info.path << ". Writing stopped premature.";
+                        break;
+                    }
                     is.read(buf, sizeof(buf));
                 }
             }
@@ -318,13 +327,16 @@ namespace crow
 
         void do_write_general()
         {
+            error_code ec;
             if (res.body.length() < res_stream_threshold_)
             {
                 res_body_copy_.swap(res.body);
                 buffers_.emplace_back(res_body_copy_.data(), res_body_copy_.size());
 
-                do_write_sync(buffers_);
-
+                ec = do_write_sync(buffers_);
+                if (ec) {
+                    CROW_LOG_ERROR << ec << " - buffer write error happened while sending response. Writing stopped premature.";
+                }
                 if (need_to_start_read_after_complete_)
                 {
                     need_to_start_read_after_complete_ = false;
@@ -334,7 +346,10 @@ namespace crow
             }
             else
             {
-                asio::write(adaptor_.socket(), buffers_); // Write the response start / headers
+                asio::write(adaptor_.socket(), buffers_,ec); // Write the response start / headers
+                if (ec) {
+                    CROW_LOG_ERROR << ec << "- buffer write error happened while sending response start / headers. Writing stopped premature.";
+                }
                 cancel_deadline_timer();
                 if (res.body.length() > 0)
                 {
@@ -345,7 +360,11 @@ namespace crow
                     {
                         size_t to_transfer = CROW_MIN(16384UL, length - transferred);
                         buffers[0] = asio::const_buffer(data + transferred, to_transfer);
-                        do_write_sync(buffers);
+                        ec = do_write_sync(buffers);
+                        if (ec) {
+                            CROW_LOG_ERROR << ec << " - " << transferred << " - buffer write error happened while sending response. Writing stopped premature.";
+                            break;
+                        }
                         transferred += to_transfer;
                     }
                 }
@@ -439,10 +458,15 @@ namespace crow
               });
         }
 
-        inline void do_write_sync(std::vector<asio::const_buffer>& buffers)
+        inline error_code do_write_sync(std::vector<asio::const_buffer>& buffers)
         {
             error_code ec;
             asio::write(adaptor_.socket(), buffers, ec);
+            if (ec)
+            {
+                // CROW_LOG_ERROR << ec << " - happened while sending buffers";
+                CROW_LOG_DEBUG << this << " from write (sync)(2)";
+            }
 
             this->res.clear();
             this->res_body_copy_.clear();
@@ -455,11 +479,7 @@ namespace crow
                 this->parser_.clear();
             }
 
-            if (ec)
-            {
-                CROW_LOG_ERROR << ec << " - happened while sending buffers";
-                CROW_LOG_DEBUG << this << " from write (sync)(2)";
-            }
+            return ec;
         }
 
         void cancel_deadline_timer()
diff --git a/include/crow/http_request.h b/include/crow/http_request.h
@@ -20,15 +20,16 @@ namespace crow // NOTE: Already documented in "crow/app.h"
 #endif
 
     /// Find and return the value associated with the key. (returns an empty string if nothing is found)
-    template<typename T>
-    inline const std::string& get_header_value(const T& headers, const std::string& key)
+    inline const std::string& get_header_value(const ci_map& headers, const std::string& key)
     {
-        if (headers.count(key))
-        {
-            return headers.find(key)->second;
+        static const std::string EMPTY;
+        const auto it = headers.find(key);
+        if (it != headers.end()) {
+            return it->second;
+        }
+        else {
+            return EMPTY;
         }
-        static std::string empty;
-        return empty;
     }
 
     /// An HTTP request.
diff --git a/include/crow/middlewares/cookie_parser.h b/include/crow/middlewares/cookie_parser.h
@@ -231,8 +231,7 @@ namespace crow
 
         void before_handle(request& req, response& res, context& ctx)
         {
-            // TODO(dranikpg): remove copies, use string_view with c++17
-            int count = req.headers.count("Cookie");
+            const int count = req.headers.count("Cookie");
             if (!count)
                 return;
             if (count > 1)
@@ -241,34 +240,49 @@ namespace crow
                 res.end();
                 return;
             }
-            std::string cookies = req.get_header_value("Cookie");
+
+            const std::string_view cookies_sv = req.get_header_value("Cookie");
+
             size_t pos = 0;
-            while (pos < cookies.size())
+            while (pos < cookies_sv.size())
             {
-                size_t pos_equal = cookies.find('=', pos);
-                if (pos_equal == cookies.npos)
+                const size_t pos_equal = cookies_sv.find('=', pos);
+                if (pos_equal == std::string_view::npos) {
                     break;
-                std::string name = cookies.substr(pos, pos_equal - pos);
-                name = utility::trim(name);
+                }
+
+                std::string_view name_sv = cookies_sv.substr(pos, pos_equal - pos);
+                name_sv = utility::trim(name_sv);
+
                 pos = pos_equal + 1;
-                if (pos == cookies.size())
+                if (pos == cookies_sv.size()) {
                     break;
+                }
 
-                size_t pos_semicolon = cookies.find(';', pos);
-                std::string value = cookies.substr(pos, pos_semicolon - pos);
+                const size_t pos_semicolon = cookies_sv.find(';', pos);
+                std::string_view value_sv;
 
-                value = utility::trim(value);
-                if (value[0] == '"' && value[value.size() - 1] == '"')
-                {
-                    value = value.substr(1, value.size() - 2);
+                if (pos_semicolon == std::string_view::npos) {
+                     value_sv = cookies_sv.substr(pos);
+                     pos = cookies_sv.size();
+                } else {
+                     value_sv = cookies_sv.substr(pos, pos_semicolon - pos);
+                     pos = pos_semicolon + 1;
                 }
 
-                ctx.jar.emplace(std::move(name), std::move(value));
+                value_sv = utility::trim(value_sv);
 
-                pos = pos_semicolon;
-                if (pos == cookies.npos)
-                    break;
-                pos++;
+                if (!value_sv.empty() && value_sv.front() == '"' && value_sv.back() == '"')
+                {
+                     if (value_sv.size() >= 2) {
+                        value_sv.remove_prefix(1);
+                        value_sv.remove_suffix(1);
+                     } else {
+                        value_sv = value_sv.substr(0,0);
+                     }
+                }
+
+                ctx.jar.emplace(std::string(name_sv), std::string(value_sv));
             }
         }
 
diff --git a/include/crow/query_string.h b/include/crow/query_string.h
diff --git a/include/crow/routing.h b/include/crow/routing.h
diff --git a/include/crow/utility.h b/include/crow/utility.h
diff --git a/include/crow/websocket.h b/include/crow/websocket.h
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
diff --git a/tests/unit_tests/test_websocket.cpp b/tests/unit_tests/test_websocket.cpp

Original file line number	Diff line number	Diff line change
`@@ -619,6 +619,7 @@ namespace crow`
`619`	`619`
`620`	`620`	`void close_websockets()`
`621`	`621`	`{`
	`622`	`+ std::lock_guard<std::mutex> lock{websockets_mutex_};`
`622`	`623`	`for (auto websocket : websockets_)`
`623`	`624`	`{`
`624`	`625`	`CROW_LOG_INFO << "Quitting Websocket: " << websocket;`
`@@ -629,11 +630,13 @@ namespace crow`
`629`	`630`
`630`	`631`	`void add_websocket(std::shared_ptr<websocket::connection> conn)`
`631`	`632`	`{`
	`633`	`+ std::lock_guard<std::mutex> lock{websockets_mutex_};`
`632`	`634`	`websockets_.push_back(conn);`
`633`	`635`	`}`
`634`	`636`
`635`	`637`	`void remove_websocket(std::shared_ptr<websocket::connection> conn)`
`636`	`638`	`{`
	`639`	`+ std::lock_guard<std::mutex> lock{websockets_mutex_};`
`637`	`640`	`websockets_.erase(std::remove(websockets_.begin(), websockets_.end(), conn), websockets_.end());`
`638`	`641`	`}`
`639`	`642`
`@@ -846,6 +849,7 @@ namespace crow`
`846`	`849`	`bool server_started_{false};`
`847`	`850`	`std::condition_variable cv_started_;`
`848`	`851`	`std::mutex start_mutex_;`
	`852`	`+ std::mutex websockets_mutex_; ///< \brief mutex to protect websockets_`
`849`	`853`	`std::vector<std::shared_ptr<websocket::connection>> websockets_;`
`850`	`854`	`};`
`851`	`855`
Original file line number	Diff line number	Diff line change
`@@ -128,9 +128,13 @@ namespace crow`
`128`	`128`	`{`
`129`	`129`	`continue_requested = true;`
`130`	`130`	`buffers_.clear();`
`131`		`- static std::string expect_100_continue = "HTTP/1.1 100 Continue\r\n\r\n";`
	`131`	`+ static const std::string expect_100_continue = "HTTP/1.1 100 Continue\r\n\r\n";`
`132`	`132`	`buffers_.emplace_back(expect_100_continue.data(), expect_100_continue.size());`
`133`		`- do_write_sync(buffers_);`
	`133`	`+ error_code ec = do_write_sync(buffers_);`
	`134`	`+ if (ec)`
	`135`	`+ {`
	`136`	`+ CROW_LOG_ERROR << ec << " buffer write error happened while handling sending continuation buffer header";`
	`137`	`+ }`
`134`	`138`	`}`
`135`	`139`	`}`
`136`	`140`
`@@ -299,7 +303,12 @@ namespace crow`
`299`	`303`	`while (is.gcount() > 0)`
`300`	`304`	`{`
`301`	`305`	`buffers[0] = asio::buffer(buf, is.gcount());`
`302`		`- do_write_sync(buffers);`
	`306`	`+ error_code ec = do_write_sync(buffers);`
	`307`	`+ if (ec) {`
	`308`	`+ CROW_LOG_ERROR << ec << " - buffer write error happened while sending content of file "`
	`309`	`+ << res.file_info.path << ". Writing stopped premature.";`
	`310`	`+ break;`
	`311`	`+ }`
`303`	`312`	`is.read(buf, sizeof(buf));`
`304`	`313`	`}`
`305`	`314`	`}`
`@@ -318,13 +327,16 @@ namespace crow`
`318`	`327`
`319`	`328`	`void do_write_general()`
`320`	`329`	`{`
	`330`	`+ error_code ec;`
`321`	`331`	`if (res.body.length() < res_stream_threshold_)`
`322`	`332`	`{`
`323`	`333`	`res_body_copy_.swap(res.body);`
`324`	`334`	`buffers_.emplace_back(res_body_copy_.data(), res_body_copy_.size());`
`325`	`335`
`326`		`- do_write_sync(buffers_);`
`327`		`-`
	`336`	`+ ec = do_write_sync(buffers_);`
	`337`	`+ if (ec) {`
	`338`	`+ CROW_LOG_ERROR << ec << " - buffer write error happened while sending response. Writing stopped premature.";`
	`339`	`+ }`
`328`	`340`	`if (need_to_start_read_after_complete_)`
`329`	`341`	`{`
`330`	`342`	`need_to_start_read_after_complete_ = false;`
`@@ -334,7 +346,10 @@ namespace crow`
`334`	`346`	`}`
`335`	`347`	`else`
`336`	`348`	`{`
`337`		`- asio::write(adaptor_.socket(), buffers_); // Write the response start / headers`
	`349`	`+ asio::write(adaptor_.socket(), buffers_,ec); // Write the response start / headers`
	`350`	`+ if (ec) {`
	`351`	`+ CROW_LOG_ERROR << ec << "- buffer write error happened while sending response start / headers. Writing stopped premature.";`
	`352`	`+ }`
`338`	`353`	`cancel_deadline_timer();`
`339`	`354`	`if (res.body.length() > 0)`
`340`	`355`	`{`
`@@ -345,7 +360,11 @@ namespace crow`
`345`	`360`	`{`
`346`	`361`	`size_t to_transfer = CROW_MIN(16384UL, length - transferred);`
`347`	`362`	`buffers[0] = asio::const_buffer(data + transferred, to_transfer);`
`348`		`- do_write_sync(buffers);`
	`363`	`+ ec = do_write_sync(buffers);`
	`364`	`+ if (ec) {`
	`365`	`+ CROW_LOG_ERROR << ec << " - " << transferred << " - buffer write error happened while sending response. Writing stopped premature.";`
	`366`	`+ break;`
	`367`	`+ }`
`349`	`368`	`transferred += to_transfer;`
`350`	`369`	`}`
`351`	`370`	`}`
`@@ -439,10 +458,15 @@ namespace crow`
`439`	`458`	`});`
`440`	`459`	`}`
`441`	`460`
`442`		`- inline void do_write_sync(std::vector<asio::const_buffer>& buffers)`
	`461`	`+ inline error_code do_write_sync(std::vector<asio::const_buffer>& buffers)`
`443`	`462`	`{`
`444`	`463`	`error_code ec;`
`445`	`464`	`asio::write(adaptor_.socket(), buffers, ec);`
	`465`	`+ if (ec)`
	`466`	`+ {`
	`467`	`+ // CROW_LOG_ERROR << ec << " - happened while sending buffers";`
	`468`	`+ CROW_LOG_DEBUG << this << " from write (sync)(2)";`
	`469`	`+ }`
`446`	`470`
`447`	`471`	`this->res.clear();`
`448`	`472`	`this->res_body_copy_.clear();`
`@@ -455,11 +479,7 @@ namespace crow`
`455`	`479`	`this->parser_.clear();`
`456`	`480`	`}`
`457`	`481`
`458`		`- if (ec)`
`459`		`- {`
`460`		`- CROW_LOG_ERROR << ec << " - happened while sending buffers";`
`461`		`- CROW_LOG_DEBUG << this << " from write (sync)(2)";`
`462`		`- }`
	`482`	`+ return ec;`
`463`	`483`	`}`
`464`	`484`
`465`	`485`	`void cancel_deadline_timer()`