ESPHome 2025.6.3
Loading...
Searching...
No Matches
http_request_idf.cpp
Go to the documentation of this file.
1#include "http_request_idf.h"
2
3#ifdef USE_ESP_IDF
4
7
9#include "esphome/core/log.h"
10
11#if CONFIG_MBEDTLS_CERTIFICATE_BUNDLE
12#include "esp_crt_bundle.h"
13#endif
14
15#include "esp_task_wdt.h"
16
17namespace esphome {
18namespace http_request {
19
20static const char *const TAG = "http_request.idf";
21
22struct UserData {
23 const std::set<std::string> &collect_headers;
24 std::map<std::string, std::list<std::string>> response_headers;
25};
26
29 ESP_LOGCONFIG(TAG,
30 " Buffer Size RX: %u\n"
31 " Buffer Size TX: %u",
32 this->buffer_size_rx_, this->buffer_size_tx_);
33}
34
35esp_err_t HttpRequestIDF::http_event_handler(esp_http_client_event_t *evt) {
36 UserData *user_data = (UserData *) evt->user_data;
37
38 switch (evt->event_id) {
39 case HTTP_EVENT_ON_HEADER: {
40 const std::string header_name = str_lower_case(evt->header_key);
41 if (user_data->collect_headers.count(header_name)) {
42 const std::string header_value = evt->header_value;
43 ESP_LOGD(TAG, "Received response header, name: %s, value: %s", header_name.c_str(), header_value.c_str());
44 user_data->response_headers[header_name].push_back(header_value);
45 }
46 break;
47 }
48 default: {
49 break;
50 }
51 }
52 return ESP_OK;
53}
54
55std::shared_ptr<HttpContainer> HttpRequestIDF::perform(std::string url, std::string method, std::string body,
56 std::list<Header> request_headers,
57 std::set<std::string> collect_headers) {
58 if (!network::is_connected()) {
59 this->status_momentary_error("failed", 1000);
60 ESP_LOGE(TAG, "HTTP Request failed; Not connected to network");
61 return nullptr;
62 }
63
64 esp_http_client_method_t method_idf;
65 if (method == "GET") {
66 method_idf = HTTP_METHOD_GET;
67 } else if (method == "POST") {
68 method_idf = HTTP_METHOD_POST;
69 } else if (method == "PUT") {
70 method_idf = HTTP_METHOD_PUT;
71 } else if (method == "DELETE") {
72 method_idf = HTTP_METHOD_DELETE;
73 } else if (method == "PATCH") {
74 method_idf = HTTP_METHOD_PATCH;
75 } else {
76 this->status_momentary_error("failed", 1000);
77 ESP_LOGE(TAG, "HTTP Request failed; Unsupported method");
78 return nullptr;
79 }
80
81 bool secure = url.find("https:") != std::string::npos;
82
83 esp_http_client_config_t config = {};
84
85 config.url = url.c_str();
86 config.method = method_idf;
87 config.timeout_ms = this->timeout_;
88 config.disable_auto_redirect = !this->follow_redirects_;
89 config.max_redirection_count = this->redirect_limit_;
90 config.auth_type = HTTP_AUTH_TYPE_BASIC;
91#if CONFIG_MBEDTLS_CERTIFICATE_BUNDLE
92 if (secure) {
93 config.crt_bundle_attach = esp_crt_bundle_attach;
94 }
95#endif
96
97 if (this->useragent_ != nullptr) {
98 config.user_agent = this->useragent_;
99 }
100
101 config.buffer_size = this->buffer_size_rx_;
102 config.buffer_size_tx = this->buffer_size_tx_;
103
104 const uint32_t start = millis();
106
107 config.event_handler = http_event_handler;
108 auto user_data = UserData{collect_headers, {}};
109 config.user_data = static_cast<void *>(&user_data);
110
111 esp_http_client_handle_t client = esp_http_client_init(&config);
112
113 std::shared_ptr<HttpContainerIDF> container = std::make_shared<HttpContainerIDF>(client);
114 container->set_parent(this);
115
116 container->set_secure(secure);
117
118 for (const auto &header : request_headers) {
119 esp_http_client_set_header(client, header.name.c_str(), header.value.c_str());
120 }
121
122 const int body_len = body.length();
123
124 esp_err_t err = esp_http_client_open(client, body_len);
125 if (err != ESP_OK) {
126 this->status_momentary_error("failed", 1000);
127 ESP_LOGE(TAG, "HTTP Request failed: %s", esp_err_to_name(err));
128 esp_http_client_cleanup(client);
129 return nullptr;
130 }
131
132 if (body_len > 0) {
133 int write_left = body_len;
134 int write_index = 0;
135 const char *buf = body.c_str();
136 while (write_left > 0) {
137 int written = esp_http_client_write(client, buf + write_index, write_left);
138 if (written < 0) {
139 err = ESP_FAIL;
140 break;
141 }
142 write_left -= written;
143 write_index += written;
144 }
145 }
146
147 if (err != ESP_OK) {
148 this->status_momentary_error("failed", 1000);
149 ESP_LOGE(TAG, "HTTP Request failed: %s", esp_err_to_name(err));
150 esp_http_client_cleanup(client);
151 return nullptr;
152 }
153
154 container->feed_wdt();
155 container->content_length = esp_http_client_fetch_headers(client);
156 container->feed_wdt();
157 container->status_code = esp_http_client_get_status_code(client);
158 container->feed_wdt();
159 container->set_response_headers(user_data.response_headers);
160 if (is_success(container->status_code)) {
161 container->duration_ms = millis() - start;
162 return container;
163 }
164
165 if (this->follow_redirects_) {
166 auto num_redirects = this->redirect_limit_;
167 while (is_redirect(container->status_code) && num_redirects > 0) {
168 err = esp_http_client_set_redirection(client);
169 if (err != ESP_OK) {
170 ESP_LOGE(TAG, "esp_http_client_set_redirection failed: %s", esp_err_to_name(err));
171 this->status_momentary_error("failed", 1000);
172 esp_http_client_cleanup(client);
173 return nullptr;
174 }
175#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
176 char redirect_url[256]{};
177 if (esp_http_client_get_url(client, redirect_url, sizeof(redirect_url) - 1) == ESP_OK) {
178 ESP_LOGV(TAG, "redirecting to url: %s", redirect_url);
179 }
180#endif
181 err = esp_http_client_open(client, 0);
182 if (err != ESP_OK) {
183 ESP_LOGE(TAG, "esp_http_client_open failed: %s", esp_err_to_name(err));
184 this->status_momentary_error("failed", 1000);
185 esp_http_client_cleanup(client);
186 return nullptr;
187 }
188
189 container->feed_wdt();
190 container->content_length = esp_http_client_fetch_headers(client);
191 container->feed_wdt();
192 container->status_code = esp_http_client_get_status_code(client);
193 container->feed_wdt();
194 if (is_success(container->status_code)) {
195 container->duration_ms = millis() - start;
196 return container;
197 }
198
199 num_redirects--;
200 }
201
202 if (num_redirects == 0) {
203 ESP_LOGW(TAG, "Reach redirect limit count=%d", this->redirect_limit_);
204 }
205 }
206
207 ESP_LOGE(TAG, "HTTP Request failed; URL: %s; Code: %d", url.c_str(), container->status_code);
208 this->status_momentary_error("failed", 1000);
209 return container;
210}
211
212int HttpContainerIDF::read(uint8_t *buf, size_t max_len) {
213 const uint32_t start = millis();
214 watchdog::WatchdogManager wdm(this->parent_->get_watchdog_timeout());
215
216 int bufsize = std::min(max_len, this->content_length - this->bytes_read_);
217
218 if (bufsize == 0) {
219 this->duration_ms += (millis() - start);
220 return 0;
221 }
222
223 this->feed_wdt();
224 int read_len = esp_http_client_read(this->client_, (char *) buf, bufsize);
225 this->feed_wdt();
226 this->bytes_read_ += read_len;
227
228 this->duration_ms += (millis() - start);
229
230 return read_len;
231}
232
234 watchdog::WatchdogManager wdm(this->parent_->get_watchdog_timeout());
235
236 esp_http_client_close(this->client_);
237 esp_http_client_cleanup(this->client_);
238}
239
241 // Tests to see if the executing task has a watchdog timer attached
242 if (esp_task_wdt_status(nullptr) == ESP_OK) {
243 App.feed_wdt();
244 }
245}
246
247} // namespace http_request
248} // namespace esphome
249
250#endif // USE_ESP_IDF
void feed_wdt(uint32_t time=0)
void status_momentary_error(const std::string &name, uint32_t length=5000)
int read(uint8_t *buf, size_t max_len) override
void feed_wdt()
Feeds the watchdog timer if the executing task has one attached.
std::shared_ptr< HttpContainer > start(const std::string &url, const std::string &method, const std::string &body, const std::list< Header > &request_headers)
std::shared_ptr< HttpContainer > perform(std::string url, std::string method, std::string body, std::list< Header > request_headers, std::set< std::string > collect_headers) override
static esp_err_t http_event_handler(esp_http_client_event_t *evt)
Monitors the http client events to gather response headers.
bool is_success(int const status)
Checks if the given HTTP status code indicates a successful request.
bool is_redirect(int const status)
Returns true if the HTTP status code is a redirect.
bool is_connected()
Return whether the node is connected to the network (through wifi, eth, ...)
Definition util.cpp:19
Providing packet encoding functions for exchanging data with a remote host.
Definition a01nyub.cpp:7
std::string str_lower_case(const std::string &str)
Convert the string to lower case.
Definition helpers.cpp:290
uint32_t IRAM_ATTR HOT millis()
Definition core.cpp:28
Application App
Global storage of Application pointer - only one Application can exist.