toy-Kapi_Rtc/components/common/src/volc_http.c

// Copyright (2025) Beijing Volcano Engine Technology Ltd.
// SPDX-License-Identifier: Apache-2.0

#include "volc_http.h"

#include <string.h>
#include <esp_log.h>
#include <esp_http_client.h>
#include "volc_platform.h"
#include "esp_crt_bundle.h"

static const char* TAG = "VOLC_HTTP";

// Response data structure for event handler
typedef struct {
    char* buffer;
    size_t buffer_size;
    size_t total_read;
    size_t max_size;
} response_data_t;

// HTTP client event handler to capture response data
static esp_err_t http_event_handler(esp_http_client_event_t *evt)
{
    response_data_t *response_data = (response_data_t *)evt->user_data;
    
    switch (evt->event_id) {
        case HTTP_EVENT_ON_DATA:
            if (response_data && evt->data && evt->data_len > 0) {
                // Calculate available space in buffer
                size_t available = response_data->max_size - response_data->total_read;
                if (available > 0) {
                    // Copy data to buffer (don't exceed max size)
                    size_t copy_len = (evt->data_len < available) ? evt->data_len : available;
                    memcpy(response_data->buffer + response_data->total_read, evt->data, copy_len);
                    response_data->total_read += copy_len;
                    
                    ESP_LOGI(TAG, "HTTP_EVENT_ON_DATA: read %d bytes, total: %d", evt->data_len, response_data->total_read);
                }
            }
            break;
        default:
            break;
    }
    return ESP_OK;
}

char* volc_http_post(const char* uri, const char* post_data, int data_len)
{
    char* response_buffer = NULL;
    esp_http_client_handle_t client = NULL;
    int response_status = 0;
    esp_err_t err = ESP_OK;
    int attempts = 0;
    const int max_attempts = 3;
    
    if (!uri || !post_data || data_len <= 0) {
        ESP_LOGE(TAG, "Invalid parameters: uri=%p, post_data=%p, data_len=%d", uri, post_data, data_len);
        return NULL;
    }
    
    ESP_LOGD(TAG, "HTTP POST: uri=%s, post_data=%s, data_len=%d", uri, post_data, data_len);
    
    /* Perform HTTP request with retries */
    while (attempts < max_attempts) {
        ESP_LOGI(TAG, "HTTP POST attempt %d/%d", attempts + 1, max_attempts);
        
        /* Allocate buffer for response */
        const size_t max_response_size = 16384;  // 增加缓冲区大小到16KB，解决响应被截断的问题
        char *buffer = (char*)hal_malloc(max_response_size + 1);
        if (!buffer) {
            ESP_LOGE(TAG, "Failed to allocate buffer for response reading");
            goto cleanup_attempt;
        }
        
        memset(buffer, 0, max_response_size + 1);
        
        /* Initialize response data structure */
        response_data_t response_data = {
            .buffer = buffer,
            .buffer_size = max_response_size + 1,
            .total_read = 0,
            .max_size = max_response_size
        };
        
        /* Configure HTTP client with event handler */
        esp_http_client_config_t config = {
            .url = uri,
            .timeout_ms = 15000,
            .transport_type = HTTP_TRANSPORT_OVER_SSL,
            .crt_bundle_attach = esp_crt_bundle_attach,
            .skip_cert_common_name_check = true,
            .method = HTTP_METHOD_POST,
            .event_handler = http_event_handler,
            .user_data = &response_data,  // Pass response data to event handler
            .disable_auto_redirect = false,  // Enable redirects
            .max_redirection_count = 3,  // Allow up to 3 redirects
        };
        
        /* Initialize HTTP client */
        client = esp_http_client_init(&config);
        if (client == NULL) {
            ESP_LOGE(TAG, "Failed to initialize HTTP client");
            hal_free(buffer);
            goto cleanup_attempt;
        }
        
        /* Set content type to application/json */
        err = esp_http_client_set_header(client, "Content-Type", "application/json");
        if (err != ESP_OK) {
            ESP_LOGE(TAG, "Failed to set Content-Type header: %s", esp_err_to_name(err));
            goto cleanup_attempt;
        }
        
        /* Set POST data */
        err = esp_http_client_set_post_field(client, post_data, data_len);
        if (err != ESP_OK) {
            ESP_LOGE(TAG, "Failed to set POST field: %s", esp_err_to_name(err));
            goto cleanup_attempt;
        }
        
        /* Perform HTTP request */
        /* The event handler will capture response data */
        ESP_LOGI(TAG, "Performing HTTP request...");
        err = esp_http_client_perform(client);
        if (err != ESP_OK) {
            ESP_LOGE(TAG, "Failed to perform HTTP request: %s", esp_err_to_name(err));
            goto cleanup_attempt;
        }
        
        /* Get response status */
        response_status = esp_http_client_get_status_code(client);
        ESP_LOGI(TAG, "HTTP response status: %d", response_status);
        
        if (response_status == 200) {
            /* Get content length from response header */
            int64_t content_length = esp_http_client_get_content_length(client);
            ESP_LOGI(TAG, "Content-Length: %lld, actually read: %d", content_length, response_data.total_read);
            
            if (response_data.total_read > 0) {
                /* Ensure null termination */
                buffer[response_data.total_read] = '\0';
                
                ESP_LOGI(TAG, "Successfully read response: %d bytes", response_data.total_read);
                ESP_LOGD(TAG, "Response data: %s", buffer);
                
                /* Copy to final buffer */
                response_buffer = (char*)hal_malloc(response_data.total_read + 1);
                if (response_buffer) {
                    memcpy(response_buffer, buffer, response_data.total_read + 1);
                } else {
                    ESP_LOGE(TAG, "Failed to allocate final response buffer");
                }
            } else {
                ESP_LOGE(TAG, "Failed to read any response data via event handler");
                
                /* Try a fallback method - read directly after perform */
                ESP_LOGI(TAG, "Trying fallback: direct read after perform...");
                int fallback_read = esp_http_client_read_response(client, buffer, max_response_size);
                if (fallback_read > 0) {
                    ESP_LOGI(TAG, "Fallback successful: read %d bytes", fallback_read);
                    buffer[fallback_read] = '\0';
                    ESP_LOGD(TAG, "Response data: %s", buffer);
                    
                    response_buffer = (char*)hal_malloc(fallback_read + 1);
                    if (response_buffer) {
                        memcpy(response_buffer, buffer, fallback_read + 1);
                    }
                } else {
                    ESP_LOGE(TAG, "Fallback also failed: %d", fallback_read);
                }
            }
        } else {
            ESP_LOGW(TAG, "Non-200 status: %d", response_status);
        }
        
        cleanup_attempt:
        /* Clean up client and buffer */
        if (client != NULL) {
            esp_http_client_cleanup(client);
            client = NULL;
        }
        if (buffer != NULL) {
            hal_free(buffer);
            buffer = NULL;
        }
        
        /* If we got a response, break the retry loop */
        if (response_buffer) {
            break;
        }
        
        attempts++;
        if (attempts < max_attempts) {
            int backoff_ms = 500 * attempts;
            ESP_LOGI(TAG, "Retrying in %d ms...", backoff_ms);
            hal_thread_sleep(backoff_ms);
        }
    }
    
    if (attempts == max_attempts) {
        ESP_LOGE(TAG, "HTTP POST failed after %d attempts", max_attempts);
    }
    
    ESP_LOGI(TAG, "HTTP POST request completed, response_buffer=%p", response_buffer);
    return response_buffer;
}