1#if defined(USE_ESP32_VARIANT_ESP32H2) || defined(USE_ESP32_VARIANT_ESP32P4)
7#include <esp_image_format.h>
8#include <esp_app_desc.h>
10#include <esp_hosted_host_fw_ver.h>
11#include <esp_ota_ops.h>
12#include <esp_system.h>
15#ifdef USE_ESP32_HOSTED_HTTP_UPDATE
22#include <esp_hosted_ota.h>
34static esp_err_t ota_end_guarded() {
36 return esp_hosted_slave_ota_end();
39#ifdef USE_ESP32_HOSTED_HTTP_UPDATE
45#define STRINGIFY_(x) #x
46#define STRINGIFY(x) STRINGIFY_(x)
47static const char *
const ESP_HOSTED_VERSION_STR = STRINGIFY(ESP_HOSTED_VERSION_MAJOR_1)
"." STRINGIFY(
48 ESP_HOSTED_VERSION_MINOR_1)
"." STRINGIFY(ESP_HOSTED_VERSION_PATCH_1);
50#ifdef USE_ESP32_HOSTED_HTTP_UPDATE
53static bool parse_int(
const char *&ptr,
int &
value) {
55 value =
static_cast<int>(strtol(ptr, &
end, 10));
64static bool parse_version(
const std::string &version_str,
int &major,
int &minor,
int &patch) {
65 major = minor = patch = 0;
66 const char *ptr = version_str.c_str();
68 if (!parse_int(ptr, major) || *ptr !=
'.')
71 if (!parse_int(ptr, minor))
74 parse_int(++ptr, patch);
83static int compare_versions(
int major1,
int minor1,
int patch1,
int major2,
int minor2,
int patch2) {
85 return major1 < major2 ? -1 : 1;
87 return minor1 < minor2 ? -1 : 1;
89 return patch1 < patch2 ? -1 : 1;
99 esp_hosted_connect_to_slave();
103 esp_hosted_coprocessor_fwver_t ver_info;
104 if (esp_hosted_get_coprocessor_fwversion(&ver_info) == ESP_OK) {
107 snprintf(buf,
sizeof(buf),
"%" PRIu32
".%" PRIu32
".%" PRIu32, ver_info.major1, ver_info.minor1, ver_info.patch1);
114#ifndef USE_ESP32_HOSTED_HTTP_UPDATE
116 const int app_desc_offset =
sizeof(esp_image_header_t) +
sizeof(esp_image_segment_header_t);
117 if (this->
firmware_size_ >= app_desc_offset +
sizeof(esp_app_desc_t)) {
118 esp_app_desc_t *app_desc = (esp_app_desc_t *) (this->
firmware_data_ + app_desc_offset);
119 if (app_desc->magic_word == ESP_APP_DESC_MAGIC_WORD) {
121 "ESP32 Hosted firmware:\n"
122 " Firmware version: %s\n"
123 " Project name: %s\n"
127 app_desc->version, app_desc->project_name, app_desc->date, app_desc->time, app_desc->idf_ver);
135 ESP_LOGW(TAG,
"Invalid app description magic word: 0x%08" PRIx32
" (expected 0x%08" PRIx32
")",
136 app_desc->magic_word,
static_cast<uint32_t>(ESP_APP_DESC_MAGIC_WORD));
140 ESP_LOGW(TAG,
"Firmware too small to contain app description");
156 this->
set_interval(INITIAL_CHECK_INTERVAL_ID, 10000, [
this]() {
171 "ESP32 Hosted Update:\n"
172 " Host Library Version: %s\n"
173 " Coprocessor Version: %s\n"
174 " Latest Version: %s",
176 this->update_info_.latest_version.c_str());
177#ifdef USE_ESP32_HOSTED_HTTP_UPDATE
185 " Firmware Size: %zu bytes",
191#ifdef USE_ESP32_HOSTED_HTTP_UPDATE
193 ESP_LOGD(TAG,
"Network not connected, skipping update check");
205 this->update_info_.latest_version == this->update_info_.current_version) {
221#ifdef USE_ESP32_HOSTED_HTTP_UPDATE
223 ESP_LOGD(TAG,
"Fetching manifest");
226 if (container ==
nullptr || container->status_code != 200) {
227 ESP_LOGE(TAG,
"Failed to fetch manifest from %s", this->
source_url_);
235 std::string json_str;
236 json_str.reserve(container->content_length);
240 while (container->get_bytes_read() < container->content_length) {
241 int read_or_error = container->read(buf,
sizeof(buf));
252 json_str.append(
reinterpret_cast<char *
>(buf), read_or_error);
260 if (!root[
"versions"].is<JsonArray>()) {
261 ESP_LOGE(TAG,
"Manifest does not contain 'versions' array");
265 JsonArray versions = root[
"versions"].as<JsonArray>();
266 if (versions.size() == 0) {
267 ESP_LOGE(TAG,
"Manifest 'versions' array is empty");
273 int best_major = -1, best_minor = -1, best_patch = -1;
274 std::string best_version, best_url, best_sha256;
276 for (JsonObject entry : versions) {
277 if (!entry[
"version"].is<const char *>() || !entry[
"url"].is<const char *>() ||
278 !entry[
"sha256"].is<const char *>()) {
282 std::string ver_str = entry[
"version"].as<std::string>();
283 int major, minor, patch;
284 if (!parse_version(ver_str, major, minor, patch)) {
285 ESP_LOGW(TAG,
"Failed to parse version: %s", ver_str.c_str());
290 if (compare_versions(major, minor, patch, ESP_HOSTED_VERSION_MAJOR_1, ESP_HOSTED_VERSION_MINOR_1,
291 ESP_HOSTED_VERSION_PATCH_1) > 0) {
296 if (best_major < 0 || compare_versions(major, minor, patch, best_major, best_minor, best_patch) > 0) {
300 best_version = ver_str;
301 best_url = entry[
"url"].as<std::string>();
302 best_sha256 = entry[
"sha256"].as<std::string>();
306 if (best_major < 0) {
307 ESP_LOGW(TAG,
"No compatible firmware version found (host is %s)", ESP_HOSTED_VERSION_STR);
316 ESP_LOGE(TAG,
"Invalid SHA256: %s", best_sha256.c_str());
326 ESP_LOGE(TAG,
"Failed to parse manifest JSON");
335 ESP_LOGI(TAG,
"Downloading firmware");
338 if (container ==
nullptr || container->status_code != 200) {
339 ESP_LOGE(TAG,
"Failed to fetch firmware");
344 size_t total_size = container->content_length;
345 ESP_LOGI(TAG,
"Firmware size: %zu bytes", total_size);
351 err = esp_hosted_slave_ota_begin();
354 ESP_LOGE(TAG,
"Failed to begin OTA: %s", esp_err_to_name(err));
369 while (container->get_bytes_read() < total_size) {
370 int read_or_error = container->read(
buffer,
sizeof(
buffer));
386 ESP_LOGE(TAG,
"Timeout reading firmware data");
388 ESP_LOGE(TAG,
"Error reading firmware data: %d", read_or_error);
397 err = esp_hosted_slave_ota_write(
buffer, read_or_error);
399 ESP_LOGE(TAG,
"Failed to write OTA data: %s", esp_err_to_name(err));
410 if (!hasher.
equals_bytes(this->firmware_sha256_.data())) {
411 ESP_LOGE(TAG,
"SHA256 mismatch");
417 ESP_LOGI(TAG,
"SHA256 verified successfully");
423 ESP_LOGE(TAG,
"No firmware data available");
433 if (!hasher.
equals_bytes(this->firmware_sha256_.data())) {
434 ESP_LOGE(TAG,
"SHA256 mismatch");
439 ESP_LOGI(TAG,
"Starting OTA update (%zu bytes)", this->
firmware_size_);
444 err = esp_hosted_slave_ota_begin();
447 ESP_LOGE(TAG,
"Failed to begin OTA: %s", esp_err_to_name(err));
455 while (remaining > 0) {
456 size_t chunk_size = std::min(remaining,
static_cast<size_t>(
CHUNK_SIZE));
457 memcpy(chunk, data_ptr, chunk_size);
458 err = esp_hosted_slave_ota_write(chunk, chunk_size);
460 ESP_LOGE(TAG,
"Failed to write OTA data: %s", esp_err_to_name(err));
465 data_ptr += chunk_size;
466 remaining -= chunk_size;
476 ESP_LOGW(TAG,
"Update not available");
480#ifdef USE_ESP32_HOSTED_HTTP_UPDATE
482 ESP_LOGW(TAG,
"No firmware URL available, run check first");
492#ifdef USE_ESP32_HOSTED_HTTP_UPDATE
498 this->
state_ = prev_state;
503 esp_err_t end_err = ota_end_guarded();
504 if (end_err != ESP_OK) {
505 ESP_LOGE(TAG,
"Failed to end OTA: %s", esp_err_to_name(end_err));
506 this->
state_ = prev_state;
513 ESP_LOGI(TAG,
"OTA update successful");
518#ifdef USE_OTA_ROLLBACK
521 esp_ota_mark_app_valid_cancel_rollback();
525 ESP_LOGI(TAG,
"Restarting in 1 second");
530 esp_err_t err = esp_hosted_slave_ota_activate();
532 ESP_LOGE(TAG,
"Failed to activate OTA: %s", esp_err_to_name(err));
536 esp_unregister_shutdown_handler(
reinterpret_cast<shutdown_handler_t
>(esp_wifi_stop));
void feed_wdt()
Feed the task watchdog.
void safe_shutdown(uint32_t timeout_ms)
Run the safe shutdown hooks, give components up to timeout_ms to tear down, then run the powerdown ho...
bool cancel_interval(const char *name)
Cancel an interval function.
void status_clear_error()
void set_timeout(const char *name, uint32_t timeout, std::function< void()> &&f)
Set a timeout function with a const char* name.
void defer(const char *name, std::function< void()> &&f)
Defer a callback to the next loop() call with a const char* name.
void set_interval(const char *name, uint32_t interval, std::function< void()> &&f)
Set an interval function with a const char* name.
bool equals_bytes(const uint8_t *expected)
Compare the hash against a provided byte-encoded hash.
virtual uint32_t get_update_interval() const
Get the update interval in ms of this sensor.
void dump_config() override
bool stream_firmware_to_coprocessor_()
uint8_t initial_check_remaining_
http_request::HttpRequestComponent * http_request_parent_
std::array< uint8_t, 32 > firmware_sha256_
std::string firmware_url_
const uint8_t * firmware_data_
bool write_embedded_firmware_to_coprocessor_()
std::shared_ptr< HttpContainer > get(const char *url)
uint32_t get_timeout() const
SHA256 hash implementation.
void calculate() override
void add(const uint8_t *data, size_t len) override
std::unique_ptr< Trigger< const UpdateInfo & > > update_available_trigger_
constexpr uint32_t INITIAL_CHECK_INTERVAL_ID
ESPHOME_LOG_TAG(TAG, "esp32_hosted.update")
constexpr uint32_t OTA_WDT_TIMEOUT_MS
constexpr size_t CHUNK_SIZE
@ TIMEOUT
Timeout waiting for data, caller should exit loop.
@ COMPLETE
All content has been read, caller should exit loop.
@ RETRY
No data yet, already delayed, caller should continue loop.
@ DATA
Data was read, process it.
HttpReadLoopResult http_read_loop_result(int bytes_read_or_error, uint32_t &last_data_time, uint32_t timeout_ms, bool is_read_complete)
Process a read result with timeout tracking and delay handling.
bool parse_json(const std::string &data, const json_parse_t &f)
Parse a JSON string and run the provided json parse function if it's valid.
ESPHOME_ALWAYS_INLINE bool is_connected()
Return whether the node is connected to the network (through wifi, eth, ...)
@ UPDATE_STATE_INSTALLING
size_t parse_hex(const char *str, size_t length, uint8_t *data, size_t count)
Parse bytes from a hex-encoded string into a byte array.
uint32_t IRAM_ATTR HOT millis()
Application App
Global storage of Application pointer - only one Application can exist.
std::string current_version
std::string latest_version