Avoid GCC ubsan contexpr bug and add asan CI (#2288)

* Avoid GCC ubsan contexpr bug

* Create sanitizers.yml

* Update jmespath.hpp

* asan testing and revert cx_rfind

* properly delete thread pointer

* avoid circular reference memory leaks

Author: stephenberry

.github/workflows/sanitizers.yml

@@ -0,0 +1,64 @@
+name: sanitizers
+
+on:
+  push:
+    branches:
+      - main
+      - feature/*
+    paths-ignore:
+      - '**/*.md'
+      - 'docs/**'
+  pull_request:
+    branches:
+      - main
+    paths-ignore:
+      - '**/*.md'
+      - 'docs/**'
+  workflow_dispatch:
+
+jobs:
+  asan:
+    runs-on: ubuntu-24.04
+    container:
+      image: gcc:15
+
+    strategy:
+      fail-fast: false
+      matrix:
+        build_type: [Debug]
+        std: [23]
+
+    env:
+      CC: gcc
+      CXX: g++
+
+    steps:
+    - name: Install build dependencies
+      env:
+        DEBIAN_FRONTEND: noninteractive
+      run: |
+        apt-get update
+        apt-get install -y --no-install-recommends \
+          ca-certificates \
+          cmake \
+          git \
+          libssl-dev \
+          python3
+        update-ca-certificates
+
+    - uses: actions/checkout@v4
+
+    - name: Configure CMake
+      run: |
+        cmake -S "$GITHUB_WORKSPACE" -B "$GITHUB_WORKSPACE/build" \
+          -DCMAKE_BUILD_TYPE=${{matrix.build_type}} \
+          -DCMAKE_CXX_STANDARD=${{matrix.std}} \
+          -DCMAKE_CXX_FLAGS="-fsanitize=address -fno-sanitize-recover=all"
+
+    - name: Build
+      run: cmake --build "$GITHUB_WORKSPACE/build" -j $(nproc)
+
+    - name: Test
+      env:
+        ASAN_OPTIONS: detect_leaks=1
+      run: ctest --output-on-failure --test-dir "$GITHUB_WORKSPACE/build"

include/glaze/core/reflect.hpp

@@ -2561,7 +2561,6 @@ namespace glz
 
       if constexpr (K > 0) {
          using keys_t = keys_wrapper<variant_deduction_keys<T>>;
-         constexpr auto& HashInfo = hash_info<keys_t>;
 
          // Populate bit arrays - for each key, set bits for variant types that have it
          for_each<std::variant_size_v<T>>([&]<auto I>() {
@@ -2570,10 +2569,12 @@ namespace glz
                using X = std::conditional_t<is_memory_object<V>, memory_type<V>, V>;
                constexpr auto Size = reflect<X>::size;
                if constexpr (Size > 0) {
+                  constexpr auto& HashInfo = hash_info<keys_t>;
                   for (size_t J = 0; J < Size; ++J) {
                      sv key = reflect<X>::keys[J];
-                     const auto index = decode_hash_with_size<JSON, keys_t, HashInfo, HashInfo.type>::op(
-                        key.data(), key.data() + key.size(), key.size());
+                     const auto index =
+                        decode_hash_with_size<JSON, keys_t, HashInfo, HashInfo.type>::op(
+                           key.data(), key.data() + key.size(), key.size());
                      if (index < K) {
                         bits[index][I] = true;
                      }

include/glaze/ext/glaze_asio.hpp

@@ -717,6 +717,7 @@ namespace glz
                   thread.join();
                }
             }
+            delete ptr;
          });
 
          threads->reserve(concurrency - uint32_t(run_on_main_thread));

include/glaze/net/http_server.hpp

@@ -2463,74 +2463,110 @@ namespace glz
    namespace streaming_utils
    {
       // Create a periodic data sender (works with both HTTP and HTTPS)
+      // Uses enable_shared_from_this to avoid circular reference memory leaks
       template <typename T>
       void send_periodic_data(std::shared_ptr<streaming_connection_interface> conn, std::function<T()> data_generator,
                               std::chrono::milliseconds interval, size_t max_events = 0)
       {
-         auto counter = std::make_shared<size_t>(0);
          if (!conn || !conn->is_open()) return;
-         auto timer = std::make_shared<asio::steady_timer>(conn->get_executor());
 
-         // Use shared_ptr to safely handle recursive lambda calls and avoid compiler-specific segfaults
-         auto send_next = std::make_shared<std::function<void()>>();
-         *send_next = [conn, timer, counter, data_generator, interval, max_events, send_next]() mutable {
-            if (!conn->is_open() || (max_events > 0 && *counter >= max_events)) {
-               conn->close();
-               return;
-            }
+         struct periodic_sender : std::enable_shared_from_this<periodic_sender>
+         {
+            std::shared_ptr<streaming_connection_interface> conn;
+            std::shared_ptr<asio::steady_timer> timer;
+            std::function<T()> data_generator;
+            std::chrono::milliseconds interval;
+            size_t max_events;
+            size_t counter = 0;
+
+            periodic_sender(std::shared_ptr<streaming_connection_interface> c, std::function<T()> gen,
+                            std::chrono::milliseconds intv, size_t max_ev)
+               : conn(std::move(c)),
+                 timer(std::make_shared<asio::steady_timer>(conn->get_executor())),
+                 data_generator(std::move(gen)),
+                 interval(intv),
+                 max_events(max_ev)
+            {}
+
+            void send_next()
+            {
+               if (!conn->is_open() || (max_events > 0 && counter >= max_events)) {
+                  conn->close();
+                  return;
+               }
 
-            try {
-               T data = data_generator();
-               conn->send_json_event(data, "data", std::to_string(*counter), [=](std::error_code ec) mutable {
-                  if (!ec) {
-                     (*counter)++;
-                     timer->expires_after(interval);
-                     timer->async_wait([send_next, timer, counter](std::error_code) { (*send_next)(); });
-                  }
-                  else {
-                     conn->close();
-                  }
-               });
-            }
-            catch (const std::exception&) {
-               conn->close();
+               try {
+                  T data = data_generator();
+                  conn->send_json_event(
+                     data, "data", std::to_string(counter), [self = this->shared_from_this()](std::error_code ec) {
+                        if (!ec) {
+                           self->counter++;
+                           self->timer->expires_after(self->interval);
+                           self->timer->async_wait(
+                              [self](std::error_code) { self->send_next(); });
+                        }
+                        else {
+                           self->conn->close();
+                        }
+                     });
+               }
+               catch (const std::exception&) {
+                  conn->close();
+               }
             }
          };
 
-         (*send_next)();
+         auto sender = std::make_shared<periodic_sender>(conn, std::move(data_generator), interval, max_events);
+         sender->send_next();
       }
 
       // Create a data stream from a collection (works with both HTTP and HTTPS)
+      // Uses enable_shared_from_this to avoid circular reference memory leaks
+      // Note: Makes a copy of the container to ensure data outlives the async operation
       template <typename Container>
       void stream_collection(std::shared_ptr<streaming_connection_interface> conn, const Container& data,
                              std::chrono::milliseconds delay_between_items = std::chrono::milliseconds(10))
       {
-         auto it = std::make_shared<typename Container::const_iterator>(data.begin());
-         auto end_it = data.end();
          if (!conn || !conn->is_open()) return;
-         auto timer = std::make_shared<asio::steady_timer>(conn->get_executor());
-
-         // Use shared_ptr to safely handle recursive lambda calls and avoid compiler-specific segfaults
-         auto send_next = std::make_shared<std::function<void()>>();
-         *send_next = [conn, timer, it, end_it, delay_between_items, send_next]() mutable {
-            if (!conn->is_open() || *it == end_it) {
-               conn->close();
-               return;
-            }
 
-            conn->send_json_event(**it, "item", "", [=](std::error_code ec) mutable {
-               if (!ec) {
-                  ++(*it);
-                  timer->expires_after(delay_between_items);
-                  timer->async_wait([send_next, timer, it](std::error_code) { (*send_next)(); });
-               }
-               else {
+         struct collection_sender : std::enable_shared_from_this<collection_sender>
+         {
+            std::shared_ptr<streaming_connection_interface> conn;
+            std::shared_ptr<asio::steady_timer> timer;
+            Container data;
+            typename Container::const_iterator it;
+            std::chrono::milliseconds delay;
+
+            collection_sender(std::shared_ptr<streaming_connection_interface> c, Container d, std::chrono::milliseconds dl)
+               : conn(std::move(c)),
+                 timer(std::make_shared<asio::steady_timer>(conn->get_executor())),
+                 data(std::move(d)),
+                 it(data.begin()),
+                 delay(dl)
+            {}
+
+            void send_next()
+            {
+               if (!conn->is_open() || it == data.end()) {
                   conn->close();
+                  return;
                }
-            });
+
+               conn->send_json_event(*it, "item", "", [self = this->shared_from_this()](std::error_code ec) {
+                  if (!ec) {
+                     ++self->it;
+                     self->timer->expires_after(self->delay);
+                     self->timer->async_wait([self](std::error_code) { self->send_next(); });
+                  }
+                  else {
+                     self->conn->close();
+                  }
+               });
+            }
          };
 
-         (*send_next)();
+         auto sender = std::make_shared<collection_sender>(conn, data, delay_between_items);
+         sender->send_next();
       }
    } // namespace streaming_utils
 

tests/networking_tests/http_client_test/http_client_test.cpp

@@ -211,32 +211,49 @@ class working_test_server
       });
 
       // Endpoint that sends data periodically, for testing client disconnect
+      // Uses enable_shared_from_this to avoid circular reference memory leaks
       server_.stream_get("/slow-stream", [](request&, streaming_response& res) {
          res.start_stream(200, {{"Content-Type", "text/plain"}});
-         auto conn = res.stream;
 
-         auto timer = std::make_shared<asio::steady_timer>(conn->get_executor());
-         auto counter = std::make_shared<int>(0);
+         struct slow_stream_handler : std::enable_shared_from_this<slow_stream_handler>
+         {
+            std::shared_ptr<streaming_connection_interface> conn;
+            std::shared_ptr<asio::steady_timer> timer;
+            int counter = 0;
 
-         // Use shared_ptr to safely handle recursive lambda calls and avoid compiler-specific segfaults
-         auto send_data = std::make_shared<std::function<void(const std::error_code&)>>();
-         *send_data = [conn, timer, counter, send_data](const std::error_code& ec) {
-            if (ec || !conn->is_open() || *counter >= 10) {
-               if (conn->is_open()) conn->close();
-               return;
+            explicit slow_stream_handler(std::shared_ptr<streaming_connection_interface> c)
+               : conn(std::move(c)), timer(std::make_shared<asio::steady_timer>(conn->get_executor()))
+            {}
+
+            void start()
+            {
+               timer->async_wait([self = shared_from_this()](const std::error_code& ec) { self->on_timer(ec); });
             }
 
-            conn->send_chunk("chunk" + std::to_string((*counter)++) + ";",
-                             [conn, timer, send_data](std::error_code write_ec) {
-                                if (write_ec || !conn->is_open()) {
-                                   if (conn->is_open()) conn->close();
-                                   return;
-                                }
-                                timer->expires_after(std::chrono::milliseconds(50));
-                                timer->async_wait(*send_data);
-                             });
+            void on_timer(const std::error_code& ec)
+            {
+               if (ec || !conn->is_open() || counter >= 10) {
+                  if (conn->is_open()) conn->close();
+                  return;
+               }
+
+               conn->send_chunk("chunk" + std::to_string(counter++) + ";",
+                                [self = shared_from_this()](std::error_code write_ec) { self->on_write(write_ec); });
+            }
+
+            void on_write(std::error_code write_ec)
+            {
+               if (write_ec || !conn->is_open()) {
+                  if (conn->is_open()) conn->close();
+                  return;
+               }
+               timer->expires_after(std::chrono::milliseconds(50));
+               timer->async_wait([self = shared_from_this()](const std::error_code& ec) { self->on_timer(ec); });
+            }
          };
-         timer->async_wait(*send_data);
+
+         auto handler = std::make_shared<slow_stream_handler>(res.stream);
+         handler->start();
       });
 
       // Endpoint that immediately returns an error