The rom_impl variant of the https_request example test connects to an
external server, which requires a valid system time for TLS certificate
validation. In CI, SNTP time sync can be unreachable, causing transient
failures. Write the host timestamp into the DUT's NVS partition (via the
existing write_time_to_nvs helper) before running the test, so the
firmware can set its clock without depending on external NTP servers.
The otatool pytest calls dut.serial.close() and then immediately
launches otatool_example.py as a subprocess that re-opens the same
serial port via esptool. This fails intermittently because:
1. pytest-embedded's QueueFeederThread still holds a reference to
the serial port file descriptor when close() returns, causing
'argument must be an int, or have a fileno() method' error.
2. The OS has not fully released the serial port by the time the
subprocess tries to open it.
Add a delay after serial close and retry logic for the subprocess
to handle transient serial port contention.
Made-with: Cursor
Replace erase_nvs + SNTP time sync with direct NVS timestamp injection
from the pytest host. This eliminates CI flakiness caused by NTP servers
being unreachable from the CI lab network.
Changes:
- Add write_time_to_nvs() helper that generates an NVS partition image
with the current host timestamp and flashes it to the DUT before each
test. The firmware reads this via the existing update_time_from_nvs()
path and skips SNTP entirely.
- Remove @pytest.mark.parametrize('erase_nvs', ['y']) from all 4
Ethernet-based tests since NVS is now written with valid data.
Replace howsmyssl.com with letsencrypt.org in the https_x509_bundle
example. howsmyssl.com is a third-party server that is frequently
unreachable from CI, causing flaky test failures. letsencrypt.org
chains to the same ISRG Root X1 CA, so the custom certificate bundle
validation coverage is identical.
Since letsencrypt.org was already present in the full bundle URL list,
remove the duplicate entry and reduce MAX_URLS from 9 to 8. All 6
unique root CAs in the stress test are still covered.
For the QEMU stress test, increase per-connection timeout from 30s to
60s and final completion timeout from 60s to 180s. QEMU emulated
network is 3-5x slower than real hardware for TLS handshakes.
(cherry picked from commit d6596eff3a)
(squashed with commit 995c0f129e)
The WebSocket echo server tests connect immediately after seeing
'Starting server on port:' in the device log, but URI handlers
(/ws, /auth) are registered asynchronously after the server starts,
taking 40-660ms depending on config and CI load.
This causes two failures:
1. WebSocket handshake returns 404 Not Found because the URI
handler is not registered yet when the client connects.
2. WebSocket echo returns wrong data because the server is in a
partially initialized state.
Wait for 'Returned from app_main()' before connecting, which
guarantees all URI handlers are registered. Add connection retry
with WebSocketBadStatusException handling to WsClient.
Extract _wait_for_server_ready() helper to deduplicate the WiFi
credential input and server readiness logic.
(cherry picked from commit 7a50e3ab04)
The async handler CI tests fail intermittently because the TCP
connection from the pytest host to the ESP32 HTTP server times out
or gets refused.
Add a _connect_with_retry() helper that retries the TCP connection
up to 3 times with a 2-second delay between attempts, catching
TimeoutError, ConnectionRefusedError, and OSError.
Extract common server startup waiting into _wait_for_server_ready()
which includes a 2-second stabilization delay after the server
registers its URI handlers before tests begin sending requests.
(cherry picked from commit a665e7410c)
- Modified test for storage data, reduced the size to 500 bytes,
less than IMAGE_HEADER_SIZE (1024), to check the workflow, if the
custom partition other than APP and BOOTLOADER less IMAGE_HEADER_SIZE
performed OTA
- For custom partition less than IMAGE_HEADER_SIZE (1024 bytes), give
error - 'complete header not received'
- Skipped the read_header function for custom partition, and directly
jumped to IN_PROGRESS state
1. In async requests, if the two or more requests are made on same
socket then it used to block the second request.
2. The main thread is used to block on select call. And there done
no FD_SET for particular fd.
Closes https://github.com/espressif/esp-idf/issues/16998
1. If the user wants authenticate the request, then user needs to do
this before upgrading the protocol to websocket.
2. To achieve this, added pre_handshake_callack, which will execute
before handshake, i.e. before switching protocol.
Added the hidden config in the esp-tls component for the dynamic buffer
strategy configuration feature. So that external components like ota
can findout whether this feature is supported or not
Updated the README.md for the reprovisoning usage in wifi_prov_mgr example
and udpated the commnet for wifi_prov_mgr_reset_sm_state_for_reprovision api.
Problem:
1. In low-memory scenarios, the dynamic buffer feature can fail due to memory fragmentation.
2. It requires a contiguous 16KB heap chunk, but continuous allocation and deallocation of
the RX buffer can lead to fragmentation.
3. If another component allocates memory between these operations, it can break up the
available 16KB block, causing allocation failure.
Solution:
1. Introduce configurable strategy for using dynamic buffers in TLS connections.
2. For example, convert RX buffers to static after the TLS handshake.
3. Allow users to select the strategy via a new field in the esp_http_client_cfg_t structure.
4. The strategy can be controlled independently for each TLS session.
In httpd_register_uri_handler api, for the strdup function failure case was not
checked and not returned any error by freeing previously allocated memory, if the memory
allocation for strdup function did not gets successful.
Closes https://github.com/espressif/esp-idf/issues/15878
1. In httpd_req_async_handler_begin, the httpd_req_aux is locally malloced
and data is done memcpy to local httpd_req_aux from request'ss httpd_req_aux for
async request use-case, this causes scartch pointer from these two structs
pointing to same memory address.
2. In current workflow, the request's sratch buffer is freed in httpd_parse.c
httpd_req_cleanup api. Therefore if the user try to fetch the data (like headers)
from the scratch buffer, data will be not available.
3. Each request should have the deep copy of the scratch buffer. To retrive
the data later.
Closes https://github.com/espressif/esp-idf/issues/15587
1. In async handler example, on hitting /long URI and closing the
connection forcefully from client (example ctrl + c) cause more stack
size (almost 200 bytes) than successfull request.
2. The connection should be closed from the server as soon as the client
closes the connect (i.e. handler should return ESP_FAIL to close the
connection)
- esp_http_client support just PEM ca_cert and client_cert.
- Although esp_tls supports both PEM and DER certificate. We have logic
based on cert_len and client_cert_len which decides whether given cert or client_cert
is in PEM or DER format.
- If length is 0 then it is PEM certificate and if length is passed then DER is
considered. This is true for both ca_cert and client_cert
This commits allow to pass the DER certificate in esp_http_client
Disabling all the protocomm security versions give empty enum value build
error.
Note - Disabling the protocomm security 0 by default
Note - Disabling the protocomm security 0 by default
Note - Disabling the protocomm security 0 by default
Note - Disabling the protocomm security 0 by default
Note - Disabling the protocomm security 0 by default
Note - Disabling the protocomm security 0 by default
Note - Disabling the protocomm security 0 by default
Note - Disabling the protocomm security 0 by default
Note - Disabling the protocomm security 0 by default
Due to ci/pytest-mark-formatter(branch) fix, while executing the main
function from the pytest, it gives error for the incorrect idf_path.
This commit ensure that, idf_path is fixed correctly.
nvs_tool.py did not provide the minimal output support which outputs
the only necessary data.
nvs_tool.py minimal text ouptut, the deliminators were not handled
in the output
Closes https://github.com/espressif/esp-idf/issues/15274
res_buf was not freed for the chunk response type in case of
first_chunk_sent true condition.
This commit ensures that resp_buf is freed and few cosmetic
changes are made
In this commit, esp_http_server's http_parser scratch is made dynamic.
User is asked to give limit size for header and URI, according to which
scratch buufer allocates memory upto limits
The socket address length is not typecasted properly while
passing to bind and sendto functions. Due to this
http_server/simple was not running with target linux on MacOS
used to give error -
I (132253266) port: Starting scheduler.
I (132253269) esp_netif_loopback: loopback initialization
I (132253269) example: Starting server on port: '8001'
E (132253270) httpd: httpd_server_init: error in creating ctrl socket (22)
I (132253270) example: Error starting server!
With this commit, simple http server runs with target linux
on MacOS for IPV4 configurations
1. Remove the pre_encrypted_ota example from the esp-idf as we have
moved this example idf-extra-components repository under esp_encrypted_img
component
2. Added the migration guide for 5.5 release
Added check to whether nvs_keys partition is provided or not in partiton csv.
Converted nvs_sec_provider_register_flash_enc_ctr and nvs_sec_provider_register_hmac_ctr
functions from __attribute__(constructor) to ESP_SYSTEM_INIT_FN.
Checked the support of OTA features for esp32c5, tested
examples and added the support in README.md file. Even
added the support in systems .build-test-rules.yml
Added support http REPORT method and tested it using local server.
Added test case for REPOPRT method in esp_http_client_example.c
The URL(httpbin.org) does not support for /report endpoint.
Closes https://github.com/espressif/esp-idf/issues/14147
Hrushikesh Bhosale
