固件 OTA 升级

static volatile bool g_ota_confirmed;
static volatile int g_ota_channel;

static void on_ota_confirmed(int channel, void *user_data)
{
    (void)user_data;
    g_ota_confirmed = true;   /* 只做轻量通知，不阻塞 MQTT process 线程 */
    g_ota_channel = channel;
}

iot_client_config_t cfg = {
    /* ... */
    .ota_confirm_callback = on_ota_confirmed,
    .ota_confirm_user_data = NULL,
};

iot_ota_upgrade_info_t info = {0};
if (!g_ota_confirmed) {
    /* 等待确认信号 */
}

int rc = iot_ota_check_upgrade(client, g_ota_channel, &info);
if (rc == OPRT_OK && info.has_upgrade) {
    rc = iot_ota_report_status(client, info.channel, OTA_STATUS_UPGRADING);
    /* 在应用线程执行下载、iot_ota_verify_* 校验和平台 OTA 烧写 */
}
iot_ota_upgrade_info_free(client, &info);

typedef struct {
    bool  has_upgrade;   // 云端是否有升级
    char *version;       // 目标版本号
    char *url;           // 固件下载 URL（优先 cdnUrl，回退 httpsUrl）
    long  file_size;     // 固件大小（字节）
    int   channel;       // 固件通道（0 = 主 MCU）
    char *md5;           // MD5 校验（可能为 NULL）
    char *hmac;          // HMAC 校验（可能为 NULL）
} iot_ota_upgrade_info_t;

typedef enum {
    OTA_STATUS_IDLE      = 0,  // 默认，不需要升级
    OTA_STATUS_READY     = 1,  // 设备准备就绪（升级任务已下发）
    OTA_STATUS_UPGRADING = 2,  // 升级中（下载/烧写前）
    OTA_STATUS_COMPLETE  = 3,  // 升级成功（重启前回报）
    OTA_STATUS_ERROR     = 4,  // 升级失败 / 异常
} iot_ota_status_t;

iot_ota_verify_ctx_t *ctx = NULL;
int rc = iot_ota_verify_init(iot, &info, &ctx);
if (rc != OPRT_OK && rc != OPRT_NOT_SUPPORTED) {
    /* 摘要格式非法、内存不足等 —— 中止升级，上报 OTA_STATUS_ERROR */
    return -1;
}
/* rc == OPRT_NOT_SUPPORTED: 云端没有摘要字段，ctx 保持 NULL，跳过校验
 * （应用自行决定） */

while ((n = read_firmware_chunk(buf)) > 0) {
    if (ctx != NULL && iot_ota_verify_update(ctx, buf, n) != OPRT_OK) {
        iot_ota_verify_abort(ctx);
        return -1;
    }
    flash_write(buf, n);                  /* 与喂给校验器的数据一致 */
}

if (ctx != NULL) {
    rc = iot_ota_verify_finish(ctx);      /* 内部释放 ctx */
    if (rc != OPRT_OK) {
        /* OPRT_OTA_VERIFY_FAILED: 固件被篡改/损坏 —— 中止，上报 OTA_STATUS_ERROR */
        return -1;
    }
}

#include "iot_client.h"
#include "iot_ota.h"
#include "esp_app_desc.h"
#include "esp_crt_bundle.h"

const esp_app_desc_t *desc = esp_app_get_description();

iot_client_config_t iot_cfg = {
    .devid      = DEFAULT_DEVID,
    .secret_key = DEFAULT_SECRET_KEY,
    .local_key  = DEFAULT_LOCAL_KEY,
    .region     = DEFAULT_REGION,
    .env        = DEFAULT_ENV,
    /* 关闭自动连接：只用 ATOP HTTP，不连 MQTT */
    .mqtt_disable_auto_connect = true,
    /* 应用固件版本：init 时自动上报，供云端 OTA 比较（NULL 用 SDK 默认） */
    .sw_ver     = desc->version,
    /* 公共 CA 证书包：ATOP HTTPS（版本上报/升级查询/状态回报）需要 */
    .cert_bundle_attach = (tls_cert_bundle_attach_fn)esp_crt_bundle_attach,
};

