Merge branch 'feature/support_redirect' into 'main'

Refine HTTP request to support redirection and options

See merge request adf/esp-webrtc-solution!46

Author: TempoTian

components/esp_webrtc/impl/apprtc_signal/https_client.c

@@ -26,6 +26,7 @@
 #include <string.h>
 #include "esp_log.h"
 #include "https_client.h"
+#include "https_client_utils.h"
 #include "esp_tls.h"
 #include <sdkconfig.h>
 #ifdef CONFIG_MBEDTLS_CERTIFICATE_BUNDLE
@@ -36,12 +37,19 @@
 static const char *TAG = "HTTPS_CLIENT";
 
 typedef struct {
-    http_header_t header;
-    http_body_t   body;
-    uint8_t      *data;
-    int           fill_size;
-    int           size;
-    void         *ctx;
+    const char *location;
+    const char *auth;
+    const char *cookie;
+} http_resp_keep_t;
+
+typedef struct {
+    http_header_t    header;
+    http_body_t      body;
+    http_resp_keep_t resp_keep;
+    uint8_t         *data;
+    int              fill_size;
+    int              size;
+    void            *ctx;
 } http_info_t;
 
 esp_err_t _http_event_handler(esp_http_client_event_t *evt)
@@ -61,6 +69,13 @@ esp_err_t _http_event_handler(esp_http_client_event_t *evt)
             break;
         case HTTP_EVENT_ON_HEADER:
             if (info->header) {
+                if (strcmp(evt->header_key, "Location") == 0) {
+                    info->resp_keep.location = strdup(evt->header_value);
+                } else if (strcmp(evt->header_key, "Authorization") == 0) {
+                    info->resp_keep.auth = strdup(evt->header_value);
+                } else if (strcmp(evt->header_key, "Set-Cookie") == 0) {
+                    info->resp_keep.cookie = strdup(evt->header_value);
+                }
                 info->header(evt->header_key, evt->header_value, info->ctx);
             }
             ESP_LOGD(TAG, "HTTP_EVENT_ON_HEADER, key=%s, value=%s", evt->header_key,
@@ -102,87 +117,220 @@ esp_err_t _http_event_handler(esp_http_client_event_t *evt)
                 ESP_LOGD(TAG, "Last mbedtls failure: 0x%x", mbedtls_err);
             }
             break;
-        case HTTP_EVENT_REDIRECT:
-            esp_http_client_set_redirection(evt->client);
-            break;
     }
     return ESP_OK;
 }
 
-int https_send_request(const char *method, char **headers, const char *url, char *data, http_header_t header_cb, http_body_t body, void *ctx)
+static int https_handle_redirect(esp_http_client_handle_t client, https_request_t *req, http_resp_keep_t *resp, char **last_url)
+{
+    if (resp->location == NULL) {
+        ESP_LOGE(TAG, "Redirect location not found");
+        return -1;
+    }
+    int status_code = esp_http_client_get_status_code(client);
+    if (!(status_code == 307 || status_code == 308)) {
+        esp_http_client_set_post_field(client, NULL, 0);
+        esp_http_client_set_method(client, HTTP_METHOD_GET);
+    }
+    char *full_url = strdup(resp->location);
+    if (full_url == NULL) {
+        return -1;
+    }
+    if (strncmp(resp->location , "http", 4) != 0) {
+        full_url = join_url(*last_url, resp->location);
+        if (full_url == NULL) {
+            return -1;
+        }
+    }
+    // Handle auth
+    if (resp->auth) {
+        // Only valid when origin same
+        if (is_same_origin(*last_url, full_url)) {
+            esp_http_client_set_header(client, "Authorization", resp->auth);
+        } else {
+            esp_http_client_set_header(client, "Authorization", NULL);
+        }
+    }
+    // Handle cookie
+    if (resp->cookie != NULL) {
+        esp_http_client_set_header(client, "Cookie", resp->cookie);
+    }
+    // Store to last url
+    if (*last_url != req->url) {
+        free(*last_url);
+    }
+    *last_url = full_url;
+    ESP_LOGI(TAG, "Redirect to: %s %p\n", full_url, full_url);
+    esp_http_client_set_url(client, full_url);
+    return 0;
+}
+
+static void free_resp_header(http_resp_keep_t *resp)
+{
+    if (resp->location) {
+        free((void *)resp->location);
+        resp->location = NULL;
+    }
+    if (resp->auth) {
+        free((void *)resp->auth);
+        resp->auth = NULL;
+    }
+    if (resp->cookie) {
+        free((void *)resp->cookie);
+        resp->cookie = NULL;
+    }
+}
+
+int https_request_advance(https_request_cfg_t *cfg, https_request_t *req)
 {
+    https_request_cfg_t default_cfg = {
+        .timeout_ms = DEFAULT_HTTPS_TIMEOUT,
+        .max_redirects = DEFAULT_HTTPS_MAX_REDIRECTS,
+        .buffer_size = DEFAULT_HTTPS_HEAD_SIZE,
+        .buffer_size_tx = DEFAULT_HTTPS_TX_SIZE,
+        .keep_alive_enable = DEFAULT_HTTPS_KEEP_ALIVE_ENABLE,
+        .keep_alive_count = DEFAULT_HTTPS_KEEP_ALIVE_COUNT,
+        .keep_alive_idle = DEFAULT_HTTPS_KEEP_ALIVE_IDLE,
+        .keep_alive_interval = DEFAULT_HTTPS_KEEP_ALIVE_INTERVAL,
+    };
+    if (cfg == NULL) {
+        cfg = &default_cfg;
+    }
     http_info_t info = {
-        .body = body,
-        .header = header_cb,
-        .ctx = ctx,
+        .body = req->body_cb,
+        .header = req->header_cb,
+        .ctx = req->ctx,
     };
-    esp_http_client_config_t config = {
-        .url = url,
+    esp_http_client_config_t http_config = {
+        .url = req->url,
         .event_handler = _http_event_handler,
 #ifdef CONFIG_MBEDTLS_CERTIFICATE_BUNDLE
         .crt_bundle_attach = esp_crt_bundle_attach,
 #endif
+        .timeout_ms = cfg->timeout_ms ? cfg->timeout_ms : default_cfg.timeout_ms,
+        .buffer_size = cfg->buffer_size ? cfg->buffer_size : default_cfg.buffer_size,
+        .buffer_size_tx = cfg->buffer_size_tx ? cfg->buffer_size_tx : default_cfg.buffer_size_tx,
+        .disable_auto_redirect = true, // Handle redirects manually
+        .keep_alive_enable = cfg->keep_alive_enable,
+        .keep_alive_idle = cfg->keep_alive_idle,
+        .keep_alive_interval = cfg->keep_alive_interval,
+        .keep_alive_count = cfg->keep_alive_count,
         .user_data = &info,
-        .timeout_ms = 10000, // Change default timeout to be 10s
     };
-    esp_http_client_handle_t client = esp_http_client_init(&config);
+    esp_http_client_handle_t client = esp_http_client_init(&http_config);
     if (client == NULL) {
         ESP_LOGE(TAG, "Fail to init client");
         return -1;
     }
     // POST
     int err = 0;
-    esp_http_client_set_url(client, url);
-    if (strcmp(method, "POST") == 0) {
+    char *last_url = (char*)req->url;
+    esp_http_client_set_url(client, req->url);
+    if (strcmp(req->method, "POST") == 0) {
         esp_http_client_set_method(client, HTTP_METHOD_POST);
-    } else if (strcmp(method, "DELETE") == 0) {
+    } else if (strcmp(req->method, "DELETE") == 0) {
         esp_http_client_set_method(client, HTTP_METHOD_DELETE);
-    } else if (strcmp(method, "PATCH") == 0) {
+    } else if (strcmp(req->method, "PATCH") == 0) {
         esp_http_client_set_method(client, HTTP_METHOD_PATCH);
+    } else if (strcmp(req->method, "GET") == 0) {
+        esp_http_client_set_method(client, HTTP_METHOD_GET);
     } else {
         err = -1;
         goto _exit;
     }
+
     bool has_content_type = false;
-    if (headers) {
+    uint8_t redirect_limit = cfg->max_redirects ? cfg->max_redirects : DEFAULT_HTTPS_MAX_REDIRECTS;
+    uint8_t redirect_count = 0;
+    const char *post_data = req->data;
+    if (req->headers) {
         int i = 0;
         // TODO suppose header writable
-        while (headers[i]) {
-            char *dot = strchr(headers[i], ':');
+        while (req->headers[i]) {
+            char *h = strdup(req->headers[i]);
+            if (h == NULL) {
+                continue;
+            }
+            char *dot = strchr(h, ':');
             if (dot) {
                 *dot = 0;
-                if (strcmp(headers[i], "Content-Type") == 0) {
+                if (strcmp(h, "Content-Type") == 0) {
                     has_content_type = true;
                 }
                 char *cont = dot + 2;
-                esp_http_client_set_header(client, headers[i], cont);
+                esp_http_client_set_header(client, h, cont);
                 *dot = ':';
             }
+            free(h);
             i++;
         }
     }
-    if (data != NULL) {
+    if (post_data != NULL) {
         if (has_content_type == false) {
             esp_http_client_set_header(client, "Content-Type", "text/plain;charset=UTF-8");
         }
-        esp_http_client_set_post_field(client, data, strlen(data));
+        esp_http_client_set_post_field(client, req->data, strlen(req->data));
     }
+RETRY_PERFORM:
+    if (info.data) {
+        free(info.data);
+        info.data = NULL;
+    }
+    info.fill_size = 0;
+    free_resp_header(&info.resp_keep);
+
     err = esp_http_client_perform(client);
     if (err == ESP_OK) {
-        ESP_LOGI(TAG, "HTTP POST Status = %d, content_length = %lld",
+        ESP_LOGI(TAG, "HTTP Status = %d, content_length = %lld",
                  esp_http_client_get_status_code(client),
                  esp_http_client_get_content_length(client));
+        int status_code = esp_http_client_get_status_code(client);
+        if (status_code >= 301 && status_code < 400) {
+            // Handle redirection
+            if (redirect_count >= redirect_limit) {
+                ESP_LOGE(TAG, "Redirect limit exceeded: %d", redirect_count);
+                err = -1;
+            } else {
+                err = https_handle_redirect(client, req, &info.resp_keep, &last_url);
+                if (!(status_code == 307 || status_code == 308)) {
+                    post_data = NULL;
+                }
+                redirect_count++;
+                if (err == 0) {
+                    goto RETRY_PERFORM;
+                }
+            }
+        }
     } else {
-        ESP_LOGE(TAG, "HTTP POST request failed: %s", esp_err_to_name(err));
+        ESP_LOGE(TAG, "HTTP %s request failed: %s", req->method, esp_err_to_name(err));
     }
 _exit:
-    esp_http_client_cleanup(client);
+    if (last_url != req->url) {
+        free(last_url);
+    }
+    free_resp_header(&info.resp_keep);
+    // Free Body
     if (info.data) {
         free(info.data);
     }
+    esp_http_client_cleanup(client);
     return err;
 }
 
+int https_send_request(const char *method, char **headers, const char *url, char *data, http_header_t header_cb, http_body_t body, void *ctx)
+{
+    https_request_t req = {
+        .method = method,
+        .url = url,
+        .headers = headers,
+        .data = data,
+        .header_cb = header_cb,
+        .body_cb = body,
+        .ctx = ctx,
+    };
+    return https_request_advance(NULL, &req);
+}
+
 int https_post(const char *url, char **headers, char *data, http_header_t header_cb, http_body_t body, void *ctx)
 {
     return https_send_request("POST", headers, url, data, header_cb, body, ctx);

components/esp_webrtc/impl/apprtc_signal/https_client.h

@@ -24,10 +24,21 @@
 
 #pragma once
 
+#include <stdbool.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+#define DEFAULT_HTTPS_TIMEOUT             10000
+#define DEFAULT_HTTPS_MAX_REDIRECTS       3
+#define DEFAULT_HTTPS_HEAD_SIZE           4096
+#define DEFAULT_HTTPS_TX_SIZE             4096
+#define DEFAULT_HTTPS_KEEP_ALIVE_ENABLE   true
+#define DEFAULT_HTTPS_KEEP_ALIVE_COUNT    3
+#define DEFAULT_HTTPS_KEEP_ALIVE_IDLE     5
+#define DEFAULT_HTTPS_KEEP_ALIVE_INTERVAL 3
+
 /**
  * @brief  Https response data
  */
@@ -53,6 +64,34 @@ typedef void (*http_body_t)(http_resp_t *resp, void *ctx);
  */
 typedef void (*http_header_t)(const char *key, const char *value, void *ctx);
 
+/**
+ * @brief  HTTP request configuration
+ *         These settings will bypass to `esp_http_client` or handled by this module internally
+ */
+typedef struct {
+    uint16_t  timeout_ms;          /*!< Connection timeout (unit milliseconds) */
+    uint8_t   max_redirects;       /*!< Maximum redirection limit */
+    uint16_t  buffer_size;         /*!< HTTP header buffer size */
+    uint16_t  buffer_size_tx;      /*!< HTTP send buffer size */
+    bool      keep_alive_enable;   /*!< Keep alive enable or not */
+    uint8_t   keep_alive_count;    /*!< Keep alive count */
+    uint16_t  keep_alive_idle;     /*!< Keep alive idle */
+    uint16_t  keep_alive_interval; /*!< Keep alive send interval */
+} https_request_cfg_t;
+
+/**
+ * @brief  HTTP request information
+ */
+typedef struct {
+    const char    *method;     /*!< HTTP method POST, GET, DELETE, PATCH etc */
+    const char    *url;        /*!< Request URL */
+    char         **headers;    /*!< HTTP headers Arrays of "Type: Info" */
+    char          *data;       /*!< Content data to send (special for post) */
+    http_header_t  header_cb;  /*!< Response header callback */
+    http_body_t    body_cb;    /*!< Response body callback */
+    void          *ctx;        /*!< Callback context */
+} https_request_t;
+
 /**
  * @brief  Send https requests
  *
@@ -75,7 +114,7 @@ int https_send_request(const char *method, char **headers, const char *url, char
 /**
  * @brief  Do post https request
  *
- * @note  This API will internally call `https_send_request`
+ * @note  This API will internally call `https_request_advance`
  *
  * @param[in]  url        HTTPS URL to post
  * @param[in]  headers    HTTP headers, headers are array of "Type: Info", last one need set to NULL
@@ -90,6 +129,20 @@ int https_send_request(const char *method, char **headers, const char *url, char
  */
 int https_post(const char *url, char **headers, char *data, http_header_t header_cb, http_body_t body, void *ctx);
 
+/**
+ * @brief  Set https request with advanced options
+ *
+ * @note  This API is run in synchronized until response or error returns
+ *
+ * @param[in]  cfg  Request HTTP configurations
+ * @param[in]  req  Request settings
+ *
+ * @return
+ *       - 0       On success
+ *       - Others  Fail to do https request
+ */
+int https_request_advance(https_request_cfg_t *cfg, https_request_t *req);
+
 #ifdef __cplusplus
 }
 #endif