[web_server_idf] Reduce heap allocations by using stack buffers

esphome/components/mqtt/mqtt_alarm_control_panel.cpp

@@ -119,8 +119,7 @@ bool MQTTAlarmControlPanelComponent::publish_state() {
     default:
       state_s = "unknown";
   }
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  return this->publish(this->get_state_topic_to_(topic_buf), state_s);
+  return this->publish(this->get_state_topic_(), state_s);
 }
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_binary_sensor.cpp

@@ -52,9 +52,8 @@ bool MQTTBinarySensorComponent::publish_state(bool state) {
   if (this->binary_sensor_->is_status_binary_sensor())
     return true;
 
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
   const char *state_s = state ? "ON" : "OFF";
-  return this->publish(this->get_state_topic_to_(topic_buf), state_s);
+  return this->publish(this->get_state_topic_(), state_s);
 }
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_component.cpp

@@ -132,29 +132,17 @@ std::string MQTTComponent::get_command_topic_() const {
 }
 
 bool MQTTComponent::publish(const std::string &topic, const std::string &payload) {
-  return this->publish(topic.c_str(), payload.data(), payload.size());
+  return this->publish(topic, payload.data(), payload.size());
 }
 
 bool MQTTComponent::publish(const std::string &topic, const char *payload, size_t payload_length) {
-  return this->publish(topic.c_str(), payload, payload_length);
-}
-
-bool MQTTComponent::publish(const char *topic, const char *payload, size_t payload_length) {
-  if (topic[0] == '\0')
+  if (topic.empty())
     return false;
   return global_mqtt_client->publish(topic, payload, payload_length, this->qos_, this->retain_);
 }
 
-bool MQTTComponent::publish(const char *topic, const char *payload) {
-  return this->publish(topic, payload, strlen(payload));
-}
-
 bool MQTTComponent::publish_json(const std::string &topic, const json::json_build_t &f) {
-  return this->publish_json(topic.c_str(), f);
-}
-
-bool MQTTComponent::publish_json(const char *topic, const json::json_build_t &f) {
-  if (topic[0] == '\0')
+  if (topic.empty())
     return false;
   return global_mqtt_client->publish_json(topic, f, this->qos_, this->retain_);
 }

esphome/components/mqtt/mqtt_component.h

@@ -157,38 +157,6 @@ class MQTTComponent : public Component {
    */
   bool publish(const std::string &topic, const char *payload, size_t payload_length);
 
-  /** Send a MQTT message (no heap allocation for topic).
-   *
-   * @param topic The topic as C string.
-   * @param payload The payload buffer.
-   * @param payload_length The length of the payload.
-   */
-  bool publish(const char *topic, const char *payload, size_t payload_length);
-
-  /** Send a MQTT message (no heap allocation for topic).
-   *
-   * @param topic The topic as StringRef (for use with get_state_topic_to_()).
-   * @param payload The payload buffer.
-   * @param payload_length The length of the payload.
-   */
-  bool publish(StringRef topic, const char *payload, size_t payload_length) {
-    return this->publish(topic.c_str(), payload, payload_length);
-  }
-
-  /** Send a MQTT message (no heap allocation for topic).
-   *
-   * @param topic The topic as C string.
-   * @param payload The null-terminated payload.
-   */
-  bool publish(const char *topic, const char *payload);
-
-  /** Send a MQTT message (no heap allocation for topic).
-   *
-   * @param topic The topic as StringRef (for use with get_state_topic_to_()).
-   * @param payload The null-terminated payload.
-   */
-  bool publish(StringRef topic, const char *payload) { return this->publish(topic.c_str(), payload); }
-
   /** Construct and send a JSON MQTT message.
    *
    * @param topic The topic.
@@ -196,20 +164,6 @@ class MQTTComponent : public Component {
    */
   bool publish_json(const std::string &topic, const json::json_build_t &f);
 
-  /** Construct and send a JSON MQTT message (no heap allocation for topic).
-   *
-   * @param topic The topic as C string.
-   * @param f The Json Message builder.
-   */
-  bool publish_json(const char *topic, const json::json_build_t &f);
-
-  /** Construct and send a JSON MQTT message (no heap allocation for topic).
-   *
-   * @param topic The topic as StringRef (for use with get_state_topic_to_()).
-   * @param f The Json Message builder.
-   */
-  bool publish_json(StringRef topic, const json::json_build_t &f) { return this->publish_json(topic.c_str(), f); }
-
   /** Subscribe to a MQTT topic.
    *
    * @param topic The topic. Wildcards are currently not supported.

esphome/components/mqtt/mqtt_cover.cpp

@@ -115,8 +115,7 @@ bool MQTTCoverComponent::publish_state() {
                         : this->cover_->position == COVER_OPEN                       ? "open"
                         : traits.get_supports_position()                             ? "open"
                                                                                      : "unknown";
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  if (!this->publish(this->get_state_topic_to_(topic_buf), state_s))
+  if (!this->publish(this->get_state_topic_(), state_s))
     success = false;
   return success;
 }

esphome/components/mqtt/mqtt_date.cpp

@@ -53,8 +53,7 @@ bool MQTTDateComponent::send_initial_state() {
   }
 }
 bool MQTTDateComponent::publish_state(uint16_t year, uint8_t month, uint8_t day) {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  return this->publish_json(this->get_state_topic_to_(topic_buf), [year, month, day](JsonObject root) {
+  return this->publish_json(this->get_state_topic_(), [year, month, day](JsonObject root) {
     // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
     root[ESPHOME_F("year")] = year;
     root[ESPHOME_F("month")] = month;

esphome/components/mqtt/mqtt_datetime.cpp

@@ -66,17 +66,15 @@ bool MQTTDateTimeComponent::send_initial_state() {
 }
 bool MQTTDateTimeComponent::publish_state(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute,
                                           uint8_t second) {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  return this->publish_json(this->get_state_topic_to_(topic_buf),
-                            [year, month, day, hour, minute, second](JsonObject root) {
-                              // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
-                              root[ESPHOME_F("year")] = year;
-                              root[ESPHOME_F("month")] = month;
-                              root[ESPHOME_F("day")] = day;
-                              root[ESPHOME_F("hour")] = hour;
-                              root[ESPHOME_F("minute")] = minute;
-                              root[ESPHOME_F("second")] = second;
-                            });
+  return this->publish_json(this->get_state_topic_(), [year, month, day, hour, minute, second](JsonObject root) {
+    // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
+    root[ESPHOME_F("year")] = year;
+    root[ESPHOME_F("month")] = month;
+    root[ESPHOME_F("day")] = day;
+    root[ESPHOME_F("hour")] = hour;
+    root[ESPHOME_F("minute")] = minute;
+    root[ESPHOME_F("second")] = second;
+  });
 }
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_event.cpp

@@ -44,8 +44,7 @@ void MQTTEventComponent::dump_config() {
 }
 
 bool MQTTEventComponent::publish_event_(const std::string &event_type) {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  return this->publish_json(this->get_state_topic_to_(topic_buf), [event_type](JsonObject root) {
+  return this->publish_json(this->get_state_topic_(), [event_type](JsonObject root) {
     // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
     root[MQTT_EVENT_TYPE] = event_type;
   });

esphome/components/mqtt/mqtt_fan.cpp

@@ -158,10 +158,9 @@ void MQTTFanComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryConfig
   }
 }
 bool MQTTFanComponent::publish_state() {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
   const char *state_s = this->state_->state ? "ON" : "OFF";
   ESP_LOGD(TAG, "'%s' Sending state %s.", this->state_->get_name().c_str(), state_s);
-  this->publish(this->get_state_topic_to_(topic_buf), state_s);
+  this->publish(this->get_state_topic_(), state_s);
   bool failed = false;
   if (this->state_->get_traits().supports_direction()) {
     bool success = this->publish(this->get_direction_state_topic(),

esphome/components/mqtt/mqtt_light.cpp

@@ -34,8 +34,7 @@ void MQTTJSONLightComponent::on_light_remote_values_update() {
 MQTTJSONLightComponent::MQTTJSONLightComponent(LightState *state) : state_(state) {}
 
 bool MQTTJSONLightComponent::publish_state_() {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  return this->publish_json(this->get_state_topic_to_(topic_buf), [this](JsonObject root) {
+  return this->publish_json(this->get_state_topic_(), [this](JsonObject root) {
     // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
     LightJSONSchema::dump_json(*this->state_, root);
   });

esphome/components/mqtt/mqtt_lock.cpp

@@ -47,14 +47,13 @@ void MQTTLockComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryConfi
 bool MQTTLockComponent::send_initial_state() { return this->publish_state(); }
 
 bool MQTTLockComponent::publish_state() {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
 #ifdef USE_STORE_LOG_STR_IN_FLASH
   char buf[LOCK_STATE_STR_SIZE];
   strncpy_P(buf, (PGM_P) lock_state_to_string(this->lock_->state), sizeof(buf) - 1);
   buf[sizeof(buf) - 1] = '\0';
-  return this->publish(this->get_state_topic_to_(topic_buf), buf);
+  return this->publish(this->get_state_topic_(), buf);
 #else
-  return this->publish(this->get_state_topic_to_(topic_buf), LOG_STR_ARG(lock_state_to_string(this->lock_->state)));
+  return this->publish(this->get_state_topic_(), LOG_STR_ARG(lock_state_to_string(this->lock_->state)));
 #endif
 }
 

esphome/components/mqtt/mqtt_number.cpp

@@ -74,10 +74,9 @@ bool MQTTNumberComponent::send_initial_state() {
   }
 }
 bool MQTTNumberComponent::publish_state(float value) {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
   char buffer[64];
-  size_t len = buf_append_printf(buffer, sizeof(buffer), 0, "%f", value);
-  return this->publish(this->get_state_topic_to_(topic_buf), buffer, len);
+  buf_append_printf(buffer, sizeof(buffer), 0, "%f", value);
+  return this->publish(this->get_state_topic_(), buffer);
 }
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_select.cpp

@@ -50,8 +50,7 @@ bool MQTTSelectComponent::send_initial_state() {
   }
 }
 bool MQTTSelectComponent::publish_state(const std::string &value) {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  return this->publish(this->get_state_topic_to_(topic_buf), value.data(), value.size());
+  return this->publish(this->get_state_topic_(), value);
 }
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_sensor.cpp

@@ -79,13 +79,12 @@ bool MQTTSensorComponent::send_initial_state() {
   }
 }
 bool MQTTSensorComponent::publish_state(float value) {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
   if (mqtt::global_mqtt_client->is_publish_nan_as_none() && std::isnan(value))
-    return this->publish(this->get_state_topic_to_(topic_buf), "None", 4);
+    return this->publish(this->get_state_topic_(), "None", 4);
   int8_t accuracy = this->sensor_->get_accuracy_decimals();
   char buf[VALUE_ACCURACY_MAX_LEN];
   size_t len = value_accuracy_to_buf(buf, value, accuracy);
-  return this->publish(this->get_state_topic_to_(topic_buf), buf, len);
+  return this->publish(this->get_state_topic_(), buf, len);
 }
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_switch.cpp

@@ -52,9 +52,8 @@ void MQTTSwitchComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryCon
 bool MQTTSwitchComponent::send_initial_state() { return this->publish_state(this->switch_->state); }
 
 bool MQTTSwitchComponent::publish_state(bool state) {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
   const char *state_s = state ? "ON" : "OFF";
-  return this->publish(this->get_state_topic_to_(topic_buf), state_s);
+  return this->publish(this->get_state_topic_(), state_s);
 }
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_text.cpp

@@ -53,8 +53,7 @@ bool MQTTTextComponent::send_initial_state() {
   }
 }
 bool MQTTTextComponent::publish_state(const std::string &value) {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  return this->publish(this->get_state_topic_to_(topic_buf), value.data(), value.size());
+  return this->publish(this->get_state_topic_(), value);
 }
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_text_sensor.cpp

@@ -31,10 +31,7 @@ void MQTTTextSensor::dump_config() {
   LOG_MQTT_COMPONENT(true, false);
 }
 
-bool MQTTTextSensor::publish_state(const std::string &value) {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  return this->publish(this->get_state_topic_to_(topic_buf), value.data(), value.size());
-}
+bool MQTTTextSensor::publish_state(const std::string &value) { return this->publish(this->get_state_topic_(), value); }
 bool MQTTTextSensor::send_initial_state() {
   if (this->sensor_->has_state()) {
     return this->publish_state(this->sensor_->state);

esphome/components/mqtt/mqtt_time.cpp

@@ -53,8 +53,7 @@ bool MQTTTimeComponent::send_initial_state() {
   }
 }
 bool MQTTTimeComponent::publish_state(uint8_t hour, uint8_t minute, uint8_t second) {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  return this->publish_json(this->get_state_topic_to_(topic_buf), [hour, minute, second](JsonObject root) {
+  return this->publish_json(this->get_state_topic_(), [hour, minute, second](JsonObject root) {
     // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
     root[ESPHOME_F("hour")] = hour;
     root[ESPHOME_F("minute")] = minute;

esphome/components/mqtt/mqtt_update.cpp

@@ -28,8 +28,7 @@ void MQTTUpdateComponent::setup() {
 }
 
 bool MQTTUpdateComponent::publish_state() {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  return this->publish_json(this->get_state_topic_to_(topic_buf), [this](JsonObject root) {
+  return this->publish_json(this->get_state_topic_(), [this](JsonObject root) {
     root[ESPHOME_F("installed_version")] = this->update_->update_info.current_version;
     root[ESPHOME_F("latest_version")] = this->update_->update_info.latest_version;
     root[ESPHOME_F("title")] = this->update_->update_info.title;

esphome/components/mqtt/mqtt_valve.cpp

@@ -84,8 +84,7 @@ bool MQTTValveComponent::publish_state() {
                         : this->valve_->position == VALVE_OPEN                       ? "open"
                         : traits.get_supports_position()                             ? "open"
                                                                                      : "unknown";
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  if (!this->publish(this->get_state_topic_to_(topic_buf), state_s))
+  if (!this->publish(this->get_state_topic_(), state_s))
     success = false;
   return success;
 }

esphome/components/web_server_idf/utils.cpp

@@ -78,11 +78,8 @@ optional<std::string> query_key_value(const std::string &query_url, const std::s
     return {};
   }
 
-  auto val = std::unique_ptr<char[]>(new char[query_url.size()]);
-  if (!val) {
-    ESP_LOGE(TAG, "Not enough memory to the query key value");
-    return {};
-  }
+  // Use stack buffer for typical query strings, heap fallback for large ones
+  SmallBufferWithHeapFallback<256, char> val(query_url.size());
 
   if (httpd_query_key_value(query_url.c_str(), key.c_str(), val.get(), query_url.size()) != ESP_OK) {
     return {};

esphome/components/web_server_idf/web_server_idf.cpp

@@ -352,14 +352,15 @@ bool AsyncWebServerRequest::authenticate(const char *username, const char *passw
   memcpy(user_info + user_len + 1, password, pass_len);
   user_info[user_info_len] = '\0';
 
-  size_t n = 0, out;
-  esp_crypto_base64_encode(nullptr, 0, &n, reinterpret_cast<const uint8_t *>(user_info), user_info_len);
-
-  auto digest = std::unique_ptr<char[]>(new char[n + 1]);
-  esp_crypto_base64_encode(reinterpret_cast<uint8_t *>(digest.get()), n, &out,
+  // Base64 output size is ceil(input_len * 4/3) + 1, with input bounded to 256 bytes
+  // max output is ceil(256 * 4/3) + 1 = 343 bytes, use 350 for safety
+  constexpr size_t max_digest_len = 350;
+  char digest[max_digest_len];
+  size_t out;
+  esp_crypto_base64_encode(reinterpret_cast<uint8_t *>(digest), max_digest_len, &out,
                            reinterpret_cast<const uint8_t *>(user_info), user_info_len);
 
-  return strcmp(digest.get(), auth_str + auth_prefix_len) == 0;
+  return strcmp(digest, auth_str + auth_prefix_len) == 0;
 }
 
 void AsyncWebServerRequest::requestAuthentication(const char *realm) const {
@@ -869,12 +870,12 @@ esp_err_t AsyncWebServer::handle_multipart_upload_(httpd_req_t *r, const char *c
     }
   });
 
-  // Process data
-  std::unique_ptr<char[]> buffer(new char[MULTIPART_CHUNK_SIZE]);
+  // Process data - use stack buffer to avoid heap allocation
+  char buffer[MULTIPART_CHUNK_SIZE];
   size_t bytes_since_yield = 0;
 
   for (size_t remaining = r->content_len; remaining > 0;) {
-    int recv_len = httpd_req_recv(r, buffer.get(), std::min(remaining, MULTIPART_CHUNK_SIZE));
+    int recv_len = httpd_req_recv(r, buffer, std::min(remaining, MULTIPART_CHUNK_SIZE));
 
     if (recv_len <= 0) {
       httpd_resp_send_err(r, recv_len == HTTPD_SOCK_ERR_TIMEOUT ? HTTPD_408_REQ_TIMEOUT : HTTPD_400_BAD_REQUEST,
@@ -882,7 +883,7 @@ esp_err_t AsyncWebServer::handle_multipart_upload_(httpd_req_t *r, const char *c
       return recv_len == HTTPD_SOCK_ERR_TIMEOUT ? ESP_ERR_TIMEOUT : ESP_FAIL;
     }
 
-    if (reader->parse(buffer.get(), recv_len) != static_cast<size_t>(recv_len)) {
+    if (reader->parse(buffer, recv_len) != static_cast<size_t>(recv_len)) {
       ESP_LOGW(TAG, "Multipart parser error");
       httpd_resp_send_err(r, HTTPD_400_BAD_REQUEST, nullptr);
       return ESP_FAIL;