/* iot_init(pal) 必须在 iot_client_init 前调用，否则 iot_client_init 返回 NULL */
iot_init(tai_pal_freertos());

iot_client_t *iot = iot_client_init(&iot_cfg);

/* 查询升级（云端与 init 时上报的 sw_ver 比较，无需再传版本号） */
iot_ota_upgrade_info_t info = {0};
int rc = iot_ota_check_upgrade(iot, 0, &info);
if (rc == OPRT_OK && info.has_upgrade) {
    ESP_LOGI(TAG, "upgrade -> %s  url=%s  size=%ld",
             info.version, info.url, info.file_size);
}

/* 下载前上报"升级中" */
iot_ota_report_status(iot, 0, OTA_STATUS_UPGRADING);

/* 用 esp_http_client 下载 info.url，逐块 esp_ota_write + 摘要校验 */
esp_err_t err = download_and_flash(iot, &info);
iot_ota_upgrade_info_free(iot, &info);

if (err != ESP_OK) {
    iot_ota_report_status(iot, 0, OTA_STATUS_ERROR);
    return;
}

/* 成功后上报"完成"，然后重启 */
iot_ota_report_status(iot, 0, OTA_STATUS_COMPLETE);
esp_restart();

static esp_err_t download_and_flash(iot_client_t *iot,
                                    const iot_ota_upgrade_info_t *info)
{
    const esp_partition_t *part = esp_ota_get_next_update_partition(NULL);

    /* 摘要校验上下文（云端无 md5/hmac 时返回 OPRT_NOT_SUPPORTED，verify 保持 NULL） */
    iot_ota_verify_ctx_t *verify = NULL;
    int vrc = iot_ota_verify_init(iot, info, &verify);
    if (vrc != OPRT_OK && vrc != OPRT_NOT_SUPPORTED) {
        ESP_LOGE(TAG, "iot_ota_verify_init failed: %d", vrc);
        return ESP_FAIL;   /* 校验器建不起来 —— 不装这个固件 */
    }

    esp_http_client_config_t http_cfg = {
        .url              = info->url,
        .timeout_ms       = 30000,
        .buffer_size      = 4096,
        .crt_bundle_attach = esp_crt_bundle_attach,  /* 公共 CA 包 */
    };
    /* ... open / fetch headers / 检查 200；任何失败路径都要 iot_ota_verify_abort(verify) ... */

    esp_ota_handle_t handle;
    esp_ota_begin(part, OTA_WITH_SEQUENTIAL_WRITES, &handle);

    while ((n = esp_http_client_read(client, buf, sizeof(buf))) > 0) {
        if (verify != NULL) {
            iot_ota_verify_update(verify, (const uint8_t *)buf, n);  /* 与写入数据一致 */
        }
        esp_ota_write(handle, buf, n);                               /* 逐块写入 */
    }

    /* 切分区前校验云端摘要；不匹配则 esp_ota_abort 放弃 */
    if (verify != NULL) {
        vrc = iot_ota_verify_finish(verify);   /* 内部释放 verify */
        if (vrc != OPRT_OK) {
            ESP_LOGE(TAG, "Firmware digest mismatch (rc=%d)", vrc);
            esp_ota_abort(handle);
            return ESP_FAIL;
        }
    }

    esp_ota_end(handle);
    esp_ota_set_boot_partition(part);    /* 切换启动分区 */
    return ESP_OK;
}

static void mark_current_valid(void)
{
    const esp_partition_t *running = esp_ota_get_running_partition();
    esp_ota_img_states_t state;
    if (esp_ota_get_state_partition(running, &state) == ESP_OK
        && state == ESP_OTA_IMG_PENDING_VERIFY) {
        esp_ota_mark_app_valid_cancel_rollback();
    }
}