Bump version to 1.9.11

Fix compile warning (#2337 )
chore(workflow): upgrade Windows image and re-enable tests on Windows (#2336 )
2025-06-23 00:00:30 -04:00 · 2025-06-20 16:51:27 +08:00 · 2025-06-18 17:43:25 +08:00 · 2025-06-18 15:47:28 +08:00 · 2025-06-17 23:15:47 +08:00 · 2025-06-05 13:52:33 +08:00
85 changed files with 2157 additions and 412 deletions
--- a/.github/workflows/cmake.yml
+++ b/.github/workflows/cmake.yml
@ -17,7 +17,7 @@ env:
 jobs:
  windows:
    name: windows/msvc - ${{ matrix.link }}
-    runs-on: windows-2019
+    runs-on: windows-2022
    strategy:
      fail-fast: false
      matrix:
@ -44,9 +44,6 @@ jobs:
      - name: Create Build Environment & Configure Cmake
        shell: bash
        working-directory: ./build
-        # For unknown reasons, we fail to create file in windows ci environment.
-        # So examples, drogon_ctl and integration tests can not be built in windows ci.
-        # We should try to enable them again in the future.
        run: |
          [[ ${{ matrix.link }} == "SHARED" ]] && shared="ON" || shared="OFF"
          cmake ..                                         \
@ -54,8 +51,8 @@ jobs:
            -DBUILD_TESTING=on                             \
            -DBUILD_SHARED_LIBS=$shared                    \
            -DCMAKE_TOOLCHAIN_FILE="conan_toolchain.cmake" \
-            -DBUILD_CTL=OFF                                \
-            -DBUILD_EXAMPLES=OFF                           \
+            -DBUILD_CTL=ON                                 \
+            -DBUILD_EXAMPLES=ON                            \
            -DUSE_SPDLOG=ON                                \
            -DCMAKE_INSTALL_PREFIX=../install              \
            -DCMAKE_POLICY_DEFAULT_CMP0091=NEW             \
@ -73,7 +70,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        osver: [12, 13]
+        osver: [13, 14, 15]
    steps:
      - name: Checkout Drogon source code
        uses: actions/checkout@v4
@ -102,7 +99,6 @@ jobs:

      - name: Prepare for testing
        run: |
-          brew tap homebrew/services
          brew services restart postgresql@14
          brew services start mariadb
          brew services start redis
--- a/.github/workflows/codespell.yml
+++ b/.github/workflows/codespell.yml
@ -11,5 +11,5 @@ jobs:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
-    - run: pip install --user codespell[toml]
-    - run: codespell --ignore-words-list="coo,folx,ot,statics,xwindows,NotIn," --skip="*.csp"
+    - run: sudo apt-get install -y codespell
+    - run: codespell --ignore-words-list="coo,folx,ot,statics,xwindows,NotIn,aNULL," --skip="*.csp"
--- a/.github/workflows/cpp.yml
+++ b/.github/workflows/cpp.yml
@ -30,7 +30,7 @@ jobs:
          CLANG_FORMAT: clang-format-17

  cpplint:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

--- a/.github/workflows/docker-publish.yml
+++ b/.github/workflows/docker-publish.yml
@ -0,0 +1,28 @@
+name: Build and Push Docker Image
+
+on:
+  release:
+    types: [created]  # 当新版本被创建时触发
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Build Docker image
+        run: |
+          cd docker/ubuntu
+          docker build -t drogonframework/drogon:latest .
+
+      - name: Push Docker image
+        run: |
+          docker push drogonframework/drogon:latest
--- a/.gitignore
+++ b/.gitignore
@ -35,7 +35,6 @@ build/
 cmake-build-debug/
 cmake-build-debug-visual-studio/
 .idea/
-lib/inc/drogon/version.h
 html/
 latex/
 .vscode
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.5...3.31)

 project(drogon)

@ -13,6 +13,7 @@ option(BUILD_DOC "Build Doxygen documentation" OFF)
 option(BUILD_BROTLI "Build Brotli" ON)
 option(BUILD_YAML_CONFIG "Build yaml config" ON)
 option(USE_SUBMODULE "Use trantor as a submodule" ON)
+option(USE_STATIC_LIBS_ONLY "Use only static libraries as dependencies" OFF)

 include(CMakeDependentOption)
 CMAKE_DEPENDENT_OPTION(BUILD_POSTGRESQL "Build with postgresql support" ON "BUILD_ORM" OFF)
@ -24,7 +25,7 @@ CMAKE_DEPENDENT_OPTION(USE_SPDLOG "Allow using the spdlog logging library" OFF "

 set(DROGON_MAJOR_VERSION 1)
 set(DROGON_MINOR_VERSION 9)
-set(DROGON_PATCH_VERSION 6)
+set(DROGON_PATCH_VERSION 11)
 set(DROGON_VERSION
    ${DROGON_MAJOR_VERSION}.${DROGON_MINOR_VERSION}.${DROGON_PATCH_VERSION})
 set(DROGON_VERSION_STRING "${DROGON_VERSION}")
@ -41,7 +42,7 @@ set(INSTALL_DROGON_CMAKE_DIR ${DEF_INSTALL_DROGON_CMAKE_DIR}
 if (CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
  # Force MSVC to use UTF-8 because that's what we use. Otherwise it uses
  # the default of whatever Windows sets and causes encoding issues.
-  message(STATUS "You are using MSVC. Forceing to use UTF-8")
+  message(STATUS "You are using MSVC. Forcing to use UTF-8")
  add_compile_options("$<$<C_COMPILER_ID:MSVC>:/utf-8>")
  add_compile_options("$<$<CXX_COMPILER_ID:MSVC>:/utf-8>")
  if (MSVC_VERSION GREATER_EQUAL 1914)
@ -77,6 +78,10 @@ if (BUILD_SHARED_LIBS)
    endif ()
 endif (BUILD_SHARED_LIBS)

+if(USE_STATIC_LIBS_ONLY)
+    set(CMAKE_FIND_LIBRARY_SUFFIXES "${CMAKE_STATIC_LIBRARY_SUFFIX}")
+endif(USE_STATIC_LIBS_ONLY)
+
 if(USE_SPDLOG)
  find_package(spdlog CONFIG)
  if(spdlog_FOUND)
@ -116,6 +121,7 @@ endif()
 target_include_directories(
    ${PROJECT_NAME}
    PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/lib/inc>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/lib/inc>
    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/orm_lib/inc>
    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/nosql_lib/redis/inc>
    $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}>
@ -337,21 +343,21 @@ set(private_headers
    lib/src/ConfigAdapter.h
    lib/src/MultipartStreamParser.h)

-if (NOT WIN32)
+if (NOT WIN32 AND NOT CMAKE_SYSTEM_NAME STREQUAL "iOS")
    set(DROGON_SOURCES
        ${DROGON_SOURCES}
        lib/src/SharedLibManager.cc)
    set(private_headers
        ${private_headers}
        lib/src/SharedLibManager.h)
-else (NOT WIN32)
+elseif(WIN32)
    set(DROGON_SOURCES
        ${DROGON_SOURCES}
        third_party/mman-win32/mman.c)
    set(private_headers
        ${private_headers}
        third_party/mman-win32/mman.h)
-endif (NOT WIN32)
+endif()

 if (BUILD_POSTGRESQL)
    # find postgres
@ -505,7 +511,7 @@ execute_process(COMMAND "git" rev-parse HEAD
    OUTPUT_VARIABLE GIT_SHA1
    ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
 configure_file("${PROJECT_SOURCE_DIR}/cmake/templates/version.h.in"
-    "${PROJECT_SOURCE_DIR}/lib/inc/drogon/version.h" @ONLY)
+    "${CMAKE_CURRENT_BINARY_DIR}/lib/inc/drogon/version.h" @ONLY)

 if (DROGON_CXX_STANDARD EQUAL 20)
    option(USE_COROUTINE "Enable C++20 coroutine support" ON)
@ -578,7 +584,7 @@ set(DROGON_HEADERS
    lib/inc/drogon/WebSocketConnection.h
    lib/inc/drogon/WebSocketController.h
    lib/inc/drogon/drogon.h
-    lib/inc/drogon/version.h
+    ${CMAKE_CURRENT_BINARY_DIR}/lib/inc/drogon/version.h
    lib/inc/drogon/drogon_callbacks.h
    lib/inc/drogon/PubSubService.h
    lib/inc/drogon/drogon_test.h
--- a/CPPLINT.cfg
+++ b/CPPLINT.cfg
@ -10,8 +10,9 @@ filter=-runtime/references
 # CHECK macros are from Drogon, not Google Test.
 filter=-readability/check

-# Don't warn about the use of C++11 features.
+# Don't warn about the use of C++11 or C++17 features.
 filter=-build/c++11
+filter=-build/c++17

 filter=-build/include_subdir

--- a/ChangeLog.md
+++ b/ChangeLog.md
@ -4,6 +4,151 @@ All notable changes to this project will be documented in this file.

 ## [Unreleased]

+## [1.9.11] - 2025-06-20
+
+### API changes list
+
+- Add a new overload for execSqlCoro.
+
+### Changed
+
+- Do not write to source directory during build.
+
+- Improve Postgres connection stability.
+
+- Add handleFatalError in handleClosed.
+
+- Add -o|--output option to drogon_ctl create models.
+
+- Add qrcode for WeChat official account to the README file.
+
+- Support for iOS compiling.
+
+- Add cors example to demonstrate cross-origin support in drogon.
+
+- Add support for continuation frame in WebSocketMessageParser.
+
+- Add RawParameter API to pass raw SQL parameters.
+
+- Upgrade Windows image and re-enable tests on Windows.
+
+### Fixed
+
+- Fix a bug in isAutoCreationClass<T>.
+
+- Fix CI on MacOS.
+
+- Fix issue with precision loss of double-type parameters in ORM inputs.
+
+
+## [1.9.10] - 2025-02-20
+
+### API changes list
+
+- Add setConnectionCallback.
+
+### Changed
+
+- ORM:Avoid unnecessary copies when returning search results.
+
+- Improve the zh-TW README translation.
+
+- Make quit function thread safe.
+
+- Added path_exempt in AccessLogger plugin config to exclude desired paths.
+
+### Fixed
+
+- Fix the issue in view generation by including the missing header file.
+
+- Fix ci: codespell.
+
+## [1.9.9] - 2025-01-01
+
+### API changes list
+
+- Added Partitioned flag for cookies.
+
+### Changed
+
+- Update FindFilesystem.cmake to check for GNU instead of GCC for CMAKE_CXX_COMPILER_ID.
+
+- Update README.
+
+- Chore(workflow/cmake.yml): upgrade macos runner.
+
+- Add emptiness check to the LogStream &operator<< with std::string_view.
+
+### Fixed
+
+- Fix a bug in plugin Redirector.
+
+- Fix CMAKE issues mentioned in #2144 and a linking problem which manifest with gcc12.3 when building with shared libs.
+
+- Fix: Remove dependency on locales being installed on the system.
+
+## [1.9.8] - 2024-10-27
+
+### API changes list
+
+- Add in-place base64 encode and decode.
+
+- Add check the client connection status.
+
+### Changed
+
+- Add Hodor whitelists.
+
+- Include exception header for std::exception_ptr.
+
+- Add support for escaped identifiers in Postgresql.
+
+- Remove content-length header from 101 Switching Protocols response.
+
+- Remove websocketResponseTest from windows shared library env.
+
+- Optimize query params and allow for empty values.
+
+- Replace rejection sampling and remove use of rand().
+
+- Add sending customized http requests to drogon_ctl.
+
+### Fixed
+
+- Fix coroutine continuation handle.
+
+- Fix some bugs in plugin PromExporter.
+
+- Fix a bug after removing content-length header in some responses.
+
+## [1.9.7] - 2024-09-10
+
+### API changes list
+
+- Add coroutine mutex.
+
+- Add requestsBufferSize function.
+
+- Refine SQLite3 error types with new exception handling.
+
+- Add a new method to reload SSL files on the fly.
+
+### Changed
+
+- Allow MultiPartParser to be movable.
+
+- Add quotes to the table name in the ORM generator.
+
+- Change stoi to stoul in the Field class.
+
+- Modernize cookies.
+
+- Change a log level.
+
+### Fixed
+
+- Use correct libraries when compiling statically.
+
 ## [1.9.6] - 2024-07-20

 ### API changes list
@ -375,7 +520,7 @@ All notable changes to this project will be documented in this file.

 - Remove unused CI files and Jekyll config.

- Ensure that all filters, AOP advices, and handlers are executed within the IO threads.
+- Ensure that all filters, AOP advice, and handlers are executed within the IO threads.

 - Update test.sh and build.sh by appending prefix "X" to string variable comparisons.

@ -707,7 +852,7 @@ All notable changes to this project will be documented in this file.

 - Check HTTP client is not sending requests in sync mode on the same event loop.

- Start listening after beginning advices.
+- Start listening after beginning advice.

 - Allow using json_cpp in other sublibraries.

@ -1697,7 +1842,17 @@ All notable changes to this project will be documented in this file.

 ## [1.0.0-beta1] - 2019-06-11

-[Unreleased]: https://github.com/an-tao/drogon/compare/v1.9.6...HEAD
+[Unreleased]: https://github.com/an-tao/drogon/compare/v1.9.11...HEAD
+
+[1.9.11]: https://github.com/an-tao/drogon/compare/v1.9.10...v1.9.11
+
+[1.9.10]: https://github.com/an-tao/drogon/compare/v1.9.9...v1.9.10
+
+[1.9.9]: https://github.com/an-tao/drogon/compare/v1.9.8...v1.9.9
+
+[1.9.8]: https://github.com/an-tao/drogon/compare/v1.9.7...v1.9.8
+
+[1.9.7]: https://github.com/an-tao/drogon/compare/v1.9.6...v1.9.7

 [1.9.6]: https://github.com/an-tao/drogon/compare/v1.9.5...v1.9.6

--- a/README.md
+++ b/README.md
@ -1,6 +1,6 @@
 ![](https://github.com/an-tao/drogon/wiki/images/drogon-white17.jpg)

-[![Build Status](https://github.com/an-tao/drogon/workflows/Build%20Drogon/badge.svg?branch=master)](https://github.com/drogonframework/drogon/actions)
+[![Build Status](https://github.com/drogonframework/drogon/actions/workflows/cmake.yml/badge.svg?branch=master)](https://github.com/drogonframework/drogon/actions)
 [![Conan Center](https://img.shields.io/conan/v/drogon)](https://conan.io/center/recipes/drogon)
 [![Join the telegram group at https://t.me/joinchat/_mMNGv0748ZkMDAx](https://img.shields.io/badge/Telegram-2CA5E0?style=flat&logo=telegram&logoColor=white)](https://t.me/joinchat/_mMNGv0748ZkMDAx)
 [![Join our Discord](https://dcbadge.vercel.app/api/server/3DvHY6Ewuj?style=flat)](https://discord.gg/3DvHY6Ewuj)
@ -8,7 +8,7 @@

 English | [简体中文](./README.zh-CN.md) | [繁體中文](./README.zh-TW.md)
 ### Overview
-**Drogon** is a C++17/20 based HTTP application framework. Drogon can be used to easily build various types of web application server programs using C++. **Drogon** is the name of a dragon in the American TV series "Game of Thrones" that I really like.
+**Drogon** is a C++17/20 based HTTP application framework. Drogon can be used to easily build various types of web application server programs using C++. **Drogon** is the name of a dragon from the American TV series *Game of Thrones*, which I really enjoy.

 Drogon is a cross-platform framework, It supports Linux, macOS, FreeBSD, OpenBSD, HaikuOS, and Windows. Its main features are as follows:

@ -183,7 +183,7 @@ As you can see, users can use the `HttpController` to map paths and parameters a

 In addition, you can also find that all handler interfaces are in asynchronous mode, where the response is returned by a callback object. This design is for performance reasons because in asynchronous mode the drogon application can handle a large number of concurrent requests with a small number of threads.

-After compiling all of the above source files, we get a very simple web application. This is a good start. **For more information, please visit the [wiki](https://github.com/an-tao/drogon/wiki/ENG-01-Overview)**
+After compiling all of the above source files, we get a very simple web application. This is a good start. **For more information, please visit the [documentation](https://drogonframework.github.io/drogon-docs/#/) on GitHub**.

 ## Cross-compilation

--- a/README.zh-CN.md
+++ b/README.zh-CN.md
@ -1,6 +1,6 @@
 ![](https://github.com/an-tao/drogon/wiki/images/drogon-white17.jpg)

-[![Build Status](https://github.com/an-tao/drogon/workflows/Build%20Drogon/badge.svg?branch=master)](https://github.com/drogonframework/drogon/actions)
+[![Build Status](https://github.com/drogonframework/drogon/actions/workflows/cmake.yml/badge.svg?branch=master)](https://github.com/drogonframework/drogon/actions)
 [![Conan Center](https://img.shields.io/conan/v/drogon)](https://conan.io/center/recipes/drogon)
 [![Join the telegram group at https://t.me/joinchat/_mMNGv0748ZkMDAx](https://img.shields.io/badge/Telegram-2CA5E0?style=flat&logo=telegram&logoColor=white)](https://t.me/joinchat/_mMNGv0748ZkMDAx)
 [![Join our Discord](https://dcbadge.vercel.app/api/server/3DvHY6Ewuj?style=flat)](https://discord.gg/3DvHY6Ewuj)
@ -186,7 +186,7 @@ class User : public drogon::HttpController<User>

 另外，你可以发现前面所有的处理函数接口都是异步的，处理器的响应是通过回调对象返回的。这种设计是出于对高性能的考虑，因为在异步模式下，可以使用少量的线程（比如和处理器核心数相等的线程）处理大量的并发请求。

-编译上述的所有源文件后，我们得到了一个非常简单的web应用程序，这是一个不错的开始。**请访问[wiki](https://github.com/an-tao/drogon/wiki/CHN-01-概述)**
+编译上述的所有源文件后，我们得到了一个非常简单的web应用程序，这是一个不错的开始。**请访问GitHub上的[文档](https://drogonframework.github.io/drogon-docs/#/CHN/CHN-01-%E6%A6%82%E8%BF%B0)**

 ## 贡献方式

@ -197,3 +197,9 @@ class User : public drogon::HttpController<User>
 ## QQ交流群：1137909452

 欢迎交流探讨。
+
+## 微信公众号：
+
+![](https://github.com/an-tao/drogon/wiki/images/qrcode_wechat.jpg)
+
+会不定期推送一些Drogon的使用技巧和更新信息，欢迎关注。
--- a/README.zh-TW.md
+++ b/README.zh-TW.md
@ -1,6 +1,6 @@
 ![](https://github.com/an-tao/drogon/wiki/images/drogon-white17.jpg)

-[![Build Status](https://github.com/an-tao/drogon/workflows/Build%20Drogon/badge.svg?branch=master)](https://github.com/drogonframework/drogon/actions)
+[![Build Status](https://github.com/drogonframework/drogon/actions/workflows/cmake.yml/badge.svg?branch=master)](https://github.com/drogonframework/drogon/actions)
 [![Conan Center](https://img.shields.io/conan/v/drogon)](https://conan.io/center/recipes/drogon)
 [![Join the telegram group at https://t.me/joinchat/_mMNGv0748ZkMDAx](https://img.shields.io/badge/Telegram-2CA5E0?style=flat&logo=telegram&logoColor=white)](https://t.me/joinchat/_mMNGv0748ZkMDAx)
 [![Join our Discord](https://dcbadge.vercel.app/api/server/3DvHY6Ewuj?style=flat)](https://discord.gg/3DvHY6Ewuj)
@ -8,41 +8,42 @@

 [English](./README.md) | [简体中文](./README.zh-CN.md) | 繁體中文

-**Drogon**是一個基於C++17/20的Http應用框架，使用Drogon可以方便的使用C++構建各種類型的Web App伺服器程式。
-本版本庫是github上[Drogon](https://github.com/an-tao/drogon)的鏡像庫。 **Drogon**是作者非常喜歡的美劇《冰與火之歌：權力遊戲》中的一條龍的名字(漢譯作卓耿)，和龍有關但並不是dragon的誤寫，為了不至於引起不必要的誤會這裡說明一下。
+**Drogon** 是一個基於 C++17/20 的 HTTP 應用程式框架，使用 Drogon 可以方便地用 C++ 建立各種類型的 Web App 伺服器端程式。

-Drogon是一個跨平台框架，它支援Linux，也支援macOS、FreeBSD/OpenBSD、HaikuOS和Windows。它的主要特點如下：
+這個版本庫是 GitHub 上 [Drogon](https://github.com/an-tao/drogon) 的鏡像庫。**Drogon** 是作者非常喜歡的美劇《冰與火之歌：權力遊戲》中的一條龍的名字（中文譯作卓耿），和龍有關但並不是 dragon 的誤寫，為了避免不必要的誤會在此說明。

-* 網路層使用基於epoll(macOS/FreeBSD下是kqueue)的非阻塞IO框架，提供高並發、高性能的網路IO。詳細請見[TFB Tests Results](https://www.techempower.com/benchmarks/#section=data-r19&hw=ph&test=composite)；
-* 全異步程式設計；
-* 支援Http1.0/1.1(server端和client端)；
-* 基於模板(template)實現了簡單的反射機制，使主程式框架、控制器(controller)和視圖(view)完全去耦；
+Drogon 是一個跨平台框架，支援 Linux、macOS、FreeBSD/OpenBSD、HaikuOS 和 Windows。主要特點如下：
+
+* 網路層使用基於 epoll（macOS/FreeBSD 下是 kqueue）的非阻塞 IO 框架，提供高並行、高效能的網路 IO。詳細請見 [TFB Tests Results](https://www.techempower.com/benchmarks/#section=data-r19&hw=ph&test=composite)；
+* 完全非同步的程式撰寫邏輯；
+* 支援 HTTP 1.0/1.1（伺服器端和用戶端）；
+* 基於樣板（template）實作的簡單反射機制，使主程式框架、控制器（controller）和視圖（view）完全解耦；
 * 支援 cookies 和內建的 session；
-* 支援後端渲染，把控制器生成的數據交給視圖生成Html頁面，視圖由CSP模板文件描述，通過CSP標籤把C++程式碼嵌入到Html頁面，由drogon的指令列工具在編譯階段自動生成C++程式碼並編譯；
-* 支援運行期的視圖頁面動態加載(動態編譯和載入so文件)；
-* 非常方便靈活的路徑(path)到控制器處理函數(handler)的映射方案；
-* 支援過濾器(filter)鏈，方便在控制器之前執行統一的邏輯(如登錄驗證、Http Method約束驗證等)；
-* 支援https(基於OpenSSL);
-* 支援websocket(server端和client端);
-* 支援Json格式的請求和回應, 方便開發Restful API;
-* 支援文件下載和上傳,支援sendfile系統呼叫；
-* 支援gzip/brotli壓縮傳輸；
+* 支援後端算繪，將控制器產生的資料交給視圖產生 HTML 頁面，視圖由 CSP 樣板檔案描述，透過 CSP 標籤將 C++ 程式碼嵌入 HTML 頁面，由 drogon 的命令列工具在編譯階段自動產生 C++ 程式碼並編譯；
+* 支援執行期的視圖頁面動態載入（動態編譯和載入 so 檔案）；
+* 非常方便靈活的路徑（path）到控制器處理函式（handler）的對應方案；
+* 支援過濾器（filter）鏈，方便在控制器之前執行統一的邏輯（如登入驗證、HTTP Method 限制驗證等）；
+* 支援 HTTPS（基於 OpenSSL）；
+* 支援 WebSocket（伺服器端和用戶端）；
+* 支援 JSON 格式的請求和回應，方便開發 RESTful API；
+* 支援檔案下載和上傳，支援 `sendfile` 系統呼叫；
+* 支援 Gzip/Brotli 壓縮傳輸；
 * 支援 pipelining；
-* 提供一個輕量的指令列工具drogon_ctl，幫助簡化各種類的創造和視圖程式碼的生成過程；
-* 非同步的讀寫資料庫，目前支援PostgreSQL和MySQL(MariaDB)資料庫；
-* 支援異步讀寫Redis;
-* 基於執行序池實現sqlite3資料庫的異步讀寫，提供與上文資料庫相同的接口；
+* 提供輕量的命令列工具 `drogon_ctl`，幫助簡化各種類別的建立和視圖程式碼的產生過程；
+* 非同步的讀寫資料庫，目前支援 PostgreSQL 和 MySQL（MariaDB）資料庫；
+* 支援非同步讀寫 Redis；
+* 基於執行緒池實作 sqlite3 資料庫的非同步讀寫，提供與上述資料庫相同的介面；
 * 支援 ARM 架構；
-* 方便的輕量級ORM實現，一般物件到資料庫的雙向映射；
-* 支援外掛，可通過設定文件在載入時動態載入；
-* 支援內建插入點的AOP
-* 支援C++ coroutine
+* 方便的輕量級 ORM 實現，一般物件到資料庫的雙向對應；
+* 支援外掛，可透過設定檔案在載入時動態載入；
+* 支援內建插入點的 AOP；
+* 支援 C++ coroutine。

 ## 一個非常簡單的例子

-不像大多數C++框架那樣，drogon的主程式可以非常簡單。 Drogon使用了一些小技巧使主程式和控制器去耦. 控制器的路由設定可以在控制器類別中定義或者設定文件中完成.
+不像大多數 C++ 框架，drogon 的主程式可以非常簡單。Drogon 使用了一些小技巧使主程式和控制器解耦。控制器的路由設定可以在控制器類別中定義或在設定檔案中完成。

-下面是一個典型的主程式的樣子:
+下面是一個典型主程式的樣子：

 ```c++
 #include <drogon/drogon.h>
@ -58,7 +59,7 @@ int main()
 }
 ```

-如果使用設定文件，可以進一步簡化成這樣:
+如果使用設定檔案，可以進一步簡化成：

 ```c++
 #include <drogon/drogon.h>
@ -69,7 +70,7 @@ int main()
 }
 ```

-當然，Drogon也提供了一些函數，使使用者可以在main()函數中直接添加控制器邏輯，比如，使用者可以註冊一個lambda處理器到drogon框架中，如下所示：
+當然，Drogon 也提供了一些函式，讓使用者可以在 `main()` 函式中直接加入控制器邏輯，例如，使用者可以註冊一個 lambda 處理常式到 drogon 框架中，如下所示：

 ```c++
 app().registerHandler("/test?username={name}",
@ -86,9 +87,7 @@ app().registerHandler("/test?username={name}",
                    {Get,"LoginFilter"});
 ```

-
-這看起來是很方便，但是這並不適用於復雜的場景，試想假如有數十個或者數百個處理函數要註冊進框架，main()函數將膨脹到不可讀的程度。顯然，讓每個包含處理函數的類在自己的定義中完成註冊是更好的選擇。所以，除非你的應用邏輯非常簡單，我們不推薦使用上述接口，更好的實踐是，我們可以創造一個HttpSimpleController類別，如下：
-
+這看起來很方便，但不適用於複雜的場景，試想如果有數十個或數百個處理函式要註冊進框架，`main()` 函式將變得難以閱讀。顯然，讓每個包含處理函式的類別在自己的定義中完成註冊是更好的選擇。所以，除非你的應用邏輯非常簡單，我們不建議使用上述介面，更好的做法是建立一個 HttpSimpleController 類別，如下：

 ```c++
 /// The TestCtrl.h file
@ -117,9 +116,9 @@ void TestCtrl::asyncHandleHttpRequest(const HttpRequestPtr& req,
 }
 ```

-**上面程式的大部分程式碼都可以由`drogon_ctl`指令創造**（這個指令是`drogon_ctl create controller TestCtr`）。使用者所需做的就是添加自己的業務邏輯。在這個例子中，當客戶端訪問URL`http://ip/test`時，控制器簡單的回傳了一個`Hello, world!`頁面。
+**上述程式的大部分程式碼都可以由 `drogon_ctl` 指令產生**（使用指令 `drogon_ctl create controller TestCtr`）。使用者只需要加入自己的業務邏輯。在這個範例中，當用戶端存取 URL `http://ip/test` 時，控制器簡單地回傳一個 `Hello, world!` 頁面。

-對於JSON格式的回應，我們可以像下面這樣創造控制器：
+對於 JSON 格式的回應，我們可以這樣建立控制器：

 ```c++
 /// The header file
@ -148,7 +147,7 @@ void JsonCtrl::asyncHandleHttpRequest(const HttpRequestPtr &req,
 }
 ```

-讓我們更進一步，通過HttpController類別創造一個RESTful API的例子，如下所示（忽略了實做文件）：
+讓我們更進一步，透過 HttpController 類別建立一個 RESTful API 的範例，如下所示（省略實作檔案）：

 ```c++
 /// The header file
@ -182,18 +181,18 @@ class User : public drogon::HttpController<User>
 } // namespace api
 ```

-如你所見，通過`HttpController`類別，使用者可以同時映射路徑和路徑參數，這對RESTful API應用來說非常方便。
+如你所見，透過 `HttpController` 類別，使用者可以同時對應路徑和路徑參數，這對 RESTful API 應用來說非常方便。

-另外，你可以發現前面所有的處理函數接口都是異步的，處理器的回應是通過回調對象回傳的。這種設計是出於對高性能的考慮，因為在異步模式下，可以使用少量的執行序（比如和處理器核心數相等的執行序）處理大量的並發請求。
+另外，你可以發現前面所有的處理函式介面都是非同步的，處理器的回應是透過回呼物件回傳的。這種設計是考慮到效能，因為在非同步模式下，可以使用少量的執行緒（例如和處理器核心數相等的執行緒）處理大量的並行請求。

-編譯上述的所有源文件後，我們得到了一個非常簡單的web應用程式，這是一個不錯的開始。 **請瀏覽[wiki](https://github.com/an-tao/drogon/wiki/CHN-01-概述)**
+編譯上述所有原始檔案後，我們得到了一個非常簡單的網頁應用程式，這是一個不錯的開始。**請瀏覽 GitHub 上的[文件](https://drogonframework.github.io/drogon-docs/#/CHN/CHN-01-%E6%A6%82%E8%BF%B0)**

 ## 貢獻方式

-歡迎您的貢獻。請閱讀[貢獻指南](CONTRIBUTING.md)以獲取更多的信息。
+歡迎您的貢獻。請閱讀[貢獻指南](CONTRIBUTING.md)以取得更多資訊。

 <a href="https://github.com/drogonframework/drogon/graphs/contributors"><img src="https://contributors-svg.opencollective.com/drogon/contributors.svg?width=890&button=false" alt="Code contributors" /></a>

 ## QQ 交流群：1137909452

-歡迎交流探討。
+歡迎交流討論。
--- a/cmake/ParseAndAddDrogonTests.cmake
+++ b/cmake/ParseAndAddDrogonTests.cmake
@ -17,7 +17,7 @@
 #        ParseAndAddDrogonTests(${PROJECT_NAME})                                                   #
 #==================================================================================================#

-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.5...3.31)

 # This removes the contents between
 #  - block comments (i.e. /* ... */) 
--- a/cmake_modules/FindFilesystem.cmake
+++ b/cmake_modules/FindFilesystem.cmake
@ -212,7 +212,7 @@ if(CXX_FILESYSTEM_HAVE_FS)
    ]] code @ONLY)

    # HACK: Needed to compile correctly on Yocto Linux
-    if(CMAKE_CXX_COMPILER_ID STREQUAL "GCC" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang"
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang"
        OR CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
        set(CMAKE_REQUIRED_FLAGS ${prev_req_flags} -std=c++17)
    endif ()
--- a/cmake_modules/FindJsoncpp.cmake
+++ b/cmake_modules/FindJsoncpp.cmake
@ -51,7 +51,9 @@ if(Jsoncpp_FOUND)
      COMMAND awk "{ printf \$3 }"
      COMMAND sed -e "s/\"//g"
      OUTPUT_VARIABLE jsoncpp_ver)
+    if(NOT Jsoncpp_FIND_QUIETLY)
      message(STATUS "jsoncpp version:" ${jsoncpp_ver})
+    endif()
    if(jsoncpp_ver LESS 1.7)
      message(
        FATAL_ERROR
--- a/drogon_ctl/create.cc
+++ b/drogon_ctl/create.cc
@ -42,7 +42,8 @@ std::string create::detail()
           "create a plugin named class_name\n\n"
           "drogon_ctl create project <project_name> //"
           "create a project named project_name\n\n"
-           "drogon_ctl create model <model_path> [--table=<table_name>] [-f]//"
+           "drogon_ctl create model <model_path> [-o <output path>] "
+           "[--table=<table_name>] [-f]//"
           "create model classes in model_path\n";
 }

--- a/drogon_ctl/create_model.cc
+++ b/drogon_ctl/create_model.cc
@ -66,6 +66,17 @@ static std::string escapeConnString(const std::string &str)
    return escaped;
 }

+std::string drogon_ctl::escapeIdentifier(const std::string &identifier,
+                                         const std::string &rdbms)
+{
+    if (rdbms != "postgresql")
+    {
+        return identifier;
+    }
+
+    return "\\\"" + identifier + "\\\"";
+}
+
 static std::map<std::string, std::vector<ConvertMethod>> getConvertMethods(
    const Json::Value &convertColumns)
 {
@ -166,7 +177,7 @@ void create_model::createModelClassFromPG(
    auto className = nameTransform(tableName, true);
    HttpViewData data;
    data["className"] = className;
-    data["tableName"] = toLower(tableName);
+    data["tableName"] = tableName;
    data["hasPrimaryKey"] = (int)0;
    data["primaryKeyName"] = "";
    data["dbName"] = dbname_;
@ -460,7 +471,7 @@ void create_model::createModelClassFromMysql(
    data["convertMethods"] = convertMethods;
    std::vector<ColumnInfo> cols;
    int i = 0;
-    *client << "desc " + tableName << Mode::Blocking >>
+    *client << "desc `" + tableName + "`" << Mode::Blocking >>
        [&i, &cols](bool isNull,
                    const std::string &field,
                    const std::string &type,
@ -815,6 +826,7 @@ void create_model::createModel(const std::string &path,
    auto restfulApiConfig = config["restful_api_controllers"];
    auto relationships = getRelationships(config["relationships"]);
    auto convertMethods = getConvertMethods(config["convert"]);
+    drogon::utils::createPath(path);
    if (dbType == "postgresql")
    {
 #if USE_POSTGRESQL
@ -1162,7 +1174,9 @@ void create_model::createModel(const std::string &path,
        try
        {
            infile >> configJsonRoot;
-            createModel(path, configJsonRoot, singleModelName);
+            createModel(outputPath_.empty() ? path : outputPath_,
+                        configJsonRoot,
+                        singleModelName);
        }
        catch (const std::exception &exception)
        {
@ -1200,6 +1214,22 @@ void create_model::handleCommand(std::vector<std::string> &parameters)
            break;
        }
    }
+    for (auto iter = parameters.begin(); iter != parameters.end();)
+    {
+        auto &file = *iter;
+        if (file == "-o" || file == "--output")
+        {
+            iter = parameters.erase(iter);
+            if (iter != parameters.end())
+            {
+                outputPath_ = *iter;
+                iter = parameters.erase(iter);
+            }
+            continue;
+        }
+        ++iter;
+    }
+
    for (auto const &path : parameters)
    {
        createModel(path, singleModelName);
--- a/drogon_ctl/create_model.h
+++ b/drogon_ctl/create_model.h
@ -78,6 +78,9 @@ inline std::string nameTransform(const std::string &origName, bool isType)
    return ret;
 }

+std::string escapeIdentifier(const std::string &identifier,
+                             const std::string &rdbms);
+
 class PivotTable
 {
  public:
@ -426,5 +429,6 @@ class create_model : public DrObject<create_model>, public CommandHandler
                                    const Json::Value &restfulApiConfig);
    std::string dbname_;
    bool forceOverwrite_{false};
+    std::string outputPath_;
 };
 }  // namespace drogon_ctl
--- a/drogon_ctl/create_view.cc
+++ b/drogon_ctl/create_view.cc
@ -411,6 +411,7 @@ void create_view::newViewSourceFile(std::ofstream &file,
            "automatically,don't modify it!\n";
    file << "#include \"" << namespacePrefix << className << ".h\"\n";
    file << "#include <drogon/utils/OStringStream.h>\n";
+    file << "#include <drogon/utils/Utilities.h>\n";
    file << "#include <string>\n";
    file << "#include <map>\n";
    file << "#include <vector>\n";
--- a/drogon_ctl/press.cc
+++ b/drogon_ctl/press.cc
@ -19,6 +19,10 @@
 #include <memory>
 #include <iomanip>
 #include <cstdlib>
+#include <json/json.h>
+#include <fstream>
+#include <string>
+#include <unordered_map>
 #ifndef _WIN32
 #include <unistd.h>
 #endif
@ -33,9 +37,10 @@ std::string press::detail()
           "  -t num    number of threads(default : 1)\n"
           "  -c num    concurrent connections(default : 1)\n"
           "  -k        disable SSL certificate validation(default: enable)\n"
+           "  -f        customize http request json file(default: disenable)\n"
           "  -q        no progress indication(default: show)\n\n"
           "example: drogon_ctl press -n 10000 -c 100 -t 4 -q "
-           "http://localhost:8080/index.html\n";
+           "http://localhost:8080/index.html -f ./http_request.json\n";
 }

 void outputErrorAndExit(const std::string_view &err)
@ -151,6 +156,24 @@ void press::handleCommand(std::vector<std::string> &parameters)
                continue;
            }
        }
+        else if (param.find("-f") == 0)
+        {
+            if (param == "-f")
+            {
+                ++iter;
+                if (iter == parameters.end())
+                {
+                    outputErrorAndExit("No http request json file!");
+                }
+                httpRequestJsonFile_ = *iter;
+                continue;
+            }
+            else
+            {
+                httpRequestJsonFile_ = param.substr(2);
+                continue;
+            }
+        }
        else if (param == "-k")
        {
            certValidation_ = false;
@ -190,6 +213,118 @@ void press::handleCommand(std::vector<std::string> &parameters)
            path_ = url_.substr(posOfPath);
        }
    }
+
+    /*
+    http_request.json
+    {
+        "method": "POST",
+        "header": {
+            "token": "e2e9d0fe-dd14-4eaf-8ac1-0997730a805d"
+        },
+        "body": {
+            "passwd": "123456",
+            "account": "10001"
+        }
+    }
+    */
+    if (!httpRequestJsonFile_.empty())
+    {
+        Json::Value httpRequestJson;
+        std::ifstream httpRequestFile(httpRequestJsonFile_,
+                                      std::ifstream::binary);
+        if (!httpRequestFile.is_open())
+        {
+            outputErrorAndExit(std::string{"No "} + httpRequestJsonFile_);
+        }
+        httpRequestFile >> httpRequestJson;
+
+        if (!httpRequestJson.isMember("method"))
+        {
+            outputErrorAndExit("No contain method");
+        }
+
+        auto methodStr = httpRequestJson["method"].asString();
+        std::transform(methodStr.begin(),
+                       methodStr.end(),
+                       methodStr.begin(),
+                       ::toupper);
+
+        auto toHttpMethod = [&]() -> drogon::HttpMethod {
+            if (methodStr == "GET")
+            {
+                return drogon::HttpMethod::Get;
+            }
+            else if (methodStr == "POST")
+            {
+                return drogon::HttpMethod::Post;
+            }
+            else if (methodStr == "HEAD")
+            {
+                return drogon::HttpMethod::Head;
+            }
+            else if (methodStr == "PUT")
+            {
+                return drogon::HttpMethod::Put;
+            }
+            else if (methodStr == "DELETE")
+            {
+                return drogon::HttpMethod::Delete;
+            }
+            else if (methodStr == "OPTIONS")
+            {
+                return drogon::HttpMethod::Options;
+            }
+            else if (methodStr == "PATCH")
+            {
+                return drogon::HttpMethod::Patch;
+            }
+            else
+            {
+                outputErrorAndExit("invalid method");
+            }
+            return drogon::HttpMethod::Get;
+        };
+
+        std::unordered_map<std::string, std::string> header;
+        if (httpRequestJson.isMember("header"))
+        {
+            auto &jsonValue = httpRequestJson["header"];
+            for (const auto &key : jsonValue.getMemberNames())
+            {
+                if (jsonValue[key].isString())
+                {
+                    header[key] = jsonValue[key].asString();
+                }
+                else
+                {
+                    header[key] = jsonValue[key].toStyledString();
+                }
+            }
+        }
+
+        std::string body;
+        if (httpRequestJson.isMember("body"))
+        {
+            Json::FastWriter fastWriter;
+            body = fastWriter.write(httpRequestJson["body"]);
+        }
+
+        createHttpRequestFunc_ = [this,
+                                  method = toHttpMethod(),
+                                  body = std::move(body),
+                                  header =
+                                      std::move(header)]() -> HttpRequestPtr {
+            auto request = HttpRequest::newHttpRequest();
+            request->setPath(path_);
+            request->setMethod(method);
+            for (const auto &[field, val] : header)
+                request->addHeader(field, val);
+            if (!body.empty())
+                request->setBody(body);
+            return request;
+        };
+    }
+
    // std::cout << "host=" << host_ << std::endl;
    // std::cout << "path=" << path_ << std::endl;
    doTesting();
@ -232,9 +367,19 @@ void press::sendRequest(const HttpClientPtr &client)
    {
        return;
    }
-    auto request = HttpRequest::newHttpRequest();
+
+    HttpRequestPtr request;
+    if (createHttpRequestFunc_)
+    {
+        request = createHttpRequestFunc_();
+    }
+    else
+    {
+        request = HttpRequest::newHttpRequest();
        request->setPath(path_);
        request->setMethod(Get);
+    }
+
    // std::cout << "send!" << std::endl;
    client->sendRequest(
        request,
--- a/drogon_ctl/press.h
+++ b/drogon_ctl/press.h
@ -20,6 +20,7 @@
 #include <drogon/HttpClient.h>
 #include <trantor/utils/Date.h>
 #include <trantor/net/EventLoopThreadPool.h>
+#include <functional>
 #include <string>
 #include <atomic>
 #include <memory>
@ -62,6 +63,8 @@ class press : public DrObject<press>, public CommandHandler
    size_t numOfThreads_{1};
    size_t numOfRequests_{1};
    size_t numOfConnections_{1};
+    std::string httpRequestJsonFile_;
+    std::function<HttpRequestPtr()> createHttpRequestFunc_;
    bool certValidation_{true};
    bool processIndication_{true};
    std::string url_;
--- a/drogon_ctl/templates/model_cc.csp
+++ b/drogon_ctl/templates/model_cc.csp
@ -76,7 +76,7 @@ else

 <%c++for(auto col:cols){
 %>
-const std::string [[className]]::Cols::_{%col.colName_%} = "{%col.colName_%}";
+const std::string [[className]]::Cols::_{%col.colName_%} = "{%escapeIdentifier(col.colName_, rdbms)%}";
 <%c++
 }%>
 <%c++if(@@.get<int>("hasPrimaryKey")<=1){%>
@ -102,7 +102,7 @@ if(!schema.empty())
 {
    $$<<schema<<".";
 }
-%>[[tableName]]";
+%>{%escapeIdentifier(@@.get<std::string>("tableName"), rdbms)%}";

 const std::vector<typename [[className]]::MetaData> [[className]]::metaData_={
 <%c++for(size_t i=0;i<cols.size();i++){
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@ -34,6 +34,8 @@ add_executable(redis_chat redis_chat/main.cc
 add_executable(async_stream async_stream/main.cc
                            async_stream/RequestStreamExampleCtrl.cc)

+add_executable(cors cors/main.cc)
+
 set(example_targets
    benchmark
    client
@ -45,7 +47,8 @@ set(example_targets
    jsonstore
    redis_simple
    redis_chat
-    async_stream)
+    async_stream
+    cors)

 # Add warnings for our example targets--some warnings (such as -Wunused-parameter) only appear
 # when the templated functions are instantiated at their point of use.
--- a/examples/README.md
+++ b/examples/README.md
@ -16,6 +16,7 @@ proxy with a simple round robin
 11. [redis_cache](https://github.com/drogonframework/drogon/tree/master/examples/redis_cache) - An example for using coroutines of Redis clients
 12. [redis_chat](https://github.com/drogonframework/drogon/tree/master/examples/redis_chat) - A chatroom server built with websocket and Redis pub/sub service
 13. [prometheus_example](https://github.com/drogonframework/drogon/tree/master/examples/prometheus_example) - An example of how to use the Prometheus exporter in Drogon
+14. [cors](https://github.com/drogonframework/drogon/tree/master/examples/cors) - An example demonstrating how to implement CORS (Cross-Origin Resource Sharing) support in Drogon

 ### [TechEmpower Framework Benchmarks](https://github.com/TechEmpower/FrameworkBenchmarks) test suite

--- a/examples/async_stream/main.cc
+++ b/examples/async_stream/main.cc
@ -1,15 +1,33 @@
 #include <drogon/drogon.h>
 #include <chrono>
+#include <functional>
+#include <mutex>
+#include <unordered_map>
+#include <trantor/utils/Logger.h>
+#include <trantor/net/callbacks.h>
+#include <trantor/net/TcpConnection.h>

 using namespace drogon;
 using namespace std::chrono_literals;

+std::mutex mutex;
+std::unordered_map<trantor::TcpConnectionPtr, std::function<void()>>
+    connMapping;
+
 int main()
 {
    app().registerHandler(
        "/stream",
-        [](const HttpRequestPtr &,
+        [](const HttpRequestPtr &req,
           std::function<void(const HttpResponsePtr &)> &&callback) {
+            const auto &weakConnPtr = req->getConnectionPtr();
+            if (auto connPtr = weakConnPtr.lock())
+            {
+                std::lock_guard lk(mutex);
+                connMapping.emplace(std::move(connPtr), [] {
+                    LOG_INFO << "call stop or other options!!!!";
+                });
+            }
            auto resp = drogon::HttpResponse::newAsyncStreamResponse(
                [](drogon::ResponseStreamPtr stream) {
                    std::thread([stream =
@ -79,5 +97,17 @@ int main()

    LOG_INFO << "Server running on 127.0.0.1:8848";
    app().enableRequestStream();  // This is for request stream.
+    app().setConnectionCallback([](const trantor::TcpConnectionPtr &conn) {
+        if (conn->disconnected())
+        {
+            std::lock_guard lk(mutex);
+            if (auto it = connMapping.find(conn); it != connMapping.end())
+            {
+                LOG_INFO << "disconnect";
+                connMapping[conn]();
+                connMapping.erase(conn);
+            }
+        }
+    });
    app().addListener("127.0.0.1", 8848).run();
 }
--- a/examples/client_example/main.cc
+++ b/examples/client_example/main.cc
@ -72,6 +72,8 @@ int main()
                    std::cout << "count=" << nth_resp << std::endl;
                });
        }
+        std::cout << "requestsBufferSize:" << client->requestsBufferSize()
+                  << std::endl;
    }

    app().run();
--- a/examples/cors/main.cc
+++ b/examples/cors/main.cc
@ -0,0 +1,153 @@
+#include <drogon/HttpAppFramework.h>
+#include <drogon/HttpResponse.h>
+#include <drogon/drogon.h>
+#include "trantor/utils/Logger.h"
+
+using namespace drogon;
+
+/// Configure Cross-Origin Resource Sharing (CORS) support.
+///
+///  This function registers both synchronous pre-processing advice for handling
+///  OPTIONS preflight requests and post-handling advice to inject CORS headers
+///  into all responses dynamically based on the incoming request headers.
+void setupCors()
+{
+    // Register sync advice to handle CORS preflight (OPTIONS) requests
+    drogon::app().registerSyncAdvice([](const drogon::HttpRequestPtr &req)
+                                         -> drogon::HttpResponsePtr {
+        if (req->method() == drogon::HttpMethod::Options)
+        {
+            auto resp = drogon::HttpResponse::newHttpResponse();
+
+            // Set Access-Control-Allow-Origin header based on the Origin
+            // request header
+            const auto &origin = req->getHeader("Origin");
+            if (!origin.empty())
+            {
+                resp->addHeader("Access-Control-Allow-Origin", origin);
+            }
+
+            // Set Access-Control-Allow-Methods based on the requested method
+            const auto &requestMethod =
+                req->getHeader("Access-Control-Request-Method");
+            if (!requestMethod.empty())
+            {
+                resp->addHeader("Access-Control-Allow-Methods", requestMethod);
+            }
+
+            // Allow credentials to be included in cross-origin requests
+            resp->addHeader("Access-Control-Allow-Credentials", "true");
+
+            // Set allowed headers from the Access-Control-Request-Headers
+            // header
+            const auto &requestHeaders =
+                req->getHeader("Access-Control-Request-Headers");
+            if (!requestHeaders.empty())
+            {
+                resp->addHeader("Access-Control-Allow-Headers", requestHeaders);
+            }
+
+            return std::move(resp);
+        }
+        return {};
+    });
+
+    // Register post-handling advice to add CORS headers to all responses
+    drogon::app().registerPostHandlingAdvice(
+        [](const drogon::HttpRequestPtr &req,
+           const drogon::HttpResponsePtr &resp) -> void {
+            // Set Access-Control-Allow-Origin based on the Origin request
+            // header
+            const auto &origin = req->getHeader("Origin");
+            if (!origin.empty())
+            {
+                resp->addHeader("Access-Control-Allow-Origin", origin);
+            }
+
+            // Reflect the requested Access-Control-Request-Method back in the
+            // response
+            const auto &requestMethod =
+                req->getHeader("Access-Control-Request-Method");
+            if (!requestMethod.empty())
+            {
+                resp->addHeader("Access-Control-Allow-Methods", requestMethod);
+            }
+
+            // Allow credentials to be included in cross-origin requests
+            resp->addHeader("Access-Control-Allow-Credentials", "true");
+
+            // Reflect the requested Access-Control-Request-Headers back
+            const auto &requestHeaders =
+                req->getHeader("Access-Control-Request-Headers");
+            if (!requestHeaders.empty())
+            {
+                resp->addHeader("Access-Control-Allow-Headers", requestHeaders);
+            }
+        });
+}
+
+/**
+ * Main function to start the Drogon application with CORS-enabled routes.
+ * This example includes:
+ * - A simple GET endpoint `/hello` that returns a greeting message.
+ * - A POST endpoint `/echo` that echoes back the request body.
+ *  You can test with curl to test the CORS support:
+ *
+```
+    curl -i -X OPTIONS http://localhost:8000/echo \
+        -H "Origin: http://localhost:3000" \
+        -H "Access-Control-Request-Method: POST" \
+        -H "Access-Control-Request-Headers: Content-Type"
+```
+or
+```
+    curl -i -X POST http://localhost:8000/echo \
+        -H "Origin: http://localhost:3000" \
+        -H "Content-Type: application/json" \
+        -d '{"key":"value"}'
+```
+ */
+int main()
+{
+    // Listen on port 8000 for all interfaces
+    app().addListener("0.0.0.0", 8000);
+
+    // Setup CORS support
+    setupCors();
+
+    // Register /hello route for GET and OPTIONS methods
+    app().registerHandler(
+        "/hello",
+        [](const HttpRequestPtr &req,
+           std::function<void(const HttpResponsePtr &)> &&callback) {
+            auto resp = HttpResponse::newHttpResponse();
+            resp->setBody("Hello from Drogon!");
+
+            // Log client IP address
+            LOG_INFO << "Request to /hello from " << req->getPeerAddr().toIp();
+
+            callback(resp);
+        },
+        {Get, Options});
+
+    // Register /echo route for POST and OPTIONS methods
+    app().registerHandler(
+        "/echo",
+        [](const HttpRequestPtr &req,
+           std::function<void(const HttpResponsePtr &)> &&callback) {
+            auto resp = HttpResponse::newHttpResponse();
+            resp->setBody(std::string("Echo: ").append(req->getBody()));
+
+            // Log client IP and request body
+            LOG_INFO << "Request to /echo from " << req->getPeerAddr().toIp();
+            LOG_INFO << "Echo content: " << req->getBody();
+
+            callback(resp);
+        },
+        {Post, Options});
+
+    // Start the application main loop
+    app().run();
+
+    return 0;
+}
--- a/examples/helloworld/main.cc
+++ b/examples/helloworld/main.cc
@ -1,3 +1,4 @@
+#include <trantor/utils/Logger.h>
 #ifdef _WIN32
 #include <ws2tcpip.h>
 #else
@ -15,8 +16,10 @@ int main()
    // sent to Drogon
    app().registerHandler(
        "/",
-        [](const HttpRequestPtr &,
+        [](const HttpRequestPtr &request,
           std::function<void(const HttpResponsePtr &)> &&callback) {
+            LOG_INFO << "connected:"
+                     << (request->connected() ? "true" : "false");
            auto resp = HttpResponse::newHttpResponse();
            resp->setBody("Hello, World!");
            callback(resp);
--- a/lib/inc/drogon/Cookie.h
+++ b/lib/inc/drogon/Cookie.h
@ -36,12 +36,7 @@ class DROGON_EXPORT Cookie
     * @param key key of the cookie
     * @param value value of the cookie
     */
-    Cookie(const std::string &key, const std::string &value)
-        : key_(key), value_(value)
-    {
-    }
-
-    Cookie(std::string &&key, std::string &&value)
+    Cookie(std::string key, std::string value)
        : key_(std::move(key)), value_(std::move(value))
    {
    }
@ -89,6 +84,9 @@ class DROGON_EXPORT Cookie
        domain_ = domain;
    }

+    /**
+     * @brief Set the domain of the cookie.
+     */
    void setDomain(std::string &&domain)
    {
        domain_ = std::move(domain);
@ -102,6 +100,9 @@ class DROGON_EXPORT Cookie
        path_ = path;
    }

+    /**
+     * @brief Set the path of the cookie.
+     */
    void setPath(std::string &&path)
    {
        path_ = std::move(path);
@ -115,6 +116,9 @@ class DROGON_EXPORT Cookie
        key_ = key;
    }

+    /**
+     * @brief Set the key of the cookie.
+     */
    void setKey(std::string &&key)
    {
        key_ = std::move(key);
@ -128,6 +132,9 @@ class DROGON_EXPORT Cookie
        value_ = value;
    }

+    /**
+     * @brief Set the value of the cookie.
+     */
    void setValue(std::string &&value)
    {
        value_ = std::move(value);
@ -149,6 +156,18 @@ class DROGON_EXPORT Cookie
        sameSite_ = sameSite;
    }

+    /**
+     *  @brief Set the partitioned status of the cookie
+     */
+    void setPartitioned(bool partitioned)
+    {
+        partitioned_ = partitioned;
+        if (partitioned)
+        {
+            setSecure(true);
+        }
+    }
+
    /**
     * @brief Get the string value of the cookie
     */
@ -275,6 +294,17 @@ class DROGON_EXPORT Cookie
        return secure_;
    }

+    /**
+     * @brief Check if the cookie is partitioned.
+     *
+     * @return true means the cookie is partitioned.
+     * @return false means the cookie is not partitioned.
+     */
+    bool isPartitioned() const
+    {
+        return partitioned_;
+    }
+
    /**
     * @brief Get the max-age of the cookie
     */
@ -343,21 +373,15 @@ class DROGON_EXPORT Cookie
     * @brief Converts a string value to its associated enum class SameSite
     * value
     */
-    static SameSite convertString2SameSite(const std::string_view &sameSite)
+    static SameSite convertString2SameSite(std::string_view sameSite)
    {
        if (stricmp(sameSite, "lax"))
-        {
            return Cookie::SameSite::kLax;
-        }
-        else if (stricmp(sameSite, "strict"))
-        {
+        if (stricmp(sameSite, "strict"))
            return Cookie::SameSite::kStrict;
-        }
-        else if (stricmp(sameSite, "none"))
-        {
+        if (stricmp(sameSite, "none"))
            return Cookie::SameSite::kNone;
-        }
-        else if (!stricmp(sameSite, "null"))
+        if (!stricmp(sameSite, "null"))
        {
            LOG_WARN
                << "'" << sameSite
@ -372,34 +396,20 @@ class DROGON_EXPORT Cookie
     * @brief Converts an enum class SameSite value to its associated string
     * value
     */
-    static const std::string_view &convertSameSite2String(SameSite sameSite)
+    static std::string_view convertSameSite2String(SameSite sameSite)
    {
        switch (sameSite)
        {
            case SameSite::kLax:
-            {
-                static std::string_view sv{"Lax"};
-                return sv;
-            }
+                return "Lax";
            case SameSite::kStrict:
-            {
-                static std::string_view sv{"Strict"};
-                return sv;
-            }
+                return "Strict";
            case SameSite::kNone:
-            {
-                static std::string_view sv{"None"};
-                return sv;
-            }
+                return "None";
            case SameSite::kNull:
-            {
-                static std::string_view sv{"Null"};
-                return sv;
-            }
-        }
-        {
-            static std::string_view sv{"UNDEFINED"};
-            return sv;
+                return "Null";
+            default:
+                return "UNDEFINED";
        }
    }

@ -407,6 +417,7 @@ class DROGON_EXPORT Cookie
    trantor::Date expiresDate_{(std::numeric_limits<int64_t>::max)()};
    bool httpOnly_{true};
    bool secure_{false};
+    bool partitioned_{false};
    std::string domain_;
    std::string path_;
    std::string key_;
--- a/lib/inc/drogon/DrObject.h
+++ b/lib/inc/drogon/DrObject.h
@ -61,8 +61,8 @@ template <typename T>
 struct isAutoCreationClass
 {
    template <class C>
-    static constexpr auto check(C *)
-        -> std::enable_if_t<std::is_same_v<decltype(C::isAutoCreation), bool>,
+    static constexpr auto check(C *) -> std::enable_if_t<
+        std::is_same_v<decltype(C::isAutoCreation), const bool>,
        bool>
    {
        return C::isAutoCreation;
--- a/lib/inc/drogon/HttpAppFramework.h
+++ b/lib/inc/drogon/HttpAppFramework.h
@ -43,6 +43,16 @@
 #include <vector>
 #include <chrono>

+#if defined(__APPLE__) && defined(__MACH__) && \
+    (defined(__ENVIRONMENT_IPHONE_OS__) ||     \
+     defined(__IPHONE_OS_VERSION_MIN_REQUIRED))
+// iOS
+#define TARGET_OS_IOS 1
+#else
+// not iOS
+#define TARGET_OS_IOS 0
+#endif
+
 namespace drogon
 {
 // the drogon banner
@ -349,7 +359,7 @@ class DROGON_EXPORT HttpAppFramework : public trantor::NonCopyable

    /// Register an advice called before routing
    /**
-     * @param advice is called after all the synchronous advices return
+     * @param advice is called after all the synchronous advice return
     * nullptr and before the request is routed to any handler. The parameters
     * of the advice are same as those of the doFilter method of the Filter
     * class.
@ -806,6 +816,15 @@ class DROGON_EXPORT HttpAppFramework : public trantor::NonCopyable
        const std::vector<std::pair<std::string, std::string>>
            &sslConfCmds) = 0;

+    /// Reload the global cert file and private key file for https server
+    /// Note: The goal of this method is not to make the framework
+    /// use the new SSL path, but rather to reload the new content
+    /// from the old path while the framework is still running.
+    /// Typically, when our SSL is about to expire,
+    /// we need to reload the SSL. The purpose of this function
+    /// is to use the new SSL certificate without stopping the framework.
+    virtual HttpAppFramework &reloadSSLFiles() = 0;
+
    /// Add plugins
    /**
     * @param configs The plugins array
@ -988,7 +1007,7 @@ class DROGON_EXPORT HttpAppFramework : public trantor::NonCopyable
    virtual HttpAppFramework &setFileTypes(
        const std::vector<std::string> &types) = 0;

-#ifndef _WIN32
+#if !defined(_WIN32) && !TARGET_OS_IOS
    /// Enable supporting for dynamic views loading.
    /**
     *
@ -1606,6 +1625,15 @@ class DROGON_EXPORT HttpAppFramework : public trantor::NonCopyable
    virtual HttpAppFramework &setAfterAcceptSockOptCallback(
        std::function<void(int)> cb) = 0;

+    /**
+     * @brief Set the client disconnect or connect callback.
+     *
+     * @param cb This callback will be called, when the client disconnect or
+     * connect
+     */
+    virtual HttpAppFramework &setConnectionCallback(
+        std::function<void(const trantor::TcpConnectionPtr &)> cb) = 0;
+
    virtual HttpAppFramework &enableRequestStream(bool enable = true) = 0;
    virtual bool isRequestStreamEnabled() const = 0;

--- a/lib/inc/drogon/HttpClient.h
+++ b/lib/inc/drogon/HttpClient.h
@ -21,6 +21,7 @@
 #include <drogon/HttpRequest.h>
 #include <trantor/utils/NonCopyable.h>
 #include <trantor/net/EventLoop.h>
+#include <cstddef>
 #include <functional>
 #include <memory>
 #include <future>
@ -178,6 +179,12 @@ class DROGON_EXPORT HttpClient : public trantor::NonCopyable
     */
    virtual void setSockOptCallback(std::function<void(int)> cb) = 0;

+    /**
+     * @brief Return the number of unsent http requests in the current http
+     * client cache buffer
+     */
+    virtual std::size_t requestsBufferSize() = 0;
+
    /// Set the pipelining depth, which is the number of requests that are not
    /// responding.
    /**
--- a/lib/inc/drogon/HttpRequest.h
+++ b/lib/inc/drogon/HttpRequest.h
@ -30,6 +30,7 @@
 #include <unordered_map>
 #include <optional>
 #include <string_view>
+#include <trantor/net/TcpConnection.h>

 namespace drogon
 {
@ -449,8 +450,7 @@ class DROGON_EXPORT HttpRequest
    virtual void setCustomContentTypeString(const std::string &type) = 0;

    /// Add a cookie
-    virtual void addCookie(const std::string &key,
-                           const std::string &value) = 0;
+    virtual void addCookie(std::string key, std::string value) = 0;

    /**
     * @brief Set the request object to the pass-through mode or not. It's not
@ -505,6 +505,11 @@ class DROGON_EXPORT HttpRequest
    virtual void setContentTypeString(const char *typeString,
                                      size_t typeStringLength) = 0;

+    virtual bool connected() const noexcept = 0;
+
+    virtual const std::weak_ptr<trantor::TcpConnection> &getConnectionPtr()
+        const noexcept = 0;
+
    virtual ~HttpRequest()
    {
    }
--- a/lib/inc/drogon/MultiPart.h
+++ b/lib/inc/drogon/MultiPart.h
@ -123,6 +123,8 @@ class DROGON_EXPORT MultiPartParser
 {
  public:
    MultiPartParser(){};
+    MultiPartParser(const MultiPartParser &other) = default;  // Copyable
+    MultiPartParser(MultiPartParser &&other) = default;       // Movable
    ~MultiPartParser(){};
    /// Get files, This method should be called after calling the parse()
    /// method.
--- a/lib/inc/drogon/RequestStream.h
+++ b/lib/inc/drogon/RequestStream.h
@ -16,6 +16,7 @@
 #include <string>
 #include <functional>
 #include <memory>
+#include <exception>

 namespace drogon
 {
@ -87,7 +88,7 @@ class StreamError final : public std::exception
 * An interface for stream request reading.
 * User should create an implementation class, or use built-in handlers
 */
-class RequestStreamReader
+class DROGON_EXPORT RequestStreamReader
 {
  public:
    virtual ~RequestStreamReader() = default;
--- a/lib/inc/drogon/plugins/AccessLogger.h
+++ b/lib/inc/drogon/plugins/AccessLogger.h
@ -36,6 +36,7 @@ namespace plugin
            // "show_microseconds": true,
            // "custom_time_format": "",
            // "use_real_ip": false
+            // "path_exempt": ""
      }
   }
   @endcode
@ -98,6 +99,10 @@ namespace plugin
 * Enable the plugin by adding the configuration to the list of plugins in the
 * configuration file.
 *
+ * path_exempt: must be a string or a string array, present a regular expression
+ * (for matching the path of a request) or a regular expression list for URLs
+ * that don't have to be logged.
+ *
 */
 class DROGON_EXPORT AccessLogger : public drogon::Plugin<AccessLogger>
 {
@ -117,6 +122,8 @@ class DROGON_EXPORT AccessLogger : public drogon::Plugin<AccessLogger>
    bool useCustomTimeFormat_{false};
    std::string timeFormat_;
    static bool useRealIp_;
+    std::regex exemptRegex_;
+    bool regexFlag_{false};

    using LogFunction = std::function<void(trantor::LogStream &,
                                           const drogon::HttpRequestPtr &,
--- a/lib/inc/drogon/plugins/Hodor.h
+++ b/lib/inc/drogon/plugins/Hodor.h
@ -71,7 +71,9 @@ IPs or users. the default value is 600.
                "ip_capacity": 0,
                "user_capacity": 0
            },...
-         ]
+        ],
+        // Trusted proxy ip or cidr
+        "trust_ips": ["127.0.0.1", "172.16.0.0/12"],
     }
  }
  @endcode
@ -137,12 +139,14 @@ class DROGON_EXPORT Hodor : public drogon::Plugin<Hodor>
    std::function<HttpResponsePtr(const drogon::HttpRequestPtr &)>
        rejectResponseFactory_;

+    RealIpResolver::CIDRs trustCIDRs_;
+
    void onHttpRequest(const drogon::HttpRequestPtr &,
                       AdviceCallback &&,
                       AdviceChainCallback &&);
    bool checkLimit(const drogon::HttpRequestPtr &req,
                    const LimitStrategy &strategy,
-                    const std::string &ip,
+                    const trantor::InetAddress &ip,
                    const std::optional<std::string> &userId);
    HttpResponsePtr rejectResponse_;
 };
--- a/lib/inc/drogon/plugins/RealIpResolver.h
+++ b/lib/inc/drogon/plugins/RealIpResolver.h
@ -57,7 +57,6 @@ class DROGON_EXPORT RealIpResolver : public drogon::Plugin<RealIpResolver>
  private:
    const trantor::InetAddress &getRealAddr(
        const drogon::HttpRequestPtr &req) const;
-    bool matchCidr(const trantor::InetAddress &addr) const;

    struct CIDR
    {
@ -66,7 +65,12 @@ class DROGON_EXPORT RealIpResolver : public drogon::Plugin<RealIpResolver>
        in_addr_t mask_{32};
    };

-    std::vector<CIDR> trustCIDRs_;
+    using CIDRs = std::vector<CIDR>;
+    static bool matchCidr(const trantor::InetAddress &addr,
+                          const CIDRs &trustCIDRs);
+
+    friend class Hodor;
+    CIDRs trustCIDRs_;
    std::string fromHeader_;
    std::string attributeKey_;
    bool useXForwardedFor_{false};
--- a/lib/inc/drogon/utils/Utilities.h
+++ b/lib/inc/drogon/utils/Utilities.h
@ -134,47 +134,85 @@ constexpr size_t base64EncodedLength(size_t in_len, bool padded = true)
 }

 /// Encode the string to base64 format.
-DROGON_EXPORT std::string base64Encode(const unsigned char *bytes_to_encode,
-                                       size_t in_len,
-                                       bool url_safe = false,
+DROGON_EXPORT void base64Encode(const unsigned char *bytesToEncode,
+                                size_t inLen,
+                                unsigned char *outputBuffer,
+                                bool urlSafe = false,
                                bool padded = true);

+/// Encode the string to base64 format.
+inline std::string base64Encode(const unsigned char *bytesToEncode,
+                                size_t inLen,
+                                bool urlSafe = false,
+                                bool padded = true)
+{
+    std::string ret;
+    ret.resize(base64EncodedLength(inLen, padded));
+    base64Encode(
+        bytesToEncode, inLen, (unsigned char *)ret.data(), urlSafe, padded);
+    return ret;
+}
+
 /// Encode the string to base64 format.
 inline std::string base64Encode(std::string_view data,
-                                bool url_safe = false,
+                                bool urlSafe = false,
                                bool padded = true)
 {
    return base64Encode((unsigned char *)data.data(),
                        data.size(),
-                        url_safe,
+                        urlSafe,
                        padded);
 }

 /// Encode the string to base64 format with no padding.
-inline std::string base64EncodeUnpadded(const unsigned char *bytes_to_encode,
-                                        size_t in_len,
-                                        bool url_safe = false)
+inline void base64EncodeUnpadded(const unsigned char *bytesToEncode,
+                                 size_t inLen,
+                                 unsigned char *outputBuffer,
+                                 bool urlSafe = false)
 {
-    return base64Encode(bytes_to_encode, in_len, url_safe, false);
+    base64Encode(bytesToEncode, inLen, outputBuffer, urlSafe, false);
+}
+
+/// Encode the string to base64 format with no padding.
+inline std::string base64EncodeUnpadded(const unsigned char *bytesToEncode,
+                                        size_t inLen,
+                                        bool urlSafe = false)
+{
+    return base64Encode(bytesToEncode, inLen, urlSafe, false);
 }

 /// Encode the string to base64 format with no padding.
 inline std::string base64EncodeUnpadded(std::string_view data,
-                                        bool url_safe = false)
+                                        bool urlSafe = false)
 {
-    return base64Encode(data, url_safe, false);
+    return base64Encode(data, urlSafe, false);
 }

 /// Get the decoded length of base64.
-constexpr size_t base64DecodedLength(size_t in_len)
+constexpr size_t base64DecodedLength(size_t inLen)
 {
-    return (in_len * 3) / 4;
+    return (inLen * 3) / 4;
 }

 /// Decode the base64 format string.
-DROGON_EXPORT std::string base64Decode(std::string_view encoded_string);
+/// Return the number of bytes written.
+DROGON_EXPORT size_t base64Decode(const char *encodedString,
+                                  size_t inLen,
+                                  unsigned char *outputBuffer);
+
+/// Decode the base64 format string.
+inline std::string base64Decode(std::string_view encodedString)
+{
+    auto inLen = encodedString.size();
+    std::string ret;
+    ret.resize(base64DecodedLength(inLen));
+    ret.resize(
+        base64Decode(encodedString.data(), inLen, (unsigned char *)ret.data()));
+    return ret;
+}
+
 DROGON_EXPORT std::vector<char> base64DecodeToVector(
-    std::string_view encoded_string);
+    std::string_view encodedString);

 /// Check if the string need decoding
 DROGON_EXPORT bool needUrlDecoding(const char *begin, const char *end);
@ -263,6 +301,12 @@ DROGON_EXPORT std::string brotliDecompress(const char *data,
 DROGON_EXPORT char *getHttpFullDate(
    const trantor::Date &date = trantor::Date::now());

+DROGON_EXPORT const std::string &getHttpFullDateStr(
+    const trantor::Date &date = trantor::Date::now());
+
+DROGON_EXPORT void dateToCustomFormattedString(const std::string &fmtStr,
+                                               std::string &str,
+                                               const trantor::Date &date);
 /// Get the trantor::Date object according to the http full date string
 /**
 * Returns trantor::Date(std::numeric_limits<int64_t>::max()) upon failure.
@ -540,6 +584,7 @@ namespace trantor
 {
 inline LogStream &operator<<(LogStream &ls, const std::string_view &v)
 {
+    if (!v.empty())
        ls.append(v.data(), v.length());
    return ls;
 }
--- a/lib/inc/drogon/utils/coroutine.h
+++ b/lib/inc/drogon/utils/coroutine.h
@ -245,7 +245,7 @@ struct [[nodiscard]] Task

        std::optional<T> value;
        std::exception_ptr exception_;
-        std::coroutine_handle<> continuation_;
+        std::coroutine_handle<> continuation_{std::noop_coroutine()};
    };

    auto operator co_await() const noexcept
@ -332,7 +332,7 @@ struct [[nodiscard]] Task<void>
        }

        std::exception_ptr exception_;
-        std::coroutine_handle<> continuation_;
+        std::coroutine_handle<> continuation_{std::noop_coroutine()};
    };

    auto operator co_await() const noexcept
@ -811,4 +811,180 @@ inline internal::EventLoopAwaiter<T> queueInLoopCoro(trantor::EventLoop *loop,
    return internal::EventLoopAwaiter<T>(std::move(task), loop);
 }

+class Mutex final
+{
+    class ScopedCoroMutexAwaiter;
+    class CoroMutexAwaiter;
+
+  public:
+    Mutex() noexcept : state_(unlockedValue()), waiters_(nullptr)
+    {
+    }
+
+    Mutex(const Mutex &) = delete;
+    Mutex(Mutex &&) = delete;
+    Mutex &operator=(const Mutex &) = delete;
+    Mutex &operator=(Mutex &&) = delete;
+
+    ~Mutex()
+    {
+        [[maybe_unused]] auto state = state_.load(std::memory_order_relaxed);
+        assert(state == unlockedValue() || state == nullptr);
+        assert(waiters_ == nullptr);
+    }
+
+    bool try_lock() noexcept
+    {
+        void *oldValue = unlockedValue();
+        return state_.compare_exchange_strong(oldValue,
+                                              nullptr,
+                                              std::memory_order_acquire,
+                                              std::memory_order_relaxed);
+    }
+
+    [[nodiscard]] ScopedCoroMutexAwaiter scoped_lock(
+        trantor::EventLoop *loop =
+            trantor::EventLoop::getEventLoopOfCurrentThread()) noexcept
+    {
+        return ScopedCoroMutexAwaiter(*this, loop);
+    }
+
+    [[nodiscard]] CoroMutexAwaiter lock(
+        trantor::EventLoop *loop =
+            trantor::EventLoop::getEventLoopOfCurrentThread()) noexcept
+    {
+        return CoroMutexAwaiter(*this, loop);
+    }
+
+    void unlock() noexcept
+    {
+        assert(state_.load(std::memory_order_relaxed) != unlockedValue());
+        auto *waitersHead = waiters_;
+        if (waitersHead == nullptr)
+        {
+            void *currentState = state_.load(std::memory_order_relaxed);
+            if (currentState == nullptr)
+            {
+                const bool releasedLock =
+                    state_.compare_exchange_strong(currentState,
+                                                   unlockedValue(),
+                                                   std::memory_order_release,
+                                                   std::memory_order_relaxed);
+                if (releasedLock)
+                {
+                    return;
+                }
+            }
+            currentState = state_.exchange(nullptr, std::memory_order_acquire);
+            assert(currentState != unlockedValue());
+            assert(currentState != nullptr);
+            auto *waiter = static_cast<CoroMutexAwaiter *>(currentState);
+            do
+            {
+                auto *temp = waiter->next_;
+                waiter->next_ = waitersHead;
+                waitersHead = waiter;
+                waiter = temp;
+            } while (waiter != nullptr);
+        }
+        assert(waitersHead != nullptr);
+        waiters_ = waitersHead->next_;
+        if (waitersHead->loop_)
+        {
+            auto handle = waitersHead->handle_;
+            waitersHead->loop_->runInLoop([handle] { handle.resume(); });
+        }
+        else
+        {
+            waitersHead->handle_.resume();
+        }
+    }
+
+  private:
+    class CoroMutexAwaiter
+    {
+      public:
+        CoroMutexAwaiter(Mutex &mutex, trantor::EventLoop *loop) noexcept
+            : mutex_(mutex), loop_(loop)
+        {
+        }
+
+        bool await_ready() noexcept
+        {
+            return mutex_.try_lock();
+        }
+
+        bool await_suspend(std::coroutine_handle<> handle) noexcept
+        {
+            handle_ = handle;
+            return mutex_.asynclockImpl(this);
+        }
+
+        void await_resume() noexcept
+        {
+        }
+
+      private:
+        friend class Mutex;
+
+        Mutex &mutex_;
+        trantor::EventLoop *loop_;
+        std::coroutine_handle<> handle_;
+        CoroMutexAwaiter *next_;
+    };
+
+    class ScopedCoroMutexAwaiter : public CoroMutexAwaiter
+    {
+      public:
+        ScopedCoroMutexAwaiter(Mutex &mutex, trantor::EventLoop *loop)
+            : CoroMutexAwaiter(mutex, loop)
+        {
+        }
+
+        [[nodiscard]] auto await_resume() noexcept
+        {
+            return std::unique_lock<Mutex>{mutex_, std::adopt_lock};
+        }
+    };
+
+    bool asynclockImpl(CoroMutexAwaiter *awaiter)
+    {
+        void *oldValue = state_.load(std::memory_order_relaxed);
+        while (true)
+        {
+            if (oldValue == unlockedValue())
+            {
+                void *newValue = nullptr;
+                if (state_.compare_exchange_weak(oldValue,
+                                                 newValue,
+                                                 std::memory_order_acquire,
+                                                 std::memory_order_relaxed))
+                {
+                    return false;
+                }
+            }
+            else
+            {
+                void *newValue = awaiter;
+                awaiter->next_ = static_cast<CoroMutexAwaiter *>(oldValue);
+                if (state_.compare_exchange_weak(oldValue,
+                                                 newValue,
+                                                 std::memory_order_release,
+                                                 std::memory_order_relaxed))
+                {
+                    return true;
+                }
+            }
+        }
+    }
+
+    void *unlockedValue() noexcept
+    {
+        return this;
+    }
+
+    std::atomic<void *> state_;
+    CoroMutexAwaiter *waiters_;
+};
+
 }  // namespace drogon
--- a/lib/inc/drogon/utils/monitoring/Gauge.h
+++ b/lib/inc/drogon/utils/monitoring/Gauge.h
@ -91,7 +91,7 @@ class Gauge : public Metric

    static std::string_view type()
    {
-        return "counter";
+        return "gauge";
    }

    void setToCurrentTime()
--- a/lib/src/AOPAdvice.cc
+++ b/lib/src/AOPAdvice.cc
@ -20,10 +20,10 @@
 namespace drogon
 {

-static void doAdvicesChain(
+static void doAdviceChain(
    const std::vector<std::function<void(const HttpRequestPtr &,
                                         AdviceCallback &&,
-                                         AdviceChainCallback &&)>> &advices,
+                                         AdviceChainCallback &&)>> &adviceChain,
    size_t index,
    const HttpRequestImplPtr &req,
    std::shared_ptr<const std::function<void(const HttpResponsePtr &)>>
@ -88,7 +88,7 @@ void AopAdvice::passPreRoutingAdvices(

    auto callbackPtr =
        std::make_shared<std::decay_t<decltype(callback)>>(std::move(callback));
-    doAdvicesChain(preRoutingAdvices_, 0, req, std::move(callbackPtr));
+    doAdviceChain(preRoutingAdvices_, 0, req, std::move(callbackPtr));
 }

 void AopAdvice::passPostRoutingObservers(const HttpRequestImplPtr &req) const
@ -114,7 +114,7 @@ void AopAdvice::passPostRoutingAdvices(

    auto callbackPtr =
        std::make_shared<std::decay_t<decltype(callback)>>(std::move(callback));
-    doAdvicesChain(postRoutingAdvices_, 0, req, std::move(callbackPtr));
+    doAdviceChain(postRoutingAdvices_, 0, req, std::move(callbackPtr));
 }

 void AopAdvice::passPreHandlingObservers(const HttpRequestImplPtr &req) const
@ -140,7 +140,7 @@ void AopAdvice::passPreHandlingAdvices(

    auto callbackPtr =
        std::make_shared<std::decay_t<decltype(callback)>>(std::move(callback));
-    doAdvicesChain(preHandlingAdvices_, 0, req, std::move(callbackPtr));
+    doAdviceChain(preHandlingAdvices_, 0, req, std::move(callbackPtr));
 }

 void AopAdvice::passPostHandlingAdvices(const HttpRequestImplPtr &req,
@ -161,32 +161,32 @@ void AopAdvice::passPreSendingAdvices(const HttpRequestImplPtr &req,
    }
 }

-static void doAdvicesChain(
+static void doAdviceChain(
    const std::vector<std::function<void(const HttpRequestPtr &,
                                         AdviceCallback &&,
-                                         AdviceChainCallback &&)>> &advices,
+                                         AdviceChainCallback &&)>> &adviceChain,
    size_t index,
    const HttpRequestImplPtr &req,
    std::shared_ptr<const std::function<void(const HttpResponsePtr &)>>
        &&callbackPtr)
 {
-    if (index < advices.size())
+    if (index < adviceChain.size())
    {
-        auto &advice = advices[index];
+        auto &advice = adviceChain[index];
        advice(
            req,
            [/*copy*/ callbackPtr](const HttpResponsePtr &resp) {
                (*callbackPtr)(resp);
            },
-            [index, req, callbackPtr, &advices]() mutable {
+            [index, req, callbackPtr, &adviceChain]() mutable {
                auto ioLoop = req->getLoop();
                if (ioLoop && !ioLoop->isInLoopThread())
                {
                    ioLoop->queueInLoop([index,
                                         req,
                                         callbackPtr = std::move(callbackPtr),
-                                         &advices]() mutable {
-                        doAdvicesChain(advices,
+                                         &adviceChain]() mutable {
+                        doAdviceChain(adviceChain,
                                      index + 1,
                                      req,
                                      std::move(callbackPtr));
@ -194,7 +194,7 @@ static void doAdvicesChain(
                }
                else
                {
-                    doAdvicesChain(advices,
+                    doAdviceChain(adviceChain,
                                  index + 1,
                                  req,
                                  std::move(callbackPtr));
--- a/lib/src/AccessLogger.cc
+++ b/lib/src/AccessLogger.cc
@ -113,6 +113,46 @@ void AccessLogger::initAndStart(const Json::Value &config)
    }
    createLogFunctions(format);
    auto logPath = config.get("log_path", "").asString();
+
+    if (config.isMember("path_exempt"))
+    {
+        if (config["path_exempt"].isArray())
+        {
+            const auto &exempts = config["path_exempt"];
+            size_t exemptsCount = exempts.size();
+            if (exemptsCount)
+            {
+                std::string regexString;
+                size_t len = 0;
+                for (const auto &exempt : exempts)
+                {
+                    assert(exempt.isString());
+                    len += exempt.size();
+                }
+                regexString.reserve((exemptsCount * (1 + 2)) - 1 + len);
+
+                const auto last = --exempts.end();
+                for (auto exempt = exempts.begin(); exempt != last; ++exempt)
+                    regexString.append("(")
+                        .append(exempt->asString())
+                        .append(")|");
+                regexString.append("(").append(last->asString()).append(")");
+
+                exemptRegex_ = std::regex(regexString);
+                regexFlag_ = true;
+            }
+        }
+        else if (config["path_exempt"].isString())
+        {
+            exemptRegex_ = std::regex(config["path_exempt"].asString());
+            regexFlag_ = true;
+        }
+        else
+        {
+            LOG_ERROR << "path_exempt must be a string or string array!";
+        }
+    }
+
 #ifdef DROGON_SPDLOG_SUPPORT
    auto logWithSpdlog = trantor::Logger::hasSpdLogSupport() &&
                         config.get("use_spdlog", false).asBool();
@ -228,7 +268,17 @@ void AccessLogger::initAndStart(const Json::Value &config)
    drogon::app().registerPreSendingAdvice(
        [this](const drogon::HttpRequestPtr &req,
               const drogon::HttpResponsePtr &resp) {
+            if (regexFlag_)
+            {
+                if (!std::regex_match(req->path(), exemptRegex_))
+                {
                    logging(LOG_RAW_TO(logIndex_), req, resp);
+                }
+            }
+            else
+            {
+                logging(LOG_RAW_TO(logIndex_), req, resp);
+            }
        });
 }

--- a/lib/src/ConfigLoader.cc
+++ b/lib/src/ConfigLoader.cc
@ -383,7 +383,7 @@ static void loadApp(const Json::Value &app)
    {
        drogon::app().setMaxConnectionNumPerIP(maxConnsPerIP);
    }
-#ifndef _WIN32
+#if !defined(_WIN32) && !TARGET_OS_IOS
    // dynamic views
    auto enableDynamicViews = app.get("load_dynamic_views", false).asBool();
    if (enableDynamicViews)
--- a/lib/src/Cookie.cc
+++ b/lib/src/Cookie.cc
@ -19,16 +19,18 @@ using namespace drogon;

 std::string Cookie::cookieString() const
 {
-    std::string ret = "Set-Cookie: ";
+    constexpr std::string_view prefix = "Set-Cookie: ";
+    std::string ret;
    // reserve space to reduce frequency allocation
-    ret.reserve(ret.size() + key_.size() + value_.size() + 30);
+    ret.reserve(prefix.size() + key_.size() + value_.size() + 30);
+    ret = prefix;
    ret.append(key_).append("=").append(value_).append("; ");
    if (expiresDate_.microSecondsSinceEpoch() !=
            (std::numeric_limits<int64_t>::max)() &&
        expiresDate_.microSecondsSinceEpoch() >= 0)
    {
        ret.append("Expires=")
-            .append(utils::getHttpFullDate(expiresDate_))
+            .append(utils::getHttpFullDateStr(expiresDate_))
            .append("; ");
    }
    if (maxAge_.has_value())
@ -67,7 +69,7 @@ std::string Cookie::cookieString() const
                ret.append("SameSite=Lax; ");
        }
    }
-    if (secure_ && sameSite_ != SameSite::kNone)
+    if ((secure_ && sameSite_ != SameSite::kNone) || partitioned_)
    {
        ret.append("Secure; ");
    }
@ -75,6 +77,10 @@ std::string Cookie::cookieString() const
    {
        ret.append("HttpOnly; ");
    }
+    if (partitioned_)
+    {
+        ret.append("Partitioned; ");
+    }
    ret.resize(ret.length() - 2);  // delete last semicolon
    ret.append("\r\n");
    return ret;
--- a/lib/src/Hodor.cc
+++ b/lib/src/Hodor.cc
@ -105,6 +105,17 @@ void Hodor::initAndStart(const Json::Value &config)
            limitStrategies_.emplace_back(makeLimitStrategy(subLimit));
        }
    }
+
+    const Json::Value &trustIps = config["trust_ips"];
+    if (!trustIps.isNull() && !trustIps.isArray())
+    {
+        throw std::runtime_error("Invalid trusted_ips. Should be array.");
+    }
+    for (const auto &ipOrCidr : trustIps)
+    {
+        trustCIDRs_.emplace_back(ipOrCidr.asString());
+    }
+
    app().registerPreHandlingAdvice([this](const drogon::HttpRequestPtr &req,
                                           AdviceCallback &&acb,
                                           AdviceChainCallback &&accb) {
@ -119,9 +130,13 @@ void Hodor::shutdown()

 bool Hodor::checkLimit(const drogon::HttpRequestPtr &req,
                       const LimitStrategy &strategy,
-                       const std::string &ip,
+                       const trantor::InetAddress &ip,
                       const std::optional<std::string> &userId)
 {
+    if (RealIpResolver::matchCidr(ip, trustCIDRs_))
+    {
+        return true;
+    }
    if (strategy.regexFlag)
    {
        if (!std::regex_match(req->path(), strategy.urlsRegex))
@ -140,7 +155,7 @@ bool Hodor::checkLimit(const drogon::HttpRequestPtr &req,
    {
        RateLimiterPtr limiterPtr;
        strategy.ipLimiterMapPtr->modify(
-            ip,
+            ip.toIpNetEndian(),
            [this, &limiterPtr, &strategy](RateLimiterPtr &ptr) {
                if (!ptr)
                {
@ -207,10 +222,9 @@ void Hodor::onHttpRequest(const drogon::HttpRequestPtr &req,
                          drogon::AdviceCallback &&adviceCallback,
                          drogon::AdviceChainCallback &&chainCallback)
 {
-    auto ip =
-        (useRealIpResolver_ ? drogon::plugin::RealIpResolver::GetRealAddr(req)
-                            : req->peerAddr())
-            .toIpNetEndian();
+    const trantor::InetAddress &ip =
+        useRealIpResolver_ ? drogon::plugin::RealIpResolver::GetRealAddr(req)
+                           : req->peerAddr();
    std::optional<std::string> userId;
    if (userIdGetter_)
    {
--- a/lib/src/HttpAppFrameworkImpl.cc
+++ b/lib/src/HttpAppFrameworkImpl.cc
@ -184,7 +184,7 @@ static void TERMFunction(int sig)
 HttpAppFrameworkImpl::~HttpAppFrameworkImpl() noexcept
 {
 // Destroy the following objects before the loop destruction
-#ifndef _WIN32
+#if !defined(_WIN32) && !TARGET_OS_IOS
    sharedLibManagerPtr_.reset();
 #endif
    sessionManagerPtr_.reset();
@ -236,7 +236,7 @@ const std::string &HttpAppFrameworkImpl::getImplicitPage() const
 {
    return StaticFileRouter::instance().getImplicitPage();
 }
-#ifndef _WIN32
+#if !defined(_WIN32) && !TARGET_OS_IOS
 HttpAppFramework &HttpAppFrameworkImpl::enableDynamicViewsLoading(
    const std::vector<std::string> &libPaths,
    const std::string &outputPath)
@ -511,6 +511,12 @@ HttpAppFramework &HttpAppFrameworkImpl::setSSLFiles(const std::string &certPath,
    return *this;
 }

+HttpAppFramework &HttpAppFrameworkImpl::reloadSSLFiles()
+{
+    listenerManagerPtr_->reloadSSLFiles();
+    return *this;
+}
+
 void HttpAppFrameworkImpl::run()
 {
    if (!getLoop()->isInLoopThread())
@ -593,7 +599,7 @@ void HttpAppFrameworkImpl::run()
        LOG_INFO << "Start child process";
    }

-#ifndef _WIN32
+#if !defined(_WIN32) && !TARGET_OS_IOS
    if (!libFilePaths_.empty())
    {
        sharedLibManagerPtr_ =
@ -1027,7 +1033,7 @@ HttpAppFramework &HttpAppFrameworkImpl::createRedisClient(

 void HttpAppFrameworkImpl::quit()
 {
-    if (getLoop()->isRunning())
+    if (getLoop()->isRunning() && running_.exchange(false))
    {
        getLoop()->queueInLoop([this]() {
            // Release members in the reverse order of initialization
@ -1038,7 +1044,6 @@ void HttpAppFrameworkImpl::quit()
            pluginsManagerPtr_.reset();
            redisClientManagerPtr_.reset();
            dbClientManagerPtr_.reset();
-            running_ = false;
            getLoop()->quit();
            for (trantor::EventLoop *loop : ioLoopThreadPool_->getLoops())
            {
@ -1361,3 +1366,10 @@ HttpAppFramework &HttpAppFrameworkImpl::setAfterAcceptSockOptCallback(
    listenerManagerPtr_->setAfterAcceptSockOptCallback(std::move(cb));
    return *this;
 }
+
+HttpAppFramework &HttpAppFrameworkImpl::setConnectionCallback(
+    std::function<void(const trantor::TcpConnectionPtr &)> cb)
+{
+    listenerManagerPtr_->setConnectionCallback(std::move(cb));
+    return *this;
+}
--- a/lib/src/HttpAppFrameworkImpl.h
+++ b/lib/src/HttpAppFrameworkImpl.h
@ -84,6 +84,9 @@ class HttpAppFrameworkImpl final : public HttpAppFramework
        override;
    HttpAppFramework &setSSLFiles(const std::string &certPath,
                                  const std::string &keyPath) override;
+
+    HttpAppFramework &reloadSSLFiles() override;
+
    void run() override;
    HttpAppFramework &registerWebSocketController(
        const std::string &pathName,
@ -264,7 +267,7 @@ class HttpAppFrameworkImpl final : public HttpAppFramework
    HttpAppFramework &setUploadPath(const std::string &uploadPath) override;
    HttpAppFramework &setFileTypes(
        const std::vector<std::string> &types) override;
-#ifndef _WIN32
+#if !defined(_WIN32) && !TARGET_OS_IOS
    HttpAppFramework &enableDynamicViewsLoading(
        const std::vector<std::string> &libPaths,
        const std::string &outputPath) override;
@ -662,6 +665,8 @@ class HttpAppFrameworkImpl final : public HttpAppFramework
        std::function<void(int)> cb) override;
    HttpAppFramework &setAfterAcceptSockOptCallback(
        std::function<void(int)> cb) override;
+    HttpAppFramework &setConnectionCallback(
+        std::function<void(const trantor::TcpConnectionPtr &)> cb) override;

    HttpAppFramework &enableRequestStream(bool enable) override;
    bool isRequestStreamEnabled() const override;
@ -704,7 +709,7 @@ class HttpAppFrameworkImpl final : public HttpAppFramework
    size_t threadNum_{1};
    std::unique_ptr<trantor::EventLoopThreadPool> ioLoopThreadPool_;

-#ifndef _WIN32
+#if !defined(_WIN32) && !TARGET_OS_IOS
    std::vector<std::string> libFilePaths_;
    std::string libFileOutputPath_;
    std::unique_ptr<SharedLibManager> sharedLibManagerPtr_;
--- a/lib/src/HttpClientImpl.h
+++ b/lib/src/HttpClientImpl.h
@ -19,6 +19,9 @@
 #include <trantor/net/EventLoop.h>
 #include <trantor/net/Resolver.h>
 #include <trantor/net/TcpClient.h>
+#include <cstddef>
+#include <functional>
+#include <future>
 #include <list>
 #include <mutex>
 #include <queue>
@ -115,6 +118,21 @@ class HttpClientImpl final : public HttpClient,
        sockOptCallback_ = std::move(cb);
    }

+    std::size_t requestsBufferSize() override
+    {
+        if (loop_->isInLoopThread())
+        {
+            return requestsBuffer_.size();
+        }
+        else
+        {
+            std::promise<std::size_t> bufferSize;
+            loop_->queueInLoop(
+                [&] { bufferSize.set_value(requestsBuffer_.size()); });
+            return bufferSize.get_future().get();
+        }
+    }
+
  private:
    std::shared_ptr<trantor::TcpClient> tcpClientPtr_;
    trantor::EventLoop *loop_;
--- a/lib/src/HttpRequestImpl.cc
+++ b/lib/src/HttpRequestImpl.cc
@ -96,13 +96,15 @@ void HttpRequestImpl::parseParameters() const
                while (cpos < key.length() &&
                       isspace(static_cast<unsigned char>(key[cpos])))
                    ++cpos;
-                key = key.substr(cpos);
+                key.remove_prefix(cpos);
                auto pvalue = coo.substr(epos + 1);
-                std::string pdecode = utils::urlDecode(pvalue);
-                std::string keydecode = utils::urlDecode(key);
-                parameters_[keydecode] = pdecode;
+                parameters_[utils::urlDecode(key)] = utils::urlDecode(pvalue);
            }
-            value = value.substr(pos + 1);
+            else
+            {
+                parameters_[utils::urlDecode(coo)];
+            }
+            value.remove_prefix(pos + 1);
        }
        if (value.length() > 0)
        {
@ -115,11 +117,13 @@ void HttpRequestImpl::parseParameters() const
                while (cpos < key.length() &&
                       isspace(static_cast<unsigned char>(key[cpos])))
                    ++cpos;
-                key = key.substr(cpos);
+                key.remove_prefix(cpos);
                auto pvalue = coo.substr(epos + 1);
-                std::string pdecode = utils::urlDecode(pvalue);
-                std::string keydecode = utils::urlDecode(key);
-                parameters_[keydecode] = pdecode;
+                parameters_[utils::urlDecode(key)] = utils::urlDecode(pvalue);
+            }
+            else
+            {
+                parameters_[utils::urlDecode(coo)];
            }
        }
    }
@ -153,13 +157,15 @@ void HttpRequestImpl::parseParameters() const
                while (cpos < key.length() &&
                       isspace(static_cast<unsigned char>(key[cpos])))
                    ++cpos;
-                key = key.substr(cpos);
+                key.remove_prefix(cpos);
                auto pvalue = coo.substr(epos + 1);
-                std::string pdecode = utils::urlDecode(pvalue);
-                std::string keydecode = utils::urlDecode(key);
-                parameters_[keydecode] = pdecode;
+                parameters_[utils::urlDecode(key)] = utils::urlDecode(pvalue);
            }
-            value = value.substr(pos + 1);
+            else
+            {
+                parameters_[utils::urlDecode(coo)];
+            }
+            value.remove_prefix(pos + 1);
        }
        if (value.length() > 0)
        {
@ -172,11 +178,13 @@ void HttpRequestImpl::parseParameters() const
                while (cpos < key.length() &&
                       isspace(static_cast<unsigned char>(key[cpos])))
                    ++cpos;
-                key = key.substr(cpos);
+                key.remove_prefix(cpos);
                auto pvalue = coo.substr(epos + 1);
-                std::string pdecode = utils::urlDecode(pvalue);
-                std::string keydecode = utils::urlDecode(key);
-                parameters_[keydecode] = pdecode;
+                parameters_[utils::urlDecode(key)] = utils::urlDecode(pvalue);
+            }
+            else
+            {
+                parameters_[utils::urlDecode(coo)];
            }
        }
    }
@ -592,6 +600,7 @@ void HttpRequestImpl::swap(HttpRequestImpl &that) noexcept
    swap(streamFinishCb_, that.streamFinishCb_);
    swap(streamExceptionPtr_, that.streamExceptionPtr_);
    swap(startProcessing_, that.startProcessing_);
+    swap(connPtr_, that.connPtr_);
 }

 const char *HttpRequestImpl::versionString() const
--- a/lib/src/HttpRequestImpl.h
+++ b/lib/src/HttpRequestImpl.h
@ -16,6 +16,7 @@

 #include "HttpUtils.h"
 #include "CacheFile.h"
+#include "impl_forwards.h"
 #include <drogon/utils/Utilities.h>
 #include <drogon/HttpRequest.h>
 #include <drogon/RequestStream.h>
@ -26,9 +27,12 @@
 #include <trantor/utils/Logger.h>
 #include <trantor/utils/MsgBuffer.h>
 #include <trantor/utils/NonCopyable.h>
+#include <trantor/net/TcpConnection.h>
 #include <algorithm>
+#include <functional>
+#include <memory>
 #include <string>
-#include <thread>
+#include <future>
 #include <unordered_map>
 #include <assert.h>
 #include <stdio.h>
@ -97,6 +101,7 @@ class HttpRequestImpl : public HttpRequest
        streamFinishCb_ = nullptr;
        streamExceptionPtr_ = nullptr;
        startProcessing_ = false;
+        connPtr_.reset();
    }

    trantor::EventLoop *getLoop()
@ -326,6 +331,11 @@ class HttpRequestImpl : public HttpRequest
        peerCertificate_ = cert;
    }

+    void setConnectionPtr(const std::shared_ptr<trantor::TcpConnection> &ptr)
+    {
+        connPtr_ = ptr;
+    }
+
    void addHeader(const char *start, const char *colon, const char *end);

    void removeHeader(std::string key) override
@ -438,9 +448,9 @@ class HttpRequestImpl : public HttpRequest
        headers_[std::move(field)] = std::move(value);
    }

-    void addCookie(const std::string &key, const std::string &value) override
+    void addCookie(std::string key, std::string value) override
    {
-        cookies_[key] = value;
+        cookies_[std::move(key)] = std::move(value);
    }

    void setPassThrough(bool flag) override
@ -554,6 +564,21 @@ class HttpRequestImpl : public HttpRequest
        return keepAlive_;
    }

+    bool connected() const noexcept override
+    {
+        if (auto conn = connPtr_.lock())
+        {
+            return conn->connected();
+        }
+        return false;
+    }
+
+    const std::weak_ptr<trantor::TcpConnection> &getConnectionPtr()
+        const noexcept override
+    {
+        return connPtr_;
+    }
+
    bool isOnSecureConnection() const noexcept override
    {
        return isOnSecureConnection_;
@ -673,6 +698,9 @@ class HttpRequestImpl : public HttpRequest
    HttpMethod previousMethod_{Invalid};
    Version version_{Version::kUnknown};
    std::string path_;
+    /// Contains the encoded `path_` if and only if `path_` is set in encoded
+    /// form. If path is in a normal form and needed no decoding, then this will
+    /// be empty, as we do not need to store a duplicate.
    std::string originalPath_;
    bool pathEncode_{true};
    std::string_view matchedPathPattern_{""};
@ -702,6 +730,7 @@ class HttpRequestImpl : public HttpRequest
    RequestStreamReaderPtr streamReaderPtr_;
    std::exception_ptr streamExceptionPtr_;
    bool startProcessing_{false};
+    std::weak_ptr<trantor::TcpConnection> connPtr_;

  protected:
    std::string content_;
--- a/lib/src/HttpResponseImpl.cc
+++ b/lib/src/HttpResponseImpl.cc
@ -516,6 +516,7 @@ void HttpResponseImpl::makeHeaderString(trantor::MsgBuffer &buffer)
                           statusCode_);
        }
    }
+
    buffer.hasWritten(len);

    if (!statusMessage_.empty())
@ -525,7 +526,18 @@ void HttpResponseImpl::makeHeaderString(trantor::MsgBuffer &buffer)
    if (!passThrough_)
    {
        buffer.ensureWritableBytes(64);
-        if (streamCallback_ || asyncStreamCallback_)
+        if (!contentLengthIsAllowed())
+        {
+            len = 0;
+            if ((bodyPtr_ && bodyPtr_->length() > 0) ||
+                !sendfileName_.empty() || streamCallback_ ||
+                asyncStreamCallback_)
+            {
+                LOG_ERROR << "The body should be empty when the content-length "
+                             "is not allowed!";
+            }
+        }
+        else if (streamCallback_ || asyncStreamCallback_)
        {
            // When the headers are created, it is time to set the transfer
            // encoding to chunked if the contents size is not specified
@ -620,15 +632,14 @@ void HttpResponseImpl::renderToBuffer(trantor::MsgBuffer &buffer)
        drogon::HttpAppFrameworkImpl::instance().sendDateHeader())
    {
        buffer.append("date: ");
-        buffer.append(utils::getHttpFullDate(trantor::Date::date()),
-                      httpFullDateStringLength);
+        buffer.append(utils::getHttpFullDateStr(trantor::Date::date()));
        buffer.append("\r\n\r\n");
    }
    else
    {
        buffer.append("\r\n");
    }
-    if (bodyPtr_)
+    if (bodyPtr_ && contentLengthIsAllowed())
        buffer.append(bodyPtr_->data(), bodyPtr_->length());
 }

@ -694,8 +705,7 @@ std::shared_ptr<trantor::MsgBuffer> HttpResponseImpl::renderToBuffer()
    {
        httpString->append("date: ");
        auto datePos = httpString->readableBytes();
-        httpString->append(utils::getHttpFullDate(trantor::Date::date()),
-                           httpFullDateStringLength);
+        httpString->append(utils::getHttpFullDateStr(trantor::Date::date()));
        httpString->append("\r\n\r\n");
        datePos_ = datePos;
    }
@ -854,7 +864,7 @@ void HttpResponseImpl::addHeader(const char *start,
        }
        if (!cookie.key().empty())
        {
-            cookies_[cookie.key()] = cookie;
+            cookies_[cookie.key()] = std::move(cookie);
        }
    }
    else
@ -957,7 +967,8 @@ bool HttpResponseImpl::shouldBeCompressed() const
 {
    if (streamCallback_ || asyncStreamCallback_ || !sendfileName_.empty() ||
        contentType() >= CT_APPLICATION_OCTET_STREAM ||
-        getBody().length() < 1024 || !(getHeaderBy("content-encoding").empty()))
+        getBody().length() < 1024 ||
+        !(getHeaderBy("content-encoding").empty()) || !contentLengthIsAllowed())
    {
        return false;
    }
--- a/lib/src/HttpResponseImpl.h
+++ b/lib/src/HttpResponseImpl.h
@ -402,6 +402,16 @@ class DROGON_EXPORT HttpResponseImpl : public HttpResponse
            addHeader("content-length", std::to_string(bodyPtr_->length()));
        }
    }
+
+    bool contentLengthIsAllowed() const
+    {
+        int statusCode =
+            customStatusCode_ >= 0 ? customStatusCode_ : statusCode_;
+
+        // return false if status code is 1xx or 204
+        return (statusCode >= k200OK || statusCode < k100Continue) &&
+               statusCode != k204NoContent;
+    }
 #ifdef USE_BROTLI
    void brDecompress()
    {
--- a/lib/src/HttpServer.cc
+++ b/lib/src/HttpServer.cc
@ -30,6 +30,7 @@
 #include "HttpControllersRouter.h"
 #include "StaticFileRouter.h"
 #include "WebSocketConnectionImpl.h"
+#include "impl_forwards.h"

 #if COZ_PROFILING
 #include <coz.h>
@ -75,7 +76,12 @@ HttpServer::HttpServer(EventLoop *loop,
    : server_(loop, listenAddr, std::move(name), true, app().reusePort())
 #endif
 {
-    server_.setConnectionCallback(onConnection);
+    server_.setConnectionCallback(
+        [this](const trantor::TcpConnectionPtr &conn) {
+            onConnection(conn);
+            if (connectionCallback_)
+                connectionCallback_(conn);
+        });
    server_.setRecvMessageCallback(onMessage);
    server_.kickoffIdleConnections(
        HttpAppFrameworkImpl::instance().getIdleConnectionTimeout());
@ -220,6 +226,7 @@ void HttpServer::onMessage(const TcpConnectionPtr &conn, MsgBuffer *buf)
            req->setCreationDate(trantor::Date::date());
            req->setSecure(conn->isSSLConnection());
            req->setPeerCertificate(conn->peerCertificate());
+            req->setConnectionPtr(conn);
            // TODO: maybe call onRequests() directly in stream mode
            requests.push_back(req);
        }
@ -306,7 +313,7 @@ void HttpServer::onRequests(
            return;
        }

-        // flush response for not passing sync advices
+        // flush response for not passing sync advice
        if (conn->connected() && !requestParser->getResponseBuffer().empty())
        {
            sendResponses(conn,
@ -508,7 +515,7 @@ void HttpServer::requestPostRouting(const HttpRequestImplPtr &req, Pack &&pack)
                else
                {
                    req->quitStreamMode();
-                    LOG_DEBUG << "Stop processing request due to stream error";
+                    LOG_ERROR << "Stop processing request due to stream error";
                    pack.callback(
                        app().getCustomErrorHandler()(k400BadRequest, req));
                }
@ -966,6 +973,8 @@ void HttpServer::sendResponse(const TcpConnectionPtr &conn,
    {
        auto httpString = respImplPtr->renderToBuffer();
        conn->send(httpString);
+        if (!respImplPtr->contentLengthIsAllowed())
+            return;
        auto &asyncStreamCallback = respImplPtr->asyncStreamCallback();
        if (asyncStreamCallback)
        {
@ -1046,6 +1055,8 @@ void HttpServer::sendResponses(
        {
            // Not HEAD method
            respImplPtr->renderToBuffer(buffer);
+            if (!respImplPtr->contentLengthIsAllowed())
+                continue;
            auto &asyncStreamCallback = respImplPtr->asyncStreamCallback();
            if (asyncStreamCallback)
            {
@ -1191,7 +1202,7 @@ static inline HttpResponsePtr tryDecompressRequest(
 * @brief Check request against each sync advice, generate response if request
 * is rejected by any one of them.
 *
- * @return true if all sync advices are passed.
+ * @return true if all sync advice are passed.
 * @return false if rejected by any sync advice.
 */
 static inline bool passSyncAdvices(
--- a/lib/src/HttpServer.h
+++ b/lib/src/HttpServer.h
@ -49,6 +49,11 @@ class HttpServer : trantor::NonCopyable
        server_.enableSSL(std::move(policy));
    }

+    void reloadSSL()
+    {
+        server_.reloadSSL();
+    }
+
    const trantor::InetAddress &address() const
    {
        return server_.address();
@ -64,6 +69,12 @@ class HttpServer : trantor::NonCopyable
        afterAcceptSetSockOptCallback_ = std::move(cb);
    }

+    void setConnectionCallback(
+        std::function<void(const trantor::TcpConnectionPtr &)> cb)
+    {
+        connectionCallback_ = std::move(cb);
+    }
+
  private:
    friend class HttpInternalForwardHelper;

@ -139,6 +150,7 @@ class HttpServer : trantor::NonCopyable

    std::function<void(int)> beforeListenSetSockOptCallback_;
    std::function<void(int)> afterAcceptSetSockOptCallback_;
+    std::function<void(const trantor::TcpConnectionPtr &)> connectionCallback_;
 };

 class HttpInternalForwardHelper
--- a/lib/src/ListenerManager.cc
+++ b/lib/src/ListenerManager.cc
@ -121,6 +121,10 @@ void ListenerManager::createListeners(
                serverPtr->setAfterAcceptSockOptCallback(
                    afterAcceptSetSockOptCallback_);
            }
+            if (connectionCallback_)
+            {
+                serverPtr->setConnectionCallback(connectionCallback_);
+            }

            if (listener.useSSL_ && utils::supportsTls())
            {
@ -214,3 +218,11 @@ void ListenerManager::stopListening()
        listeningThread_->wait();
    }
 }
+
+void ListenerManager::reloadSSLFiles()
+{
+    for (auto &server : servers_)
+    {
+        server->reloadSSL();
+    }
+}
--- a/lib/src/ListenerManager.h
+++ b/lib/src/ListenerManager.h
@ -61,6 +61,14 @@ class ListenerManager : public trantor::NonCopyable
        afterAcceptSetSockOptCallback_ = std::move(cb);
    }

+    void setConnectionCallback(
+        std::function<void(const trantor::TcpConnectionPtr &)> cb)
+    {
+        connectionCallback_ = std::move(cb);
+    }
+
+    void reloadSSLFiles();
+
  private:
    struct ListenerInfo
    {
@ -99,6 +107,7 @@ class ListenerManager : public trantor::NonCopyable
    std::unique_ptr<trantor::EventLoopThread> listeningThread_;
    std::function<void(int)> beforeListenSetSockOptCallback_;
    std::function<void(int)> afterAcceptSetSockOptCallback_;
+    std::function<void(const trantor::TcpConnectionPtr &)> connectionCallback_;
 };

 }  // namespace drogon
--- a/lib/src/PromExporter.cc
+++ b/lib/src/PromExporter.cc
@ -28,6 +28,7 @@ void PromExporter::initAndStart(const Json::Value &config)
            }
            auto resp = HttpResponse::newHttpResponse();
            resp->setBody(thisPtr->exportMetrics());
+            resp->setContentTypeCode(CT_TEXT_PLAIN);
            resp->setExpiredTime(5);
            callback(resp);
        },
@ -118,12 +119,12 @@ static std::string exportCollector(
        .append(collector->name())
        .append(" ")
        .append(collector->help())
-        .append("\r\n");
+        .append("\n");
    res.append("# TYPE ")
        .append(collector->name())
        .append(" ")
        .append(collector->type())
-        .append("\r\n");
+        .append("\n");
    for (auto const &sampleGroup : sampleGroups)
    {
        auto const &metricPtr = sampleGroup.metric;
@ -157,11 +158,11 @@ static std::string exportCollector(
                res.append(" ")
                    .append(std::to_string(
                        sample.timestamp.microSecondsSinceEpoch() / 1000))
-                    .append("\r\n");
+                    .append("\n");
            }
            else
            {
-                res.append("\r\n");
+                res.append("\n");
            }
        }
    }
--- a/lib/src/RealIpResolver.cc
+++ b/lib/src/RealIpResolver.cc
@ -96,21 +96,20 @@ void RealIpResolver::initAndStart(const Json::Value &config)
    }

    const Json::Value &trustIps = config["trust_ips"];
-    if (!trustIps.isArray())
+    if (!trustIps.isNull() && !trustIps.isArray())
    {
        throw std::runtime_error("Invalid trusted_ips. Should be array.");
    }
-    for (const auto &elem : trustIps)
+    for (const auto &ipOrCidr : trustIps)
    {
-        std::string ipOrCidr = elem.asString();
-        trustCIDRs_.emplace_back(ipOrCidr);
+        trustCIDRs_.emplace_back(ipOrCidr.asString());
    }

    drogon::app().registerPreRoutingAdvice([this](const HttpRequestPtr &req) {
        const auto &headers = req->headers();
        auto ipHeaderFind = headers.find(fromHeader_);
        const trantor::InetAddress &peerAddr = req->getPeerAddr();
-        if (ipHeaderFind == headers.end() || !matchCidr(peerAddr))
+        if (ipHeaderFind == headers.end() || !matchCidr(peerAddr, trustCIDRs_))
        {
            // Target header is empty, or
            // direct peer is already a non-proxy
@ -139,7 +138,7 @@ void RealIpResolver::initAndStart(const Json::Value &config)
        while (!(ip = parser.getNext()).empty())
        {
            trantor::InetAddress addr = parseAddress(ip);
-            if (addr.isUnspecified() || matchCidr(addr))
+            if (addr.isUnspecified() || matchCidr(addr, trustCIDRs_))
            {
                continue;
            }
@ -177,9 +176,10 @@ const trantor::InetAddress &RealIpResolver::getRealAddr(
    return attributesPtr->get<trantor::InetAddress>(attributeKey_);
 }

-bool RealIpResolver::matchCidr(const trantor::InetAddress &addr) const
+bool RealIpResolver::matchCidr(const trantor::InetAddress &addr,
+                               const CIDRs &trustCIDRs)
 {
-    for (auto &cidr : trustCIDRs_)
+    for (const auto &cidr : trustCIDRs)
    {
        if ((addr.ipNetEndian() & cidr.mask_) == cidr.addr_)
        {
--- a/lib/src/Redirector.cc
+++ b/lib/src/Redirector.cc
@ -30,6 +30,10 @@ void Redirector::initAndStart(const Json::Value &config)
            }
            std::string protocol, host;
            bool pathChanged{false};
+            for (auto &handler : thisPtr->pathRewriteHandlers_)
+            {
+                pathChanged |= handler(req);
+            }
            for (auto &handler : thisPtr->handlers_)
            {
                if (!handler(req, protocol, host, pathChanged))
@ -37,10 +41,6 @@ void Redirector::initAndStart(const Json::Value &config)
                    return HttpResponse::newNotFoundResponse(req);
                }
            }
-            for (auto &handler : thisPtr->pathRewriteHandlers_)
-            {
-                pathChanged |= handler(req);
-            }
            if (!protocol.empty() || !host.empty() || pathChanged)
            {
                std::string url;
--- a/lib/src/StaticFileRouter.cc
+++ b/lib/src/StaticFileRouter.cc
@ -44,7 +44,7 @@ void StaticFileRouter::init(const std::vector<trantor::EventLoop *> &ioLoops)
                   size_t i) {
            assert(i == ioLoops[i]->index());
            mapPtr = std::make_unique<CacheMap<std::string, char>>(ioLoops[i],
-                                                                   1.0,
+                                                                   1.0f,
                                                                   4,
                                                                   50);
        });
--- a/lib/src/Utilities.cc
+++ b/lib/src/Utilities.cc
@ -33,6 +33,7 @@
 #include <sstream>
 #include <string>
 #include <mutex>
+#include <random>
 #include <algorithm>
 #include <array>
 #include <locale>
@ -83,12 +84,12 @@ namespace drogon
 {
 namespace utils
 {
-static const std::string base64Chars =
+static constexpr std::string_view base64Chars =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "abcdefghijklmnopqrstuvwxyz"
    "0123456789+/";

-static const std::string urlBase64Chars =
+static constexpr std::string_view urlBase64Chars =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "abcdefghijklmnopqrstuvwxyz"
    "0123456789-_";
@ -162,28 +163,16 @@ bool isBase64(std::string_view str)

 std::string genRandomString(int length)
 {
-    static const char char_space[] =
+    static const std::string_view char_space =
        "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-    static std::once_flag once;
-    static const size_t len = strlen(char_space);
-    static const int randMax = RAND_MAX - (RAND_MAX % len);
-    std::call_once(once, []() {
-        std::srand(static_cast<unsigned int>(time(nullptr)));
-    });
+    std::uniform_int_distribution<size_t> dist(0, char_space.size() - 1);
+    thread_local std::mt19937 rng(std::random_device{}());

-    int i;
    std::string str;
    str.resize(length);
-
-    for (i = 0; i < length; ++i)
+    for (char &ch : str)
    {
-        int x = std::rand();
-        while (x >= randMax)
-        {
-            x = std::rand();
-        }
-        x = (x % len);
-        str[i] = char_space[x];
+        ch = char_space[dist(rng)];
    }

    return str;
@ -440,33 +429,33 @@ std::string getUuid(bool lowercase)
 #endif
 }

-std::string base64Encode(const unsigned char *bytes_to_encode,
-                         size_t in_len,
-                         bool url_safe,
+void base64Encode(const unsigned char *bytesToEncode,
+                  size_t inLen,
+                  unsigned char *outputBuffer,
+                  bool urlSafe,
                  bool padded)
 {
-    std::string ret;
-    ret.reserve(base64EncodedLength(in_len, padded));
    int i = 0;
-    unsigned char char_array_3[3];
-    unsigned char char_array_4[4];
+    unsigned char charArray3[3];
+    unsigned char charArray4[4];

-    const std::string &charSet = url_safe ? urlBase64Chars : base64Chars;
+    const std::string_view charSet = urlSafe ? urlBase64Chars : base64Chars;

-    while (in_len--)
+    size_t a = 0;
+    while (inLen--)
    {
-        char_array_3[i++] = *(bytes_to_encode++);
+        charArray3[i++] = *(bytesToEncode++);
        if (i == 3)
        {
-            char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
-            char_array_4[1] = ((char_array_3[0] & 0x03) << 4) +
-                              ((char_array_3[1] & 0xf0) >> 4);
-            char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) +
-                              ((char_array_3[2] & 0xc0) >> 6);
-            char_array_4[3] = char_array_3[2] & 0x3f;
+            charArray4[0] = (charArray3[0] & 0xfc) >> 2;
+            charArray4[1] =
+                ((charArray3[0] & 0x03) << 4) + ((charArray3[1] & 0xf0) >> 4);
+            charArray4[2] =
+                ((charArray3[1] & 0x0f) << 2) + ((charArray3[2] & 0xc0) >> 6);
+            charArray4[3] = charArray3[2] & 0x3f;

-            for (i = 0; (i < 4); ++i)
-                ret += charSet[char_array_4[i]];
+            for (i = 0; (i < 4); ++i, ++a)
+                outputBuffer[a] = charSet[charArray4[i]];
            i = 0;
        }
    }
@ -474,59 +463,61 @@ std::string base64Encode(const unsigned char *bytes_to_encode,
    if (i)
    {
        for (int j = i; j < 3; ++j)
-            char_array_3[j] = '\0';
+            charArray3[j] = '\0';

-        char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
-        char_array_4[1] =
-            ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
-        char_array_4[2] =
-            ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
-        char_array_4[3] = char_array_3[2] & 0x3f;
+        charArray4[0] = (charArray3[0] & 0xfc) >> 2;
+        charArray4[1] =
+            ((charArray3[0] & 0x03) << 4) + ((charArray3[1] & 0xf0) >> 4);
+        charArray4[2] =
+            ((charArray3[1] & 0x0f) << 2) + ((charArray3[2] & 0xc0) >> 6);
+        charArray4[3] = charArray3[2] & 0x3f;

-        for (int j = 0; (j <= i); ++j)
-            ret += charSet[char_array_4[j]];
+        for (int j = 0; (j <= i); ++j, ++a)
+            outputBuffer[a] = charSet[charArray4[j]];

        if (padded)
            while ((++i < 4))
-                ret += '=';
+            {
+                outputBuffer[a] = '=';
+                ++a;
+            }
    }
-    return ret;
 }

-std::vector<char> base64DecodeToVector(std::string_view encoded_string)
+std::vector<char> base64DecodeToVector(std::string_view encodedString)
 {
-    auto in_len = encoded_string.size();
+    auto inLen = encodedString.size();
    int i = 0;
    int in_{0};
-    char char_array_4[4], char_array_3[3];
+    char charArray4[4], charArray3[3];
    std::vector<char> ret;
-    ret.reserve(base64DecodedLength(in_len));
+    ret.reserve(base64DecodedLength(inLen));

-    while (in_len-- && (encoded_string[in_] != '='))
+    while (inLen-- && (encodedString[in_] != '='))
    {
-        if (!isBase64(encoded_string[in_]))
+        if (!isBase64(encodedString[in_]))
        {
            ++in_;
            continue;
        }

-        char_array_4[i++] = encoded_string[in_];
+        charArray4[i++] = encodedString[in_];
        ++in_;
        if (i == 4)
        {
            for (i = 0; i < 4; ++i)
            {
-                char_array_4[i] = base64CharMap.getIndex(char_array_4[i]);
+                charArray4[i] = base64CharMap.getIndex(charArray4[i]);
            }

-            char_array_3[0] =
-                (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
-            char_array_3[1] = ((char_array_4[1] & 0xf) << 4) +
-                              ((char_array_4[2] & 0x3c) >> 2);
-            char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+            charArray3[0] =
+                (charArray4[0] << 2) + ((charArray4[1] & 0x30) >> 4);
+            charArray3[1] =
+                ((charArray4[1] & 0xf) << 4) + ((charArray4[2] & 0x3c) >> 2);
+            charArray3[2] = ((charArray4[2] & 0x3) << 6) + charArray4[3];

            for (i = 0; (i < 3); ++i)
-                ret.push_back(char_array_3[i]);
+                ret.push_back(charArray3[i]);
            i = 0;
        }
    }
@ -534,60 +525,59 @@ std::vector<char> base64DecodeToVector(std::string_view encoded_string)
    if (i)
    {
        for (int j = i; j < 4; ++j)
-            char_array_4[j] = 0;
+            charArray4[j] = 0;

        for (int j = 0; j < 4; ++j)
        {
-            char_array_4[j] = base64CharMap.getIndex(char_array_4[j]);
+            charArray4[j] = base64CharMap.getIndex(charArray4[j]);
        }

-        char_array_3[0] =
-            (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
-        char_array_3[1] =
-            ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
-        char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+        charArray3[0] = (charArray4[0] << 2) + ((charArray4[1] & 0x30) >> 4);
+        charArray3[1] =
+            ((charArray4[1] & 0xf) << 4) + ((charArray4[2] & 0x3c) >> 2);
+        charArray3[2] = ((charArray4[2] & 0x3) << 6) + charArray4[3];

        --i;
        for (int j = 0; (j < i); ++j)
-            ret.push_back(char_array_3[j]);
+            ret.push_back(charArray3[j]);
    }

    return ret;
 }

-std::string base64Decode(std::string_view encoded_string)
+size_t base64Decode(const char *encodedString,
+                    size_t inLen,
+                    unsigned char *outputBuffer)
 {
-    auto in_len = encoded_string.size();
    int i = 0;
    int in_{0};
-    unsigned char char_array_4[4], char_array_3[3];
-    std::string ret;
-    ret.reserve(base64DecodedLength(in_len));
+    unsigned char charArray4[4], charArray3[3];

-    while (in_len-- && (encoded_string[in_] != '='))
+    size_t a = 0;
+    while (inLen-- && (encodedString[in_] != '='))
    {
-        if (!isBase64(encoded_string[in_]))
+        if (!isBase64(encodedString[in_]))
        {
            ++in_;
            continue;
        }

-        char_array_4[i++] = encoded_string[in_];
+        charArray4[i++] = encodedString[in_];
        ++in_;
        if (i == 4)
        {
            for (i = 0; i < 4; ++i)
            {
-                char_array_4[i] = base64CharMap.getIndex(char_array_4[i]);
+                charArray4[i] = base64CharMap.getIndex(charArray4[i]);
            }
-            char_array_3[0] =
-                (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
-            char_array_3[1] = ((char_array_4[1] & 0xf) << 4) +
-                              ((char_array_4[2] & 0x3c) >> 2);
-            char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+            charArray3[0] =
+                (charArray4[0] << 2) + ((charArray4[1] & 0x30) >> 4);
+            charArray3[1] =
+                ((charArray4[1] & 0xf) << 4) + ((charArray4[2] & 0x3c) >> 2);
+            charArray3[2] = ((charArray4[2] & 0x3) << 6) + charArray4[3];

-            for (i = 0; (i < 3); ++i)
-                ret += char_array_3[i];
+            for (i = 0; (i < 3); ++i, ++a)
+                outputBuffer[a] = charArray3[i];
            i = 0;
        }
    }
@ -595,25 +585,24 @@ std::string base64Decode(std::string_view encoded_string)
    if (i)
    {
        for (int j = i; j < 4; ++j)
-            char_array_4[j] = 0;
+            charArray4[j] = 0;

        for (int j = 0; j < 4; ++j)
        {
-            char_array_4[j] = base64CharMap.getIndex(char_array_4[j]);
+            charArray4[j] = base64CharMap.getIndex(charArray4[j]);
        }

-        char_array_3[0] =
-            (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
-        char_array_3[1] =
-            ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
-        char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+        charArray3[0] = (charArray4[0] << 2) + ((charArray4[1] & 0x30) >> 4);
+        charArray3[1] =
+            ((charArray4[1] & 0xf) << 4) + ((charArray4[2] & 0x3c) >> 2);
+        charArray3[2] = ((charArray4[2] & 0x3) << 6) + charArray4[3];

        --i;
-        for (int j = 0; (j < i); ++j)
-            ret += char_array_3[j];
+        for (int j = 0; (j < i); ++j, ++a)
+            outputBuffer[a] = charArray3[j];
    }

-    return ret;
+    return a;
 }

 static std::string charToHex(char c)
@ -1045,6 +1034,35 @@ char *getHttpFullDate(const trantor::Date &date)
    return lastTimeString;
 }

+void dateToCustomFormattedString(const std::string &fmtStr,
+                                 std::string &str,
+                                 const trantor::Date &date)
+{
+    auto nowSecond = date.microSecondsSinceEpoch() / MICRO_SECONDS_PRE_SEC;
+    time_t seconds = static_cast<time_t>(nowSecond);
+    struct tm tm_LValue = date.tmStruct();
+    std::stringstream Out;
+    Out.imbue(std::locale{"C"});
+    Out << std::put_time(&tm_LValue, fmtStr.c_str());
+    str = Out.str();
+}
+
+const std::string &getHttpFullDateStr(const trantor::Date &date)
+{
+    static thread_local int64_t lastSecond = 0;
+    static thread_local std::string lastTimeString(128, 0);
+    auto nowSecond = date.microSecondsSinceEpoch() / MICRO_SECONDS_PRE_SEC;
+    if (nowSecond == lastSecond)
+    {
+        return lastTimeString;
+    }
+    lastSecond = nowSecond;
+    dateToCustomFormattedString("%a, %d %b %Y %H:%M:%S GMT",
+                                lastTimeString,
+                                date);
+    return lastTimeString;
+}
+
 trantor::Date getHttpDate(const std::string &httpFullDateString)
 {
    static const std::array<const char *, 4> formats = {
--- a/lib/src/WebSocketConnectionImpl.cc
+++ b/lib/src/WebSocketConnectionImpl.cc
@ -17,6 +17,7 @@
 #include <json/value.h>
 #include <json/writer.h>
 #include <thread>
+#include <limits>

 using namespace drogon;

@ -268,14 +269,14 @@ bool WebSocketMessageParser::parse(trantor::MsgBuffer *buffer)
 {
    // According to the rfc6455
    gotAll_ = false;
-    if (buffer->readableBytes() >= 2)
+    while (buffer->readableBytes() >= 2)
    {
        unsigned char opcode = (*buffer)[0] & 0x0f;
        bool isControlFrame = false;
        switch (opcode)
        {
            case 0:
-                // continuation frame
+                LOG_TRACE << "continuation frame";
                break;
            case 1:
                type_ = WebSocketMessageType::Text;
@ -327,8 +328,13 @@ bool WebSocketMessageParser::parse(trantor::MsgBuffer *buffer)
        {
            indexFirstMask = 10;
        }
-        if (indexFirstMask > 2 && buffer->readableBytes() >= indexFirstMask)
+        if (indexFirstMask > 2)
        {
+            if (buffer->readableBytes() < indexFirstMask)
+            {
+                // Not enough data yet, wait for more.
+                return true;
+            }
            if (isControlFrame)
            {
                // rfc6455-5.5
@ -344,14 +350,17 @@ bool WebSocketMessageParser::parse(trantor::MsgBuffer *buffer)
            }
            else if (indexFirstMask == 10)
            {
-                length = (unsigned char)(*buffer)[2];
-                length = (length << 8) + (unsigned char)(*buffer)[3];
-                length = (length << 8) + (unsigned char)(*buffer)[4];
-                length = (length << 8) + (unsigned char)(*buffer)[5];
-                length = (length << 8) + (unsigned char)(*buffer)[6];
-                length = (length << 8) + (unsigned char)(*buffer)[7];
-                length = (length << 8) + (unsigned char)(*buffer)[8];
-                length = (length << 8) + (unsigned char)(*buffer)[9];
+                length = 0;
+                for (int i = 2; i <= 9; ++i)
+                {
+                    if (length > ((std::numeric_limits<size_t>::max)() >> 8))
+                    {
+                        LOG_ERROR
+                            << "Payload length too large to handle safely";
+                        return false;
+                    }
+                    length = (length << 8) + (unsigned char)(*buffer)[i];
+                }
            }
            else
            {
@ -380,9 +389,16 @@ bool WebSocketMessageParser::parse(trantor::MsgBuffer *buffer)
                {
                    message_[oldLen + i] = (rawData[i] ^ masks[i % 4]);
                }
-                if (isFin)
-                    gotAll_ = true;
                buffer->retrieve(indexFirstMask + 4 + length);
+                if (isFin)
+                {
+                    gotAll_ = true;
+                    return true;
+                }
+            }
+            else
+            {
+                // Not enough data yet, wait for more.
                return true;
            }
        }
@ -392,9 +408,16 @@ bool WebSocketMessageParser::parse(trantor::MsgBuffer *buffer)
            {
                auto rawData = buffer->peek() + indexFirstMask;
                message_.append(rawData, length);
-                if (isFin)
-                    gotAll_ = true;
                buffer->retrieve(indexFirstMask + length);
+                if (isFin)
+                {
+                    gotAll_ = true;
+                    return true;
+                }
+            }
+            else
+            {
+                // Not enough data yet, wait for more.
                return true;
            }
        }
--- a/lib/tests/CMakeLists.txt
+++ b/lib/tests/CMakeLists.txt
@ -42,7 +42,8 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC" AND BUILD_SHARED_LIBS)
  set(UNITTEST_SOURCES ${UNITTEST_SOURCES} ../src/HttpUtils.cc)
 else()
  set(UNITTEST_SOURCES ${UNITTEST_SOURCES} ../src/HttpFileImpl.cc
-                       unittests/HttpFileTest.cc)
+                       unittests/HttpFileTest.cc
+                       unittests/WebsocketResponseTest.cc)
 endif()

 add_executable(unittest ${UNITTEST_SOURCES})
--- a/lib/tests/CookieSameSite.cc
+++ b/lib/tests/CookieSameSite.cc
@ -44,8 +44,7 @@ DROGON_TEST(CookieSameSite)
        if (seq.sessionCookie.getValue() != "")
        {
            // add session cookie
-            req->addCookie(seq.sessionCookie.getKey(),
-                           seq.sessionCookie.getValue());
+            req->addCookie(seq.sessionCookie.key(), seq.sessionCookie.value());
        }  // endif

        client->sendRequest(
--- a/lib/tests/integration_test/server/main.cc
+++ b/lib/tests/integration_test/server/main.cc
@ -408,8 +408,7 @@ int main()
    app().registerCustomExtensionMime("md", "text/markdown");
    app().setFileTypes({"md", "html", "jpg", "cc", "txt"});
    std::cout << "Date: "
-              << std::string{drogon::utils::getHttpFullDate(
-                     trantor::Date::now())}
+              << drogon::utils::getHttpFullDateStr(trantor::Date::now())
              << std::endl;

    app().registerBeginningAdvice(
--- a/lib/tests/unittests/CookieTest.cc
+++ b/lib/tests/unittests/CookieTest.cc
@ -35,4 +35,29 @@ DROGON_TEST(CookieTest)
          drogon::Cookie::convertString2SameSite("Strict"));
    CHECK(drogon::Cookie::SameSite::kNone ==
          drogon::Cookie::convertString2SameSite("None"));
+
+    // Test for Partitioned attribute
+    drogon::Cookie cookie6("test", "6");
+    cookie6.setPartitioned(true);
+    CHECK(cookie6.cookieString() ==
+          "Set-Cookie: test=6; Secure; HttpOnly; Partitioned\r\n");
+    // Test that partitioned attribute  automatically sets secure
+    drogon::Cookie cookie7("test", "7");
+    cookie7.setPartitioned(true);
+    CHECK(cookie7.isSecure() == true);
+    // Test other attributes
+    drogon::Cookie cookie8("test", "8");
+    cookie8.setPartitioned(true);
+    cookie8.setDomain("drogon.org");
+    cookie8.setMaxAge(3600);
+    CHECK(cookie8.cookieString() ==
+          "Set-Cookie: test=8; Max-Age=3600; Domain=drogon.org; Secure; "
+          "HttpOnly; Partitioned\r\n");
+    // Teset Partitioned and SameSite can coexist
+    drogon::Cookie cookie9("test", "9");
+    cookie9.setPartitioned(true);
+    cookie9.setSameSite(drogon::Cookie::SameSite::kLax);
+    CHECK(
+        cookie9.cookieString() ==
+        "Set-Cookie: test=9; SameSite=Lax; Secure; HttpOnly; Partitioned\r\n");
 }
--- a/lib/tests/unittests/CoroutineTest.cc
+++ b/lib/tests/unittests/CoroutineTest.cc
@ -2,6 +2,10 @@
 #include <drogon/utils/coroutine.h>
 #include <drogon/HttpAppFramework.h>
 #include <trantor/net/EventLoopThread.h>
+#include <trantor/net/EventLoopThreadPool.h>
+#include <chrono>
+#include <cstdint>
+#include <future>
 #include <type_traits>

 using namespace drogon;
@ -212,3 +216,32 @@ DROGON_TEST(SwitchThread)
    sync_wait(switch_thread());
    thread.wait();
 }
+
+DROGON_TEST(Mutex)
+{
+    trantor::EventLoopThreadPool pool{3};
+    pool.start();
+    Mutex mutex;
+    async_run([&]() -> Task<> {
+        co_await switchThreadCoro(pool.getLoop(0));
+        auto guard = co_await mutex.scoped_lock();
+        co_await sleepCoro(pool.getLoop(1), std::chrono::seconds(2));
+        co_return;
+    });
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    std::promise<void> done;
+    async_run([&]() -> Task<> {
+        co_await switchThreadCoro(pool.getLoop(2));
+        auto id = std::this_thread::get_id();
+        co_await mutex.lock();
+        CHECK(id == std::this_thread::get_id());
+        mutex.unlock();
+        CHECK(id == std::this_thread::get_id());
+        done.set_value();
+        co_return;
+    });
+    done.get_future().wait();
+    for (int16_t i = 0; i < 3; i++)
+        pool.getLoop(i)->quit();
+    pool.wait();
+}
--- a/lib/tests/unittests/DrObjectTest.cc
+++ b/lib/tests/unittests/DrObjectTest.cc
@ -1,5 +1,6 @@
 #include <drogon/DrObject.h>
 #include <drogon/drogon_test.h>
+#include <drogon/HttpController.h>

 using namespace drogon;

@ -41,3 +42,45 @@ DROGON_TEST(DrObjectNamespaceTest)
    CHECK(objPtr2.get() != nullptr);
    CHECK(objPtr == objPtr2);
 }
+
+class TestC : public DrObject<TestC>
+{
+  public:
+    static constexpr bool isAutoCreation = true;
+};
+
+class TestD : public DrObject<TestD>
+{
+  public:
+    static constexpr bool isAutoCreation = false;
+};
+
+class TestE : public DrObject<TestE>
+{
+  public:
+    static constexpr double isAutoCreation = 3.0;
+};
+
+class CtrlA : public HttpController<CtrlA>
+{
+  public:
+    METHOD_LIST_BEGIN
+    METHOD_LIST_END
+};
+
+class CtrlB : public HttpController<CtrlB, false>
+{
+  public:
+    METHOD_LIST_BEGIN
+    METHOD_LIST_END
+};
+
+DROGON_TEST(IsAutoCreationClassTest)
+{
+    STATIC_REQUIRE(isAutoCreationClass<TestA>::value == false);
+    STATIC_REQUIRE(isAutoCreationClass<TestC>::value == true);
+    STATIC_REQUIRE(isAutoCreationClass<TestD>::value == false);
+    STATIC_REQUIRE(isAutoCreationClass<TestE>::value == false);
+    STATIC_REQUIRE(isAutoCreationClass<CtrlA>::value == true);
+    STATIC_REQUIRE(isAutoCreationClass<CtrlB>::value == false);
+}
--- a/lib/tests/unittests/HttpFullDateTest.cc
+++ b/lib/tests/unittests/HttpFullDateTest.cc
@ -7,7 +7,7 @@ using namespace drogon;

 DROGON_TEST(HttpFullDateTest)
 {
-    auto str = utils::getHttpFullDate();
+    auto str = utils::getHttpFullDateStr();
    auto date = utils::getHttpDate(str);
    CHECK(utils::getHttpFullDate(date) == str);
 }
--- a/lib/tests/unittests/WebsocketResponseTest.cc
+++ b/lib/tests/unittests/WebsocketResponseTest.cc
@ -0,0 +1,40 @@
+#include <drogon/drogon_test.h>
+
+#include "../../lib/src/HttpRequestImpl.h"
+#include "../../lib/src/HttpResponseImpl.h"
+#include "../../lib/src/HttpControllerBinder.h"
+
+using namespace drogon;
+
+DROGON_TEST(WebsocketReponseTest)
+{
+    WebsocketControllerBinder binder;
+
+    auto reqPtr = std::make_shared<HttpRequestImpl>(nullptr);
+
+    // Value from rfc6455-1.3
+    reqPtr->addHeader("sec-websocket-key", "dGhlIHNhbXBsZSBub25jZQ==");
+
+    binder.handleRequest(reqPtr, [&](const HttpResponsePtr &resp) {
+        CHECK(resp->statusCode() == k101SwitchingProtocols);
+        CHECK(resp->headers().size() == 3);
+        CHECK(resp->getHeader("Upgrade") == "websocket");
+        CHECK(resp->getHeader("Connection") == "Upgrade");
+
+        // Value from rfc6455-1.3
+        CHECK(resp->getHeader("Sec-WebSocket-Accept") ==
+              "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=");
+
+        auto implPtr = std::dynamic_pointer_cast<HttpResponseImpl>(resp);
+
+        implPtr->makeHeaderString();
+        auto buffer = implPtr->renderToBuffer();
+        auto str = std::string{buffer->peek(), buffer->readableBytes()};
+
+        CHECK(str.find("upgrade: websocket") != std::string::npos);
+        CHECK(str.find("connection: Upgrade") != std::string::npos);
+        CHECK(str.find("sec-websocket-accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=") !=
+              std::string::npos);
+        CHECK(str.find("content-length:") == std::string::npos);
+    });
+}
--- a/orm_lib/inc/drogon/orm/DbClient.h
+++ b/orm_lib/inc/drogon/orm/DbClient.h
@ -214,6 +214,28 @@ class DROGON_EXPORT DbClient : public trantor::NonCopyable
            (binder << std::forward<Arguments>(args), 0)...};
        return internal::SqlAwaiter(std::move(binder));
    }
+
+    /**
+     * @brief Execute a SQL query asynchronously using coroutine support.
+     *        This overload accepts a vector of arguments to bind to the query.
+     * @tparam T The type of the elements in the vector.
+     * @param sql The SQL query string to execute.
+     * @param args A vector of arguments to bind to the query.
+     * @return A SqlAwaiter object that can be co_awaited to retrieve the query
+     * result.
+     * @note This method is only available when coroutine support is enabled.
+     */
+    template <typename T>
+    internal::SqlAwaiter execSqlCoro(const std::string &sql,
+                                     const std::vector<T> &args) noexcept
+    {
+        auto binder = *this << sql;
+        for (const auto &arg : args)
+        {
+            binder << arg;
+        }
+        return internal::SqlAwaiter(std::move(binder));
+    }
 #endif

    /// Streaming-like method for sql execution. For more information, see the
--- a/orm_lib/inc/drogon/orm/Exception.h
+++ b/orm_lib/inc/drogon/orm/Exception.h
@ -137,15 +137,24 @@ class SqlError : public Failure
    /// SQLSTATE string describing the error type, if known; or empty string.
    const std::string sqlState_;

+    const int errcode_{0};
+    const int extendedErrcode_{0};
+
  public:
    DROGON_EXPORT explicit SqlError(const std::string &msg = "",
                                    const std::string &Q = "",
                                    const char sqlstate[] = nullptr);
+    DROGON_EXPORT explicit SqlError(const std::string &msg,
+                                    const std::string &Q,
+                                    const int errcode,
+                                    const int extendedErrcode);
    DROGON_EXPORT virtual ~SqlError() noexcept;

    /// The query whose execution triggered the exception
    DROGON_EXPORT const std::string &query() const noexcept;
    DROGON_EXPORT const std::string &sqlState() const noexcept;
+    DROGON_EXPORT int errcode() const noexcept;
+    DROGON_EXPORT int extendedErrcode() const noexcept;
 };

 /// "Help, I don't know whether transaction was committed successfully!"
@ -293,6 +302,14 @@ class FeatureNotSupported : public SqlError
        : SqlError(err, Q, sqlstate)
    {
    }
+
+    explicit FeatureNotSupported(const std::string &msg,
+                                 const std::string &Q,
+                                 const int errcode,
+                                 const int extendedErrcode)
+        : SqlError(msg, Q, errcode, extendedErrcode)
+    {
+    }
 };

 /// Error in data provided to SQL statement
@ -305,6 +322,14 @@ class DataException : public SqlError
        : SqlError(err, Q, sqlstate)
    {
    }
+
+    explicit DataException(const std::string &msg,
+                           const std::string &Q,
+                           const int errcode,
+                           const int extendedErrcode)
+        : SqlError(msg, Q, errcode, extendedErrcode)
+    {
+    }
 };

 class IntegrityConstraintViolation : public SqlError
@ -316,6 +341,14 @@ class IntegrityConstraintViolation : public SqlError
        : SqlError(err, Q, sqlstate)
    {
    }
+
+    explicit IntegrityConstraintViolation(const std::string &msg,
+                                          const std::string &Q,
+                                          const int errcode,
+                                          const int extendedErrcode)
+        : SqlError(msg, Q, errcode, extendedErrcode)
+    {
+    }
 };

 class RestrictViolation : public IntegrityConstraintViolation
@ -327,6 +360,14 @@ class RestrictViolation : public IntegrityConstraintViolation
        : IntegrityConstraintViolation(err, Q, sqlstate)
    {
    }
+
+    explicit RestrictViolation(const std::string &msg,
+                               const std::string &Q,
+                               const int errcode,
+                               const int extendedErrcode)
+        : IntegrityConstraintViolation(msg, Q, errcode, extendedErrcode)
+    {
+    }
 };

 class NotNullViolation : public IntegrityConstraintViolation
@ -338,6 +379,14 @@ class NotNullViolation : public IntegrityConstraintViolation
        : IntegrityConstraintViolation(err, Q, sqlstate)
    {
    }
+
+    explicit NotNullViolation(const std::string &msg,
+                              const std::string &Q,
+                              const int errcode,
+                              const int extendedErrcode)
+        : IntegrityConstraintViolation(msg, Q, errcode, extendedErrcode)
+    {
+    }
 };

 class ForeignKeyViolation : public IntegrityConstraintViolation
@ -349,6 +398,14 @@ class ForeignKeyViolation : public IntegrityConstraintViolation
        : IntegrityConstraintViolation(err, Q, sqlstate)
    {
    }
+
+    explicit ForeignKeyViolation(const std::string &msg,
+                                 const std::string &Q,
+                                 const int errcode,
+                                 const int extendedErrcode)
+        : IntegrityConstraintViolation(msg, Q, errcode, extendedErrcode)
+    {
+    }
 };

 class UniqueViolation : public IntegrityConstraintViolation
@ -360,6 +417,14 @@ class UniqueViolation : public IntegrityConstraintViolation
        : IntegrityConstraintViolation(err, Q, sqlstate)
    {
    }
+
+    explicit UniqueViolation(const std::string &msg,
+                             const std::string &Q,
+                             const int errcode,
+                             const int extendedErrcode)
+        : IntegrityConstraintViolation(msg, Q, errcode, extendedErrcode)
+    {
+    }
 };

 class CheckViolation : public IntegrityConstraintViolation
@ -371,6 +436,14 @@ class CheckViolation : public IntegrityConstraintViolation
        : IntegrityConstraintViolation(err, Q, sqlstate)
    {
    }
+
+    explicit CheckViolation(const std::string &msg,
+                            const std::string &Q,
+                            const int errcode,
+                            const int extendedErrcode)
+        : IntegrityConstraintViolation(msg, Q, errcode, extendedErrcode)
+    {
+    }
 };

 class InvalidCursorState : public SqlError
@ -382,6 +455,14 @@ class InvalidCursorState : public SqlError
        : SqlError(err, Q, sqlstate)
    {
    }
+
+    explicit InvalidCursorState(const std::string &msg,
+                                const std::string &Q,
+                                const int errcode,
+                                const int extendedErrcode)
+        : SqlError(msg, Q, errcode, extendedErrcode)
+    {
+    }
 };

 class InvalidSqlStatementName : public SqlError
@ -393,6 +474,14 @@ class InvalidSqlStatementName : public SqlError
        : SqlError(err, Q, sqlstate)
    {
    }
+
+    explicit InvalidSqlStatementName(const std::string &msg,
+                                     const std::string &Q,
+                                     const int errcode,
+                                     const int extendedErrcode)
+        : SqlError(msg, Q, errcode, extendedErrcode)
+    {
+    }
 };

 class InvalidCursorName : public SqlError
@ -404,6 +493,14 @@ class InvalidCursorName : public SqlError
        : SqlError(err, Q, sqlstate)
    {
    }
+
+    explicit InvalidCursorName(const std::string &msg,
+                               const std::string &Q,
+                               const int errcode,
+                               const int extendedErrcode)
+        : SqlError(msg, Q, errcode, extendedErrcode)
+    {
+    }
 };

 class SyntaxError : public SqlError
@ -419,6 +516,15 @@ class SyntaxError : public SqlError
        : SqlError(err, Q, sqlstate), errorPosition_(pos)
    {
    }
+
+    explicit SyntaxError(const std::string &msg,
+                         const std::string &Q,
+                         const int errcode,
+                         const int extendedErrcode,
+                         int pos = -1)
+        : SqlError(msg, Q, errcode, extendedErrcode), errorPosition_(pos)
+    {
+    }
 };

 class UndefinedColumn : public SyntaxError
@ -430,6 +536,14 @@ class UndefinedColumn : public SyntaxError
        : SyntaxError(err, Q, sqlstate)
    {
    }
+
+    explicit UndefinedColumn(const std::string &msg,
+                             const std::string &Q,
+                             const int errcode,
+                             const int extendedErrcode)
+        : SyntaxError(msg, Q, errcode, extendedErrcode)
+    {
+    }
 };

 class UndefinedFunction : public SyntaxError
@ -441,6 +555,14 @@ class UndefinedFunction : public SyntaxError
        : SyntaxError(err, Q, sqlstate)
    {
    }
+
+    explicit UndefinedFunction(const std::string &msg,
+                               const std::string &Q,
+                               const int errcode,
+                               const int extendedErrcode)
+        : SyntaxError(msg, Q, errcode, extendedErrcode)
+    {
+    }
 };

 class UndefinedTable : public SyntaxError
@ -452,6 +574,14 @@ class UndefinedTable : public SyntaxError
        : SyntaxError(err, Q, sqlstate)
    {
    }
+
+    explicit UndefinedTable(const std::string &msg,
+                            const std::string &Q,
+                            const int errcode,
+                            const int extendedErrcode)
+        : SyntaxError(msg, Q, errcode, extendedErrcode)
+    {
+    }
 };

 class InsufficientPrivilege : public SqlError
@ -463,6 +593,14 @@ class InsufficientPrivilege : public SqlError
        : SqlError(err, Q, sqlstate)
    {
    }
+
+    explicit InsufficientPrivilege(const std::string &msg,
+                                   const std::string &Q,
+                                   const int errcode,
+                                   const int extendedErrcode)
+        : SqlError(msg, Q, errcode, extendedErrcode)
+    {
+    }
 };

 /// Resource shortage on the server
@ -475,6 +613,14 @@ class InsufficientResources : public SqlError
        : SqlError(err, Q, sqlstate)
    {
    }
+
+    explicit InsufficientResources(const std::string &msg,
+                                   const std::string &Q,
+                                   const int errcode,
+                                   const int extendedErrcode)
+        : SqlError(msg, Q, errcode, extendedErrcode)
+    {
+    }
 };

 class DiskFull : public InsufficientResources
@ -486,6 +632,14 @@ class DiskFull : public InsufficientResources
        : InsufficientResources(err, Q, sqlstate)
    {
    }
+
+    explicit DiskFull(const std::string &msg,
+                      const std::string &Q,
+                      const int errcode,
+                      const int extendedErrcode)
+        : InsufficientResources(msg, Q, errcode, extendedErrcode)
+    {
+    }
 };

 class OutOfMemory : public InsufficientResources
@ -497,6 +651,14 @@ class OutOfMemory : public InsufficientResources
        : InsufficientResources(err, Q, sqlstate)
    {
    }
+
+    explicit OutOfMemory(const std::string &msg,
+                         const std::string &Q,
+                         const int errcode,
+                         const int extendedErrcode)
+        : InsufficientResources(msg, Q, errcode, extendedErrcode)
+    {
+    }
 };

 class TooManyConnections : public BrokenConnection
--- a/orm_lib/inc/drogon/orm/Field.h
+++ b/orm_lib/inc/drogon/orm/Field.h
@ -245,7 +245,7 @@ inline unsigned int Field::as<unsigned int>() const
    if (isNull())
        return 0;
    return static_cast<unsigned int>(
-        std::stoi(result_.getValue(row_, column_)));
+        std::stoul(result_.getValue(row_, column_)));
 }

 template <>
--- a/orm_lib/inc/drogon/orm/Mapper.h
+++ b/orm_lib/inc/drogon/orm/Mapper.h
@ -1053,9 +1053,9 @@ inline void Mapper<T>::findBy(const Criteria &criteria,
        std::vector<T> ret;
        for (auto const &row : r)
        {
-            ret.push_back(T(row));
+            ret.emplace_back(row);
        }
-        rcb(ret);
+        rcb(std::move(ret));
    };
    binder >> ecb;
 }
--- a/orm_lib/inc/drogon/orm/SqlBinder.h
+++ b/orm_lib/inc/drogon/orm/SqlBinder.h
@ -116,6 +116,14 @@ enum class Mode
    Blocking
 };

+struct RawParameter
+{
+    std::shared_ptr<void> obj;
+    const char *parameter;
+    int length;
+    int format;
+};
+
 namespace internal
 {
 template <typename T>
@ -434,6 +442,15 @@ class DROGON_EXPORT SqlBinder : public trantor::NonCopyable
        return *this;
    }

+    self &operator<<(const RawParameter &);
+
+    self &operator<<(RawParameter &param)
+    {
+        return operator<<((const RawParameter &)param);
+    }
+
+    self &operator<<(RawParameter &&);
+
    // template <>
    self &operator<<(const char str[])
    {
--- a/orm_lib/src/DbClientImpl.cc
+++ b/orm_lib/src/DbClientImpl.cc
@ -429,6 +429,8 @@ DbConnectionPtr DbClientImpl::newConnection(trantor::EventLoop *loop)
        }
        // Reconnect after 1 second
        auto loop = closeConnPtr->loop();
+        // closeConnPtr may be not valid. Close the connection file descriptor.
+        closeConnPtr->disconnect();
        loop->runAfter(1, [weakPtr, loop, closeConnPtr] {
            auto thisPtr = weakPtr.lock();
            if (!thisPtr)
--- a/orm_lib/src/Exception.cc
+++ b/orm_lib/src/Exception.cc
@ -42,7 +42,23 @@ BrokenConnection::BrokenConnection(const std::string &whatarg)
 SqlError::SqlError(const std::string &whatarg,
                   const std::string &Q,
                   const char sqlstate[])
-    : Failure(whatarg), query_(Q), sqlState_(sqlstate ? sqlstate : "")
+    : Failure(whatarg),
+      query_(Q),
+      sqlState_(sqlstate ? sqlstate : ""),
+      errcode_(0),
+      extendedErrcode_(0)
+{
+}
+
+SqlError::SqlError(const std::string &whatarg,
+                   const std::string &Q,
+                   const int errcode,
+                   const int extendedErrcode)
+    : Failure(whatarg),
+      query_(Q),
+      sqlState_(""),
+      errcode_(errcode),
+      extendedErrcode_(extendedErrcode)
 {
 }

@ -60,6 +76,16 @@ const std::string &SqlError::sqlState() const noexcept
    return sqlState_;
 }

+int SqlError::errcode() const noexcept
+{
+    return errcode_;
+}
+
+int SqlError::extendedErrcode() const noexcept
+{
+    return extendedErrcode_;
+}
+
 InDoubtError::InDoubtError(const std::string &whatarg) : Failure(whatarg)
 {
 }
--- a/orm_lib/src/SqlBinder.cc
+++ b/orm_lib/src/SqlBinder.cc
@ -18,6 +18,9 @@
 #include <drogon/utils/Utilities.h>
 #include <future>
 #include <regex>
+#if defined(__cpp_lib_format)
+#include <format>
+#endif
 #if USE_MYSQL
 #include <mysql.h>
 #endif
@ -134,6 +137,26 @@ SqlBinder::~SqlBinder()
    }
 }

+SqlBinder &SqlBinder::operator<<(const RawParameter &param)
+{
+    objs_.push_back(param.obj);
+    parameters_.push_back(param.parameter);
+    lengths_.push_back(param.length);
+    formats_.push_back(param.format);
+    ++parametersNumber_;
+    return *this;
+}
+
+SqlBinder &SqlBinder::operator<<(RawParameter &&param)
+{
+    objs_.push_back(std::move(param.obj));
+    parameters_.push_back(std::move(param.parameter));
+    lengths_.push_back(std::move(param.length));
+    formats_.push_back(std::move(param.format));
+    ++parametersNumber_;
+    return *this;
+}
+
 SqlBinder &SqlBinder::operator<<(const std::string_view &str)
 {
    auto obj = std::make_shared<std::string>(str.data(), str.length());
@ -259,7 +282,14 @@ SqlBinder &SqlBinder::operator<<(double f)
        parameters_.push_back((char *)(obj.get()));
        return *this;
    }
-    return operator<<(std::to_string(f));
+
+#if defined(__cpp_lib_format)
+    return operator<<(std::format("{:.17g}", f));
+#else
+    std::stringstream ss;
+    ss << std::setprecision(17) << f;
+    return operator<<(ss.str());
+#endif
 }

 SqlBinder &SqlBinder::operator<<(std::nullptr_t)
--- a/orm_lib/src/postgresql_impl/PgBatchConnection.cc
+++ b/orm_lib/src/postgresql_impl/PgBatchConnection.cc
@ -87,11 +87,14 @@ PgConnection::PgConnection(trantor::EventLoop *loop,
                                  [](PGconn *conn) { PQfinish(conn); })),
      channel_(loop, PQsocket(connectionPtr_.get()))
 {
+    if (channel_.fd() < 0)
+    {
+        LOG_ERROR << "Failed to create Postgres connection";
+    }
 }

 void PgConnection::init()
 {
-    PQsetnonblocking(connectionPtr_.get(), 1);
    if (channel_.fd() < 0)
    {
        LOG_ERROR << "Connection with Postgres could not be established";
@ -103,6 +106,8 @@ void PgConnection::init()
        }
        return;
    }
+
+    PQsetnonblocking(connectionPtr_.get(), 1);
    channel_.setReadCallback([this]() {
        if (status_ == ConnectStatus::Bad)
        {
@ -165,8 +170,11 @@ void PgConnection::disconnect()
    auto thisPtr = shared_from_this();
    loop_->runInLoop([thisPtr, &pro]() {
        thisPtr->status_ = ConnectStatus::Bad;
+        if (thisPtr->channel_.fd() >= 0)
+        {
            thisPtr->channel_.disableAll();
            thisPtr->channel_.remove();
+        }
        thisPtr->connectionPtr_.reset();
        pro.set_value(1);
    });
@ -521,13 +529,19 @@ void PgConnection::handleFatalError(bool clearAll, bool isAbortPipeline)
    if (clearAll)
    {
        for (auto &cmd : batchCommandsForWaitingResults_)
+        {
+            if (cmd->exceptionCallback_)
            {
                cmd->exceptionCallback_(exceptPtr);
            }
+        }
        for (auto &cmd : batchSqlCommands_)
+        {
+            if (cmd->exceptionCallback_)
            {
                cmd->exceptionCallback_(exceptPtr);
            }
+        }
        batchCommandsForWaitingResults_.clear();
        batchSqlCommands_.clear();
    }
@ -535,14 +549,20 @@ void PgConnection::handleFatalError(bool clearAll, bool isAbortPipeline)
    {
        if (!batchSqlCommands_.empty() &&
            !batchSqlCommands_.front()->preparingStatement_.empty())
+        {
+            if (batchSqlCommands_.front()->exceptionCallback_)
            {
                batchSqlCommands_.front()->exceptionCallback_(exceptPtr);
+            }
            batchSqlCommands_.pop_front();
        }
        else if (!batchCommandsForWaitingResults_.empty())
        {
            auto &cmd = batchCommandsForWaitingResults_.front();
+            if (cmd->exceptionCallback_)
+            {
                cmd->exceptionCallback_(exceptPtr);
+            }
            batchCommandsForWaitingResults_.pop_front();
        }
        else
--- a/orm_lib/src/postgresql_impl/PgConnection.cc
+++ b/orm_lib/src/postgresql_impl/PgConnection.cc
@ -65,11 +65,14 @@ PgConnection::PgConnection(trantor::EventLoop *loop,
                                  [](PGconn *conn) { PQfinish(conn); })),
      channel_(loop, PQsocket(connectionPtr_.get()))
 {
+    if (channel_.fd() < 0)
+    {
+        LOG_ERROR << "Failed to create Postgres connection";
+    }
 }

 void PgConnection::init()
 {
-    PQsetnonblocking(connectionPtr_.get(), 1);
    if (channel_.fd() < 0)
    {
        LOG_ERROR << "Connection with Postgres could not be established";
@ -80,6 +83,8 @@ void PgConnection::init()
        }
        return;
    }
+
+    PQsetnonblocking(connectionPtr_.get(), 1);
    channel_.setReadCallback([this]() {
        if (status_ == ConnectStatus::Bad)
        {
@ -128,6 +133,15 @@ void PgConnection::handleClosed()
    if (status_ == ConnectStatus::Bad)
        return;
    status_ = ConnectStatus::Bad;
+
+    if (isWorking_)
+    {
+        // Connection was closed unexpectedly while isWorking_ was true.
+        isWorking_ = false;
+        handleFatalError();
+        callback_ = nullptr;
+    }
+
    channel_.disableAll();
    channel_.remove();
    assert(closeCallback_);
@ -142,8 +156,11 @@ void PgConnection::disconnect()
    auto thisPtr = shared_from_this();
    loop_->runInLoop([thisPtr, &pro]() {
        thisPtr->status_ = ConnectStatus::Bad;
+        if (thisPtr->channel_.fd() >= 0)
+        {
            thisPtr->channel_.disableAll();
            thisPtr->channel_.remove();
+        }
        thisPtr->connectionPtr_.reset();
        pro.set_value(1);
    });
@ -398,9 +415,13 @@ void PgConnection::doAfterPreparing()

 void PgConnection::handleFatalError()
 {
-    auto exceptPtr =
-        std::make_exception_ptr(Failure(PQerrorMessage(connectionPtr_.get())));
+    if (exceptionCallback_)
+    {
+        auto exceptPtr = std::make_exception_ptr(
+            Failure(PQerrorMessage(connectionPtr_.get())));
        exceptionCallback_(exceptPtr);
+    }
+
    exceptionCallback_ = nullptr;
 }

--- a/orm_lib/src/sqlite3_impl/Sqlite3Connection.cc
+++ b/orm_lib/src/sqlite3_impl/Sqlite3Connection.cc
@ -14,7 +14,10 @@

 #include "Sqlite3Connection.h"
 #include "Sqlite3ResultImpl.h"
+#include <drogon/orm/Exception.h>
 #include <drogon/utils/Utilities.h>
+#include <stdexcept>
+#include <string>
 #include <string_view>
 #include <cctype>
 #include <exception>
@ -24,14 +27,54 @@
 using namespace drogon;
 using namespace drogon::orm;

+namespace
+{
+
+}
+
 std::once_flag Sqlite3Connection::once_;

 void Sqlite3Connection::onError(
    const std::string_view &sql,
-    const std::function<void(const std::exception_ptr &)> &exceptCallback)
+    const std::function<void(const std::exception_ptr &)> &exceptCallback,
+    const int &extendedErrcode)
 {
-    auto exceptPtr = std::make_exception_ptr(
-        SqlError(sqlite3_errmsg(connectionPtr_.get()), std::string{sql}));
+    int errcode = extendedErrcode & 0xFF;  // low 8 bit
+#define ORM_ERR_CASE(code, type)                                    \
+    case code:                                                      \
+    {                                                               \
+        auto exceptPtr = std::make_exception_ptr(                   \
+            drogon::orm::type(sqlite3_errmsg(connectionPtr_.get()), \
+                              std::string{sql},                     \
+                              errcode,                              \
+                              extendedErrcode));                    \
+        exceptCallback(exceptPtr);                                  \
+        return;                                                     \
+    };
+    switch (extendedErrcode)
+    {
+        ORM_ERR_CASE(SQLITE_CONSTRAINT_NOTNULL, NotNullViolation)
+        ORM_ERR_CASE(SQLITE_CONSTRAINT_FOREIGNKEY, ForeignKeyViolation)
+        ORM_ERR_CASE(SQLITE_CONSTRAINT_PRIMARYKEY, UniqueViolation)
+        ORM_ERR_CASE(SQLITE_CONSTRAINT_UNIQUE, UniqueViolation)
+        ORM_ERR_CASE(SQLITE_CONSTRAINT_CHECK, CheckViolation)
+    }
+    switch (errcode)
+    {
+        ORM_ERR_CASE(SQLITE_MISMATCH, DataException)
+        ORM_ERR_CASE(SQLITE_CONSTRAINT, IntegrityConstraintViolation)
+        ORM_ERR_CASE(SQLITE_PERM, InsufficientPrivilege)
+        ORM_ERR_CASE(SQLITE_AUTH, InsufficientPrivilege)
+        ORM_ERR_CASE(SQLITE_NOMEM, OutOfMemory)
+        ORM_ERR_CASE(SQLITE_FULL, DiskFull)
+    }
+#undef ORM_ERR_CASE
+
+    auto exceptPtr =
+        std::make_exception_ptr(SqlError(sqlite3_errmsg(connectionPtr_.get()),
+                                         std::string{sql},
+                                         errcode,
+                                         extendedErrcode));
    exceptCallback(exceptPtr);
 }

@ -148,7 +191,8 @@ void Sqlite3Connection::execSqlInQueue(
                       : nullptr;
        if (ret != SQLITE_OK || !stmtPtr)
        {
-            onError(sql, exceptCallback);
+            int ext_ret = sqlite3_extended_errcode(connectionPtr_.get());
+            onError(sql, exceptCallback, ext_ret);
            idleCb_();
            return;
        }
@ -207,13 +251,14 @@ void Sqlite3Connection::execSqlInQueue(
        }
        if (bindRet != SQLITE_OK)
        {
-            onError(sql, exceptCallback);
+            int eret = sqlite3_extended_errcode(connectionPtr_.get());
+            onError(sql, exceptCallback, eret);
            sqlite3_reset(stmt);
            idleCb_();
            return;
        }
    }
-    int r;
+    int r, er;
    int columnNum = sqlite3_column_count(stmt);
    auto resultPtr = std::make_shared<Sqlite3ResultImpl>();
    for (int i = 0; i < columnNum; ++i)
@ -233,6 +278,10 @@ void Sqlite3Connection::execSqlInQueue(
        // Readonly, hold read lock;
        std::shared_lock<SharedMutex> lock(*sharedMutexPtr_);
        r = stmtStep(stmt, resultPtr, columnNum);
+        if (r != SQLITE_DONE)
+        {
+            er = sqlite3_extended_errcode(connectionPtr_.get());
+        }
        sqlite3_reset(stmt);
    }
    else
@ -246,12 +295,16 @@ void Sqlite3Connection::execSqlInQueue(
            resultPtr->insertId_ =
                sqlite3_last_insert_rowid(connectionPtr_.get());
        }
+        else
+        {
+            er = sqlite3_extended_errcode(connectionPtr_.get());
+        }
        sqlite3_reset(stmt);
    }

    if (r != SQLITE_DONE)
    {
-        onError(sql, exceptCallback);
+        onError(sql, exceptCallback, er);
        sqlite3_reset(stmt);
        idleCb_();
        return;
--- a/orm_lib/src/sqlite3_impl/Sqlite3Connection.h
+++ b/orm_lib/src/sqlite3_impl/Sqlite3Connection.h
@ -75,7 +75,8 @@ class Sqlite3Connection : public DbConnection,
        const std::function<void(const std::exception_ptr &)> &exceptCallback);
    void onError(
        const std::string_view &sql,
-        const std::function<void(const std::exception_ptr &)> &exceptCallback);
+        const std::function<void(const std::exception_ptr &)> &exceptCallback,
+        const int &extendedErrcode);
    int stmtStep(sqlite3_stmt *stmt,
                 const std::shared_ptr<Sqlite3ResultImpl> &resultPtr,
                 int columnNum);
--- a/orm_lib/tests/db_test.cc
+++ b/orm_lib/tests/db_test.cc
@ -287,11 +287,24 @@ DROGON_TEST(PostgreTest)
            FAULT("postgresql - DbClient streaming-type interface(8) what():",
                  e.base().what());
        };
-    /// 1.10 clean up
+    /// 1.10 query with raw parameter
+    auto rawParamData = std::make_shared<int>(htonl(3));
+    auto rawParam = RawParameter{rawParamData,
+                                 reinterpret_cast<char *>(rawParamData.get()),
+                                 sizeof(int),
+                                 1};
+    *clientPtr << "select * from users where length(user_id)=$1" << rawParam >>
+        [TEST_CTX](const Result &r) { MANDATE(r.size() == 1); } >>
+        [TEST_CTX](const DrogonDbException &e) {
+            FAULT("postgresql - DbClient streaming-type interface(9) what():",
+                  e.base().what());
+        };
+
+    /// 1.11 clean up
    *clientPtr << "truncate table users restart identity" >>
        [TEST_CTX](const Result &r) { SUCCESS(); } >>
        [TEST_CTX](const DrogonDbException &e) {
-            FAULT("postgresql - DbClient streaming-type interface(9) what():",
+            FAULT("postgresql - DbClient streaming-type interface(10) what():",
                  e.base().what());
        };
    /// Test asynchronous method
@ -379,12 +392,21 @@ DROGON_TEST(PostgreTest)
        "postgresql1",
        "pg",
        "postgresql");
-    /// 2.6 clean up
+    /// 2.6 query with raw parameter
+    clientPtr->execSqlAsync(
+        "select * from users where length(user_id)=$1",
+        [TEST_CTX](const Result &r) { MANDATE(r.size() == 1); },
+        [TEST_CTX](const DrogonDbException &e) {
+            FAULT("postgresql - DbClient asynchronous interface(7) what():",
+                  e.base().what());
+        },
+        rawParam);
+    /// 2.7 clean up
    clientPtr->execSqlAsync(
        "truncate table users restart identity",
        [TEST_CTX](const Result &r) { SUCCESS(); },
        [TEST_CTX](const DrogonDbException &e) {
-            FAULT("postgresql - DbClient asynchronous interface(7) what():",
+            FAULT("postgresql - DbClient asynchronous interface(8) what():",
                  e.base().what());
        });

@ -464,7 +486,19 @@ DROGON_TEST(PostgreTest)
    {
        SUCCESS();
    }
-    /// 3.6 clean up
+    /// 3.6 query with raw parameter
+    try
+    {
+        auto r = clientPtr->execSqlSync(
+            "select * from users where length(user_id)=$1", rawParam);
+        MANDATE(r.size() == 1);
+    }
+    catch (const DrogonDbException &e)
+    {
+        FAULT("postgresql - DbClient asynchronous interface(4) what():",
+              e.base().what());
+    }
+    /// 3.7 clean up
    try
    {
        auto r =
@ -557,7 +591,20 @@ DROGON_TEST(PostgreTest)
    {
        SUCCESS();
    }
-    /// 4.6 clean up
+    /// 4.6 query with raw parameter
+    f = clientPtr->execSqlAsyncFuture(
+        "select * from users where length(user_id)=$1", rawParam);
+    try
+    {
+        auto r = f.get();
+        MANDATE(r.size() == 1);
+    }
+    catch (const DrogonDbException &e)
+    {
+        FAULT("postgresql - DbClient future interface(4) what():",
+              e.base().what());
+    }
+    /// 4.7 clean up
    f = clientPtr->execSqlAsyncFuture("truncate table users restart identity");
    try
    {
@ -1670,11 +1717,28 @@ DROGON_TEST(MySQLTest)
            FAULT("mysql - DbClient streaming-type interface(8) what():",
                  e.base().what());
        };
-    /// 1.10 truncate
+    /// 1.10 query with raw parameter
+    // MariaDB uses little-endian, so the opposite of network ordering :P
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+    auto rawParamData = std::make_shared<int>(3);
+#else
+    auto rawParamData = std::make_shared<int>(0x03000000);  // byteswapped 3
+#endif
+    auto rawParam = RawParameter{rawParamData,
+                                 reinterpret_cast<char *>(rawParamData.get()),
+                                 sizeof(int),
+                                 internal::MySqlLong};
+    *clientPtr << "select * from users where length(user_id)=?" << rawParam >>
+        [TEST_CTX](const Result &r) { MANDATE(r.size() == 1); } >>
+        [TEST_CTX](const DrogonDbException &e) {
+            FAULT("mysql - DbClient streaming-type interface(9) what():",
+                  e.base().what());
+        };
+    /// 1.11 truncate
    *clientPtr << "truncate table users" >> [TEST_CTX](const Result &r) {
        SUCCESS();
    } >> [TEST_CTX](const DrogonDbException &e) {
-        FAULT("mysql - DbClient streaming-type interface(9) what():",
+        FAULT("mysql - DbClient streaming-type interface(10) what():",
              e.base().what());
    };
    /// Test asynchronous method
@ -1759,12 +1823,21 @@ DROGON_TEST(MySQLTest)
        "postgresql1",
        "pg",
        "postgresql");
-    /// 2.6 truncate
+    /// 2.6 query with raw parameter
+    clientPtr->execSqlAsync(
+        "select * from users where length(user_id)=?",
+        [TEST_CTX](const Result &r) { MANDATE(r.size() == 1); },
+        [TEST_CTX](const DrogonDbException &e) {
+            FAULT("mysql - DbClient asynchronous interface(7) what():",
+                  e.base().what());
+        },
+        rawParam);
+    /// 2.7 truncate
    clientPtr->execSqlAsync(
        "truncate table users",
        [TEST_CTX](const Result &r) { SUCCESS(); },
        [TEST_CTX](const DrogonDbException &e) {
-            FAULT("mysql - DbClient asynchronous interface(7) what():",
+            FAULT("mysql - DbClient asynchronous interface(9) what():",
                  e.base().what());
        });

@ -1845,7 +1918,19 @@ DROGON_TEST(MySQLTest)
    {
        SUCCESS();
    }
-    /// 3.6 truncate
+    /// 3.6 query with raw parameter
+    try
+    {
+        auto r = clientPtr->execSqlSync(
+            "select * from users where length(user_id)=?", rawParam);
+        MANDATE(r.size() == 1);
+    }
+    catch (const DrogonDbException &e)
+    {
+        FAULT("mysql - DbClient asynchronous interface(4) what():",
+              e.base().what());
+    }
+    /// 3.7 truncate
    try
    {
        auto r = clientPtr->execSqlSync("truncate table users");
@ -1932,7 +2017,19 @@ DROGON_TEST(MySQLTest)
    {
        SUCCESS();
    }
-    /// 4.6 truncate
+    /// 4.6. query with raw parameter
+    f = clientPtr->execSqlAsyncFuture(
+        "select * from users where length(user_id)=?", rawParam);
+    try
+    {
+        auto r = f.get();
+        MANDATE(r.size() == 1);
+    }
+    catch (const DrogonDbException &e)
+    {
+        FAULT("mysql - DbClient future interface(5) what():", e.base().what());
+    }
+    /// 4.7 truncate
    f = clientPtr->execSqlAsyncFuture("truncate table users");
    try
    {
@ -1941,7 +2038,7 @@ DROGON_TEST(MySQLTest)
    }
    catch (const DrogonDbException &e)
    {
-        FAULT("mysql - DbClient future interface(5) what():", e.base().what());
+        FAULT("mysql - DbClient future interface(6) what():", e.base().what());
    }

    /// 5 Test Result and Row exception throwing
@ -2881,17 +2978,29 @@ DROGON_TEST(SQLite3Test)
            FAULT("sqlite3 - DbClient streaming-type interface(8) what():",
                  e.base().what());
        };
-    /// 1.10 clean up
+    /// 1.10 query with raw parameter
+    auto rawParamData = std::make_shared<int>(3);
+    auto rawParam = RawParameter{rawParamData,
+                                 reinterpret_cast<char *>(rawParamData.get()),
+                                 0,
+                                 Sqlite3TypeInt};
+    *clientPtr << "select * from users where length(user_id) = ?" << rawParam >>
+        [TEST_CTX](const Result &r) { MANDATE(r.size() == 1); } >>
+        [TEST_CTX](const DrogonDbException &e) {
+            FAULT("sqlite3 - DbClient streaming-type interface(9) what():",
+                  e.base().what());
+        };
+    /// 1.11 clean up
    *clientPtr << "delete from users" >> [TEST_CTX](const Result &r) {
        SUCCESS();
    } >> [TEST_CTX](const DrogonDbException &e) {
-        FAULT("sqlite3 - DbClient streaming-type interface(9.1) what():",
+        FAULT("sqlite3 - DbClient streaming-type interface(10.1) what():",
              e.base().what());
    };
    *clientPtr << "UPDATE sqlite_sequence SET seq = 0" >>
        [TEST_CTX](const Result &r) { SUCCESS(); } >>
        [TEST_CTX](const DrogonDbException &e) {
-            FAULT("sqlite3 - DbClient streaming-type interface(9.2) what():",
+            FAULT("sqlite3 - DbClient streaming-type interface(10.2) what():",
                  e.base().what());
        };
    /// Test asynchronous method
@ -2975,19 +3084,28 @@ DROGON_TEST(SQLite3Test)
        "postgresql1",
        "pg",
        "postgresql");
-    /// 2.6 clean up
+    /// 2.6 query with raw parameter
+    clientPtr->execSqlAsync(
+        "select * from users where length(user_id) = ?",
+        [TEST_CTX](const Result &r) { MANDATE(r.size() == 1); },
+        [TEST_CTX](const DrogonDbException &e) {
+            FAULT("sqlite3 - DbClient asynchronous interface(7) what():",
+                  e.base().what());
+        },
+        rawParam);
+    /// 2.7 clean up
    clientPtr->execSqlAsync(
        "delete from users",
        [TEST_CTX](const Result &r) { SUCCESS(); },
        [TEST_CTX](const DrogonDbException &e) {
-            FAULT("sqlite3 - DbClient asynchronous interface(7.1) what():",
+            FAULT("sqlite3 - DbClient asynchronous interface(8.1) what():",
                  e.base().what());
        });
    clientPtr->execSqlAsync(
        "UPDATE sqlite_sequence SET seq = 0",
        [TEST_CTX](const Result &r) { SUCCESS(); },
        [TEST_CTX](const DrogonDbException &e) {
-            FAULT("sqlite3 - DbClient asynchronous interface(7.2) what():",
+            FAULT("sqlite3 - DbClient asynchronous interface(8.2) what():",
                  e.base().what());
        });

@ -3074,7 +3192,19 @@ DROGON_TEST(SQLite3Test)
    {
        SUCCESS();
    }
-    /// 3.6 clean up
+    /// 3.6 query with raw parameter
+    try
+    {
+        auto r = clientPtr->execSqlSync(
+            "select * from users where length(user_id) = ?", rawParam);
+        MANDATE(r.size() == 1);
+    }
+    catch (const DrogonDbException &e)
+    {
+        FAULT("sqlite3 - DbClient asynchronous interface(4) what():",
+              e.base().what());
+    }
+    /// 3.7 clean up
    try
    {
        auto r = clientPtr->execSqlSync("delete from users");
@ -3177,6 +3307,19 @@ DROGON_TEST(SQLite3Test)
    {
        SUCCESS();
    }
+    /// 4.6 query with raw parameter
+    f = clientPtr->execSqlAsyncFuture(
+        "select * from users where length(user_id)=?", rawParam);
+    try
+    {
+        auto r = f.get();
+        MANDATE(r.size() == 1);
+    }
+    catch (const DrogonDbException &e)
+    {
+        FAULT("sqlite3 - DbClient future interface(4) what():",
+              e.base().what());
+    }
    /// 4.6 clean up
    f = clientPtr->execSqlAsyncFuture("delete from users");
    try
--- a/2
+++ b/2
@ -1 +1 @@
-Subproject commit 79e1ffc59aa1b9c8226c2988fe2e1185e97cd795
+Subproject commit 43fd79b2dbac59608a819ebba167e8fe2c079d90
Author	SHA1	Message	Date
an-tao	a22956b82b	Bump version to 1.9.11	2025-06-20 16:51:27 +08:00
Heran Yang	3c5749bbc2	Fix compile warning (#2337 )	2025-06-18 17:43:25 +08:00
Heran Yang	7cd1ae8940	chore(workflow): upgrade Windows image and re-enable tests on Windows (#2336 ) * chore(workflow): upgrade Windows image to 2022 * chore(test): re-enable tests on Windows	2025-06-18 15:47:28 +08:00
LordMZTE	c3f9192541	Add RawParameter API to pass raw SQL parameters to the database directly (#2335 )	2025-06-17 23:15:47 +08:00
KEBE Mouhamad	e46e05e94a	dg_ctl: fix segfault when using --output option (#2330 )	2025-06-05 13:52:33 +08:00
dm	26e7c6913c	Add support for continuation frame in WebSocketMessageParser (#2320 ) Co-authored-by: antao <antao2002@gmail.com>	2025-06-04 10:02:07 +08:00
曹梦轩	8d640bafb4	Add cors example to demonstrate cross-origin support in drogon (#2323 )	2025-05-26 10:10:39 +08:00
Leonardo Monteiro	f6b5404dbb	Add a new overload for execSqlCoro (#2314 )	2025-05-22 18:16:11 +08:00
程憨憨	46b5c9044d	Fix issue with precision loss of double-type parameters in ORM inputs (#2310 )	2025-05-19 19:07:37 +08:00
an-tao	ac0d4d0f89	Update trantor	2025-05-16 11:10:24 +08:00
cjserio	5c4057331e	Support for iOS compiling (#2307 )	2025-05-15 17:25:56 +08:00
an-tao	95a518e7f2	Add qrcode for WeChat official account to the README file	2025-05-13 11:15:48 +08:00
KEBE Mouhamad	c03a3df106	added -o\|--output option to drogon_ctl create models (#2304 ) Co-authored-by: Mouhamad Kebe <mouhamad.kebe@ses.com>	2025-05-10 21:20:52 +08:00
Alexey Gerasimchuck	d6a33f93c9	Added handleFatalError in handleClosed (#2291 )	2025-04-21 11:15:00 +08:00
An Tao	59cd4366c7	Fix CI on MacOS (#2289 )	2025-04-08 14:11:03 +08:00
Alexey Gerasimchuck	c92d146374	Improved Postgres connection stability (#2286 )	2025-04-08 11:03:02 +08:00
Axel Svensson	3c7c66e310	fix: Do not write to source directory during build (#2288 ) Fixes #2287	2025-04-08 10:23:43 +08:00
Tanglong3bf	1fb67d68be	fix: Fix a bug in isAutoCreationClass<T>. (#2277 )	2025-03-22 15:46:41 +08:00
antao	cbf63f8fc4	Bump version to 1.9.10	2025-02-20 21:19:18 +08:00
an-tao	d68e8aa554	Fix the CI status badge	2025-02-20 14:16:30 +08:00
An Tao	41537a6e86	Fix ci: codespell (#2259 )	2025-02-18 22:29:47 +08:00
TheEnigmist	a32dc67867	Added path_exempt in AccessLogger plugin config to exclude desired path from logging (#2258 )	2025-02-18 10:28:57 +08:00
ereynalabs	e155df9f66	Fix the issue in view generation by including the missing header file drogon/utils/Utilities.h (#2248 ) Co-authored-by: dlinten <david.linten@gmail.com>	2025-02-06 15:19:44 +08:00
Alexey Gerasimchuck	f5de41f5d7	Make quit function thread safe (#2247 )	2025-02-02 22:22:17 +08:00
pan93412	a3b4779540	Improve the zh-TW README translation (#2239 ) * Improve the zh-TW README translation * Unify the "View" term in the zh-TW README	2025-01-14 20:08:30 +08:00
fantasy-peak	686f68a12f	Add setConnectionCallback (#2204 )	2025-01-08 20:00:44 +08:00
An Tao	152a69f1e9	ORM:Avoid unnecessary copies when returning search results (#2237 )	2025-01-02 22:44:09 +08:00
antao	38dd5fea31	Bump version to 1.9.9	2025-01-01 11:26:30 +08:00
Alexey Gerasimchuck	3a6268f7e9	Added emptiness check to the LogStream &operator<< with std::string_view (#2234 )	2024-12-19 10:36:20 +08:00
antao	47f8af7ca1	Update README	2024-12-14 01:17:49 +08:00
Heran Yang	44f796b796	Chore(workflow/cmake.yml): upgrade macos runner (#2228 )	2024-12-10 12:56:24 +08:00
Antonio Nesic	df7e83ae74	Added Partitioned flag for cookies (#2230 ) Co-authored-by: Antonio Nesic <anesic@collectivemind.dev>	2024-12-10 12:55:16 +08:00
EasyMoney322	99e816283d	Fix: Removed dependency on locales being installed (#2227 )	2024-12-09 10:53:15 +08:00
EasyMoney322	3e944d28d8	Fixed issues created by the date string being localized (#2217 )	2024-12-05 18:08:24 +08:00
Eyal Niv	1765223755	Fix CMAKE issues mentioned in #2144 and a linking problem which manifest with gcc12.3 when building with shared libs (#2208 ) (#2213 ) * Respect find_package QUIET * Add policy_max to cmake_minimum_required Avoid deprecation warning introduced by cmake 3.31 * Add missing DROGON_EXPORT	2024-11-26 22:53:09 +08:00
hanhuayin	71b6d57cae	Update FindFilesystem.cmake to check for GNU instead of GCC for CMAKE_CXX_COMPILER_ID (#2211 ) This patch fixes a build issue encountered in our Amazon Linux 2 environment when integrating Drogon alongside other dependencies. The issue occurred because the filesystem check failed to compile when the compiler ID was set to "GNU", due to missing -std=c++17 flag. The existing CXX_FILESYSTEM_HAVE_FS check was looking for "GCC" instead of "GNU". "GNU" is the correct identifier for gcc according to CMake documentation (see https://cmake.org/cmake/help/latest/variable/CMAKE_LANG_COMPILER_ID.html). Interestingly, this issue only manifested when Drogon was integrated alongside other dependencies. When Drogon was the sole project added to our build, compilation proceeded without error.	2024-11-25 16:15:21 +08:00
Tanglong3bf	882c1d9ecd	fix a bug in plugin Redirector. (#2198 )	2024-11-16 15:04:57 +08:00
dependabot[bot]	8541e67143	Bump docker/login-action from 1 to 3 (#2197 ) Bumps [docker/login-action](https://github.com/docker/login-action) from 1 to 3. - [Release notes](https://github.com/docker/login-action/releases) - [Commits](https://github.com/docker/login-action/compare/v1...v3) --- updated-dependencies: - dependency-name: docker/login-action dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2024-11-02 09:48:46 +08:00
antao	6d9ecb8d8d	Bump version to 1.9.8	2024-10-27 14:31:56 +08:00
fantasy-peak	23c561f072	Add check the client connection status (#2191 )	2024-10-25 16:08:03 +08:00
Tanglong3bf	284d14b8ca	Fix some bugs in plugin PromExporter. (#2189 )	2024-10-21 09:51:34 +08:00
fantasy-peak	ca2210331d	Add sending customized http requests to drogon_ctl (#2186 )	2024-10-17 10:47:04 +08:00
Martin Chang	3fce70b535	Replace rejection sampling and remove use of rand() (#2180 )	2024-10-10 13:45:46 +08:00
An Tao	bf1fc03bff	Fix lint (#2181 )	2024-10-09 18:20:29 +08:00
an-tao	5225bb3295	Update trantor and add docker actions	2024-10-09 16:45:19 +08:00
An Tao	ac0a1b873e	Fix a bug after removing content-length header in some responses (#2176 )	2024-10-02 16:42:40 +08:00
Muhammad	912f1d803c	Optimize query params and allow for empty values (#2171 )	2024-09-26 15:47:58 +08:00
An Tao	13d7148764	Remove websocketResponseTest from windows shared library env (#2170 )	2024-09-25 20:16:40 +08:00
Chad Barth	b0c5331bc1	Remove content-length header from 101 Switching Protocols response (#2164 )	2024-09-25 17:52:41 +08:00
Christopher T	c9f5754423	Add support for escaped identifiers in Postgresql (#2167 )	2024-09-23 16:00:50 +08:00
an-tao	31fb18fb46	Update trantor	2024-09-20 16:22:09 +08:00
toge	f918ead0ae	include exception header for std::exception_ptr (#2159 )	2024-09-19 10:11:04 +08:00
Muhammad	fee34095a2	Add Hodor whitelists (#2154 )	2024-09-19 09:56:11 +08:00
Omar Mohamed Khallaf	2911a7c08a	Fix coroutine continuation handle (#2163 ) Using coroutines directly by the user e.g. declaring a function with drogon::Task<> return type, will have it's continuation set to nullptr. Returning nullptr causes a segfault and it must be checked before returning e.g. the snippet form https://en.cppreference.com/w/cpp/coroutine/noop_coroutine ```cpp struct final_awaiter { std::coroutine_handle<> await_suspend(std::coroutine_handle<promise_type> h) noexcept { // final_awaiter::await_suspend is called when the execution of the // current coroutine (referred to by 'h') is about to finish. // If the current coroutine was resumed by another coroutine via // co_await get_task(), a handle to that coroutine has been stored // as h.promise().previous. In that case, return the handle to resume // the previous coroutine. // Otherwise, return noop_coroutine(), whose resumption does nothing. if (auto previous = h.promise().previous; previous) return previous; else return std::noop_coroutine(); } }; ``` This commit default initializes the continuation handle to no op coroutine and avoids the check. Signed-off-by: Omar Mohamed <mohamed.omar67492@gmail.com>	2024-09-19 09:52:51 +08:00
Muhammad	1b4653577f	Revert original path to its initial behavior (#2157 )	2024-09-17 11:54:33 +08:00
Muhammad	bbcad71458	Add in-place base64 encode and decode (#2153 )	2024-09-14 09:57:07 +08:00
Muhammad	beec858eba	Partially revert commit 93d8fb425d7e95939d398afd51b9d5adc4392c43 (#2156 )	2024-09-13 17:34:23 +08:00
Muhammad	93d8fb425d	Fix forwarding with space in url by encoding (#2155 )	2024-09-13 09:46:06 +08:00
antao	73406d1225	Bump version to 1.9.7	2024-09-10 23:12:02 +08:00
Ponder	6bafdf30fd	Feature: TcpServer hot reload SSL file (#2150 )	2024-09-10 11:38:56 +08:00
元路	59919f33ef	Refine SQLite3 error types with new exception handling (#2145 ) Signed-off-by: yuanlu <2573580691@qq.com>	2024-09-06 15:37:09 +08:00
an-tao	1326205483	Change a log level	2024-08-23 11:34:50 +08:00
Omar Mohamed Khallaf	80ec7d9211	Use correct libraries when compiling statically (#2136 ) When compiling statically, cmake pulls shared libraries as dependencies for drogon e.g. libpq.so instead of libpq.a. This causes linkage errors when compiling the whole program. The flag USE_STATIC_LIBS_ONLY should set the CMAKE_FIND_LIBRARY_SUFFIXES to the appropriate suffix on different platforms, thus find_* commands find the right library.	2024-08-22 15:46:47 +08:00
fantasy-peak	5b5d1906bf	Add requestsBufferSize function (#2124 )	2024-08-14 11:15:33 +08:00
Muhammad	206ef0d881	Modernize cookies (#2112 )	2024-08-08 22:23:28 +08:00
fantasy-peak	c46f149c2c	Add coroutine mutex (#2095 )	2024-08-08 15:17:06 +08:00
Bohdan Tsehelnyk	0546032edc	change stoi to stoul (#2115 )	2024-08-06 17:16:06 +08:00
Bohdan Tsehelnyk	f743cfd4d1	add quotes (#2116 )	2024-08-06 17:15:01 +08:00
Muhammad	500d44faac	Allow `MultiPartParser` to be movable (#2107 )	2024-07-23 11:52:52 +03:00