fix static local

include/cinatra/coro_http_client.hpp

@@ -986,7 +986,8 @@ class coro_http_client : public std::enable_shared_from_this<coro_http_client> {
         size_t rd_size =
             source->read(file_data.data(), file_data.size()).gcount();
         std::vector<asio::const_buffer> bufs;
-        cinatra::to_chunked_buffers(bufs, {file_data.data(), rd_size},
+        std::string size_str;
+        cinatra::to_chunked_buffers(bufs, size_str, {file_data.data(), rd_size},
                                     source->eof());
         if (std::tie(ec, size) = co_await async_write(bufs); ec) {
           break;
@@ -1005,7 +1006,8 @@ class coro_http_client : public std::enable_shared_from_this<coro_http_client> {
         auto [rd_ec, rd_size] =
             co_await file.async_read(file_data.data(), file_data.size());
         std::vector<asio::const_buffer> bufs;
-        cinatra::to_chunked_buffers(bufs, {file_data.data(), rd_size},
+        std::string size_str;
+        cinatra::to_chunked_buffers(bufs, size_str, {file_data.data(), rd_size},
                                     file.eof());
         if (std::tie(ec, size) = co_await async_write(bufs); ec) {
           break;
@@ -1016,8 +1018,9 @@ class coro_http_client : public std::enable_shared_from_this<coro_http_client> {
       while (true) {
         auto result = co_await source();
         std::vector<asio::const_buffer> bufs;
+        std::string size_str;
         cinatra::to_chunked_buffers(
-            bufs, {result.buf.data(), result.buf.size()}, result.eof);
+            bufs, size_str, {result.buf.data(), result.buf.size()}, result.eof);
         if (std::tie(ec, size) = co_await async_write(bufs); ec) {
           break;
         }

include/cinatra/coro_http_connection.hpp

@@ -367,7 +367,7 @@ class coro_http_connection
     size_t size;
     if (multi_buf_) {
       if (need_to_bufffer) {
-        response_.to_buffers(buffers_);
+        response_.to_buffers(buffers_, chunk_size_str_);
       }
       std::tie(ec, size) = co_await async_write(buffers_);
     }
@@ -392,35 +392,9 @@ class coro_http_connection
     co_return true;
   }
 
-  std::string local_address() {
-    if (has_closed_) {
-      return "";
-    }
+  std::string local_address() { return get_address_impl(false); }
 
-    std::stringstream ss;
-    std::error_code ec;
-    ss << socket_.local_endpoint(ec);
-    if (ec) {
-      return "";
-    }
-    return ss.str();
-  }
-
-  std::string remote_address() {
-    static std::string remote_addr;
-    if (has_closed_) {
-      return remote_addr;
-    }
-
-    std::stringstream ss;
-    std::error_code ec;
-    ss << socket_.remote_endpoint(ec);
-    if (ec) {
-      return remote_addr;
-    }
-    remote_addr = ss.str();
-    return ss.str();
-  }
+  std::string remote_address() { return get_address_impl(); }
 
   void set_multi_buf(bool r) { multi_buf_ = r; }
 
@@ -459,7 +433,7 @@ class coro_http_connection
                                                bool eof = false) {
     response_.set_delay(true);
     buffers_.clear();
-    to_chunked_buffers(buffers_, chunked_data, eof);
+    to_chunked_buffers(buffers_, chunk_size_str_, chunked_data, eof);
     co_return co_await reply(false);
   }
 
@@ -869,6 +843,24 @@ class coro_http_connection
     }
   }
 
+  std::string get_address_impl(bool remote = true) {
+    if (has_closed_) {
+      return "";
+    }
+
+    std::error_code ec;
+    auto pt = remote ? socket_.remote_endpoint(ec) : socket_.local_endpoint(ec);
+    if (ec) {
+      return "";
+    }
+    auto addr = pt.address().to_string(ec);
+    if (ec) {
+      return "";
+    }
+    addr.append(":").append(std::to_string(pt.port()));
+    return addr;
+  }
+
  private:
   friend class multipart_reader_t<coro_http_connection>;
   async_simple::Executor *executor_;
@@ -905,5 +897,6 @@ class coro_http_connection
   bool multi_buf_ = true;
   std::function<void(coro_http_request &, coro_http_response &)>
       default_handler_ = nullptr;
+  std::string chunk_size_str_;
 };
 }  // namespace cinatra

include/cinatra/coro_http_response.hpp

@@ -109,14 +109,15 @@ class coro_http_response {
 
   std::string_view get_boundary() { return boundary_; }
 
-  void to_buffers(std::vector<asio::const_buffer> &buffers) {
+  void to_buffers(std::vector<asio::const_buffer> &buffers,
+                  std::string &size_str) {
     buffers.push_back(asio::buffer(to_http_status_string(status_)));
     build_resp_head(buffers);
     if (!content_.empty()) {
-      handle_content(buffers, content_);
+      handle_content(buffers, size_str, content_);
     }
     else if (!content_view_.empty()) {
-      handle_content(buffers, content_view_);
+      handle_content(buffers, size_str, content_view_);
     }
   }
 
@@ -293,9 +294,9 @@ class coro_http_response {
 
  private:
   void handle_content(std::vector<asio::const_buffer> &buffers,
-                      std::string_view content) {
+                      std::string &size_str, std::string_view content) {
     if (fmt_type_ == format_type::chunked) {
-      to_chunked_buffers(buffers, content, true);
+      to_chunked_buffers(buffers, size_str, content, true);
     }
     else {
       buffers.push_back(asio::buffer(content));

include/cinatra/utils.hpp

@@ -135,18 +135,17 @@ inline std::string_view trim_sv(std::string_view v) {
   return v;
 }
 
-inline std::string_view to_hex_string(size_t val) {
-  static char buf[20];
-  auto [ptr, ec] = std::to_chars(std::begin(buf), std::end(buf), val, 16);
-  return std::string_view{buf, size_t(std::distance(buf, ptr))};
-}
-
 inline void to_chunked_buffers(std::vector<asio::const_buffer> &buffers,
+                               std::string &size_str,
                                std::string_view chunk_data, bool eof) {
   size_t length = chunk_data.size();
   if (length > 0) {
     // convert bytes transferred count to a hex string.
-    auto chunk_size = to_hex_string(length);
+    detail::resize(size_str, 20);
+    auto [ptr, ec] =
+        std::to_chars(size_str.data(), size_str.data() + 20, length, 16);
+    std::string_view chunk_size{size_str.data(),
+                                size_t(std::distance(size_str.data(), ptr))};
 
     // Construct chunk based on rfc2616 section 3.6.1
     buffers.push_back(asio::buffer(chunk_size));