Crash_Override/OVMS3-idf
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
OVMS3-idf/components/esp_http_client/esp_http_client.c
Ivan Grokhotkov 9ab70d5379 Merge branch 'bugfix/http_write_data' into 'master' 
esp_http_client: Fix minor bugs in `esp_http_client_write` and `esp_http_client_open` APIs

See merge request idf/esp-idf!2924
2018-08-22 16:49:29 +08:00

1037 lines
37 KiB
C
Raw Blame History

// Copyright 2015-2018 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <string.h>
#include "esp_system.h"
#include "esp_log.h"
#include "http_header.h"
#include "transport.h"
#include "transport_tcp.h"
#include "http_utils.h"
#include "http_auth.h"
#include "sdkconfig.h"
#include "transport.h"
#include "esp_http_client.h"
#ifdef CONFIG_ESP_HTTP_CLIENT_ENABLE_HTTPS
#include "transport_ssl.h"
#endif
static const char *TAG = "HTTP_CLIENT";
/**
* HTTP Buffer
*/
typedef struct {
char *data; /*!< The HTTP data received from the server */
int len; /*!< The HTTP data len received from the server */
char *raw_data; /*!< The HTTP data after decoding */
int raw_len; /*!< The HTTP data len after decoding */
char *output_ptr; /*!< The destination address of the data to be copied to after decoding */
} esp_http_buffer_t;
/**
* private HTTP Data structure
*/
typedef struct {
http_header_handle_t headers; /*!< http header */
esp_http_buffer_t *buffer; /*!< data buffer as linked list */
int status_code; /*!< status code (integer) */
int content_length; /*!< data length */
int data_offset; /*!< offset to http data (Skip header) */
int data_process; /*!< data processed */
int method; /*!< http method */
bool is_chunked;
} esp_http_data_t;
typedef struct {
char *url;
char *scheme;
char *host;
int port;
char *username;
char *password;
char *path;
char *query;
char *cert_pem;
esp_http_client_method_t method;
esp_http_client_auth_type_t auth_type;
esp_http_client_transport_t transport_type;
int max_store_header_size;
} connection_info_t;
typedef enum {
HTTP_STATE_UNINIT = 0,
HTTP_STATE_INIT,
HTTP_STATE_CONNECTED,
HTTP_STATE_REQ_COMPLETE_HEADER,
HTTP_STATE_REQ_COMPLETE_DATA,
HTTP_STATE_RES_COMPLETE_HEADER,
HTTP_STATE_RES_COMPLETE_DATA,
HTTP_STATE_CLOSE
} esp_http_state_t;
/**
* HTTP client class
*/
struct esp_http_client {
int redirect_counter;
int max_redirection_count;
int process_again;
struct http_parser *parser;
struct http_parser_settings *parser_settings;
transport_list_handle_t transport_list;
transport_handle_t transport;
esp_http_data_t *request;
esp_http_data_t *response;
void *user_data;
esp_http_auth_data_t *auth_data;
char *post_data;
char *location;
char *auth_header;
char *current_header_key;
char *current_header_value;
int post_len;
connection_info_t connection_info;
bool is_chunk_complete;
esp_http_state_t state;
http_event_handle_cb event_handler;
int timeout_ms;
int buffer_size;
bool disable_auto_redirect;
esp_http_client_event_t event;
};
typedef struct esp_http_client esp_http_client_t;
static esp_err_t _clear_connection_info(esp_http_client_handle_t client);
/**
* Default settings
*/
#define DEFAULT_HTTP_PORT (80)
#define DEFAULT_HTTPS_PORT (443)
static const char *DEFAULT_HTTP_USER_AGENT = "ESP32 HTTP Client/1.0";
static const char *DEFAULT_HTTP_PROTOCOL = "HTTP/1.1";
static const char *DEFAULT_HTTP_PATH = "/";
static int DEFAULT_MAX_REDIRECT = 10;
static int DEFAULT_TIMEOUT_MS = 5000;
static const char *HTTP_METHOD_MAPPING[] = {
"GET",
"POST",
"PUT",
"PATCH",
"DELETE",
"HEAD"
};
/**
* Enum for the HTTP status codes.
*/
enum HttpStatus_Code
{
/* 3xx - Redirection */
HttpStatus_MovedPermanently = 301,
HttpStatus_Found = 302,
/* 4xx - Client Error */
HttpStatus_Unauthorized = 401
};
static esp_err_t http_dispatch_event(esp_http_client_t *client, esp_http_client_event_id_t event_id, void *data, int len)
{
esp_http_client_event_t *event = &client->event;
if (client->event_handler) {
event->event_id = event_id;
event->user_data = client->user_data;
event->data = data;
event->data_len = len;
return client->event_handler(event);
}
return ESP_OK;
}
static int http_on_message_begin(http_parser *parser)
{
esp_http_client_t *client = parser->data;
ESP_LOGD(TAG, "on_message_begin");
client->response->is_chunked = false;
client->is_chunk_complete = false;
return 0;
}
static int http_on_url(http_parser *parser, const char *at, size_t length)
{
ESP_LOGD(TAG, "http_on_url");
return 0;
}
static int http_on_status(http_parser *parser, const char *at, size_t length)
{
return 0;
}
static int http_on_header_field(http_parser *parser, const char *at, size_t length)
{
esp_http_client_t *client = parser->data;
http_utils_assign_string(&client->current_header_key, at, length);
return 0;
}
static int http_on_header_value(http_parser *parser, const char *at, size_t length)
{
esp_http_client_handle_t client = parser->data;
if (client->current_header_key == NULL) {
return 0;
}
if (strcasecmp(client->current_header_key, "Location") == 0) {
http_utils_assign_string(&client->location, at, length);
} else if (strcasecmp(client->current_header_key, "Transfer-Encoding") == 0
&& memcmp(at, "chunked", length) == 0) {
client->response->is_chunked = true;
} else if (strcasecmp(client->current_header_key, "WWW-Authenticate") == 0) {
http_utils_assign_string(&client->auth_header, at, length);
}
http_utils_assign_string(&client->current_header_value, at, length);
ESP_LOGD(TAG, "HEADER=%s:%s", client->current_header_key, client->current_header_value);
client->event.header_key = client->current_header_key;
client->event.header_value = client->current_header_value;
http_dispatch_event(client, HTTP_EVENT_ON_HEADER, NULL, 0);
free(client->current_header_key);
free(client->current_header_value);
client->current_header_key = NULL;
client->current_header_value = NULL;
return 0;
}
static int http_on_headers_complete(http_parser *parser)
{
esp_http_client_handle_t client = parser->data;
client->response->status_code = parser->status_code;
client->response->data_offset = parser->nread;
client->response->content_length = parser->content_length;
client->response->data_process = 0;
ESP_LOGD(TAG, "http_on_headers_complete, status=%d, offset=%d, nread=%d", parser->status_code, client->response->data_offset, parser->nread);
client->state = HTTP_STATE_RES_COMPLETE_HEADER;
return 0;
}
static int http_on_body(http_parser *parser, const char *at, size_t length)
{
esp_http_client_t *client = parser->data;
ESP_LOGD(TAG, "http_on_body %d", length);
client->response->buffer->raw_data = (char *)at;
if (client->response->buffer->output_ptr) {
memcpy(client->response->buffer->output_ptr, (char *)at, length);
client->response->buffer->output_ptr += length;
}
client->response->data_process += length;
client->response->buffer->raw_len += length;
http_dispatch_event(client, HTTP_EVENT_ON_DATA, (void *)at, length);
return 0;
}
static int http_on_message_complete(http_parser *parser)
{
ESP_LOGD(TAG, "http_on_message_complete, parser=%x", (int)parser);
esp_http_client_handle_t client = parser->data;
client->is_chunk_complete = true;
return 0;
}
static int http_on_chunk_complete(http_parser *parser)
{
ESP_LOGD(TAG, "http_on_chunk_complete");
return 0;
}
esp_err_t esp_http_client_set_header(esp_http_client_handle_t client, const char *key, const char *value)
{
return http_header_set(client->request->headers, key, value);
}
esp_err_t esp_http_client_get_header(esp_http_client_handle_t client, const char *key, char **value)
{
return http_header_get(client->request->headers, key, value);
}
esp_err_t esp_http_client_delete_header(esp_http_client_handle_t client, const char *key)
{
return http_header_delete(client->request->headers, key);
}
static esp_err_t _set_config(esp_http_client_handle_t client, const esp_http_client_config_t *config)
{
client->connection_info.method = config->method;
client->connection_info.port = config->port;
client->connection_info.auth_type = config->auth_type;
client->event_handler = config->event_handler;
client->timeout_ms = config->timeout_ms;
client->max_redirection_count = config->max_redirection_count;
client->user_data = config->user_data;
client->buffer_size = config->buffer_size;
client->disable_auto_redirect = config->disable_auto_redirect;
if (config->buffer_size == 0) {
client->buffer_size = DEFAULT_HTTP_BUF_SIZE;
}
if (client->max_redirection_count == 0) {
client->max_redirection_count = DEFAULT_MAX_REDIRECT;
}
if (config->path) {
client->connection_info.path = strdup(config->path);
} else {
client->connection_info.path = strdup(DEFAULT_HTTP_PATH);
}
HTTP_MEM_CHECK(TAG, client->connection_info.path, {
return ESP_ERR_NO_MEM;
});
if (config->host) {
client->connection_info.host = strdup(config->host);
HTTP_MEM_CHECK(TAG, client->connection_info.host, {
_clear_connection_info(client);
return ESP_ERR_NO_MEM;
});
}
if (config->query) {
client->connection_info.query = strdup(config->query);
HTTP_MEM_CHECK(TAG, client->connection_info.query, {
_clear_connection_info(client);
return ESP_ERR_NO_MEM;
});
}
if (config->username) {
client->connection_info.username = strdup(config->username);
HTTP_MEM_CHECK(TAG, client->connection_info.username, {
_clear_connection_info(client);
return ESP_ERR_NO_MEM;
});
}
if (config->password) {
client->connection_info.password = strdup(config->password);
HTTP_MEM_CHECK(TAG, client->connection_info.password, {
_clear_connection_info(client);
return ESP_ERR_NO_MEM;
});
}
if (config->transport_type == HTTP_TRANSPORT_OVER_SSL) {
http_utils_assign_string(&client->connection_info.scheme, "https", 0);
if (client->connection_info.port == 0) {
client->connection_info.port = DEFAULT_HTTPS_PORT;
}
} else {
http_utils_assign_string(&client->connection_info.scheme, "http", 0);
if (client->connection_info.port == 0) {
client->connection_info.port = DEFAULT_HTTP_PORT;
}
}
if (client->timeout_ms == 0) {
client->timeout_ms = DEFAULT_TIMEOUT_MS;
}
return ESP_OK;
}
static esp_err_t _clear_connection_info(esp_http_client_handle_t client)
{
free(client->connection_info.path);
free(client->connection_info.host);
free(client->connection_info.query);
free(client->connection_info.username);
if (client->connection_info.password) {
memset(client->connection_info.password, 0, strlen(client->connection_info.password));
free(client->connection_info.password);
}
free(client->connection_info.scheme);
free(client->connection_info.url);
memset(&client->connection_info, 0, sizeof(connection_info_t));
return ESP_OK;
}
static esp_err_t _clear_auth_data(esp_http_client_handle_t client)
{
if (client->auth_data == NULL) {
return ESP_FAIL;
}
free(client->auth_data->method);
free(client->auth_data->realm);
free(client->auth_data->algorithm);
free(client->auth_data->qop);
free(client->auth_data->nonce);
free(client->auth_data->opaque);
memset(client->auth_data, 0, sizeof(esp_http_auth_data_t));
return ESP_OK;
}
static esp_err_t esp_http_client_prepare(esp_http_client_handle_t client)
{
client->process_again = 0;
client->response->data_process = 0;
http_parser_init(client->parser, HTTP_RESPONSE);
if (client->connection_info.username) {
char *auth_response = NULL;
if (client->connection_info.auth_type == HTTP_AUTH_TYPE_BASIC) {
auth_response = http_auth_basic(client->connection_info.username, client->connection_info.password);
} else if (client->connection_info.auth_type == HTTP_AUTH_TYPE_DIGEST && client->auth_data) {
client->auth_data->uri = client->connection_info.path;
client->auth_data->cnonce = ((uint64_t)esp_random() << 32) + esp_random();
auth_response = http_auth_digest(client->connection_info.username, client->connection_info.password, client->auth_data);
client->auth_data->nc ++;
}
if (auth_response) {
ESP_LOGD(TAG, "auth_response=%s", auth_response);
esp_http_client_set_header(client, "Authorization", auth_response);
free(auth_response);
}
}
return ESP_OK;
}
esp_http_client_handle_t esp_http_client_init(const esp_http_client_config_t *config)
{
esp_http_client_handle_t client;
transport_handle_t tcp;
bool _success;
_success = (
(client = calloc(1, sizeof(esp_http_client_t))) &&
(client->parser = calloc(1, sizeof(struct http_parser))) &&
(client->parser_settings = calloc(1, sizeof(struct http_parser_settings))) &&
(client->auth_data = calloc(1, sizeof(esp_http_auth_data_t))) &&
(client->request = calloc(1, sizeof(esp_http_data_t))) &&
(client->request->headers = http_header_init()) &&
(client->request->buffer = calloc(1, sizeof(esp_http_buffer_t))) &&
(client->response = calloc(1, sizeof(esp_http_data_t))) &&
(client->response->headers = http_header_init()) &&
(client->response->buffer = calloc(1, sizeof(esp_http_buffer_t)))
);
if (!_success) {
ESP_LOGE(TAG, "Error allocate memory");
esp_http_client_cleanup(client);
return NULL;
}
_success = (
(client->transport_list = transport_list_init()) &&
(tcp = transport_tcp_init()) &&
(transport_set_default_port(tcp, DEFAULT_HTTP_PORT) == ESP_OK) &&
(transport_list_add(client->transport_list, tcp, "http") == ESP_OK)
);
if (!_success) {
ESP_LOGE(TAG, "Error initialize transport");
esp_http_client_cleanup(client);
return NULL;
}
#ifdef CONFIG_ESP_HTTP_CLIENT_ENABLE_HTTPS
transport_handle_t ssl;
_success = (
(ssl = transport_ssl_init()) &&
(transport_set_default_port(ssl, DEFAULT_HTTPS_PORT) == ESP_OK) &&
(transport_list_add(client->transport_list, ssl, "https") == ESP_OK)
);
if (!_success) {
ESP_LOGE(TAG, "Error initialize SSL Transport");
esp_http_client_cleanup(client);
return NULL;
}
if (config->cert_pem) {
transport_ssl_set_cert_data(ssl, config->cert_pem, strlen(config->cert_pem));
}
#endif
if (_set_config(client, config) != ESP_OK) {
ESP_LOGE(TAG, "Error set configurations");
esp_http_client_cleanup(client);
return NULL;
}
_success = (
(client->request->buffer->data = malloc(client->buffer_size)) &&
(client->response->buffer->data = malloc(client->buffer_size))
);
if (!_success) {
ESP_LOGE(TAG, "Allocation failed");
esp_http_client_cleanup(client);
return NULL;
}
_success = (
(esp_http_client_set_url(client, config->url) == ESP_OK) &&
(esp_http_client_set_header(client, "User-Agent", DEFAULT_HTTP_USER_AGENT) == ESP_OK) &&
(esp_http_client_set_header(client, "Host", client->connection_info.host) == ESP_OK)
);
if (!_success) {
ESP_LOGE(TAG, "Error set default configurations");
esp_http_client_cleanup(client);
return NULL;
}
client->parser_settings->on_message_begin = http_on_message_begin;
client->parser_settings->on_url = http_on_url;
client->parser_settings->on_status = http_on_status;
client->parser_settings->on_header_field = http_on_header_field;
client->parser_settings->on_header_value = http_on_header_value;
client->parser_settings->on_headers_complete = http_on_headers_complete;
client->parser_settings->on_body = http_on_body;
client->parser_settings->on_message_complete = http_on_message_complete;
client->parser_settings->on_chunk_complete = http_on_chunk_complete;
client->parser->data = client;
client->event.client = client;
client->state = HTTP_STATE_INIT;
return client;
}
esp_err_t esp_http_client_cleanup(esp_http_client_handle_t client)
{
if (client == NULL) {
return ESP_FAIL;
}
esp_http_client_close(client);
transport_list_destroy(client->transport_list);
http_header_destroy(client->request->headers);
free(client->request->buffer->data);
free(client->request->buffer);
free(client->request);
http_header_destroy(client->response->headers);
free(client->response->buffer->data);
free(client->response->buffer);
free(client->response);
free(client->parser);
free(client->parser_settings);
_clear_connection_info(client);
_clear_auth_data(client);
free(client->auth_data);
free(client->current_header_key);
free(client->location);
free(client->auth_header);
free(client);
return ESP_OK;
}
static esp_err_t esp_http_check_response(esp_http_client_handle_t client)
{
char *auth_header = NULL;
if (client->redirect_counter >= client->max_redirection_count || client->disable_auto_redirect) {
ESP_LOGE(TAG, "Error, reach max_redirection_count count=%d", client->redirect_counter);
return ESP_ERR_HTTP_MAX_REDIRECT;
}
switch (client->response->status_code) {
case HttpStatus_MovedPermanently:
case HttpStatus_Found:
ESP_LOGI(TAG, "Redirect to %s", client->location);
esp_http_client_set_url(client, client->location);
client->redirect_counter ++;
client->process_again = 1;
break;
case HttpStatus_Unauthorized:
auth_header = client->auth_header;
if (auth_header) {
http_utils_trim_whitespace(&auth_header);
ESP_LOGD(TAG, "UNAUTHORIZED: %s", auth_header);
client->redirect_counter ++;
if (http_utils_str_starts_with(auth_header, "Digest") == 0) {
ESP_LOGD(TAG, "type = Digest");
client->connection_info.auth_type = HTTP_AUTH_TYPE_DIGEST;
} else if (http_utils_str_starts_with(auth_header, "Basic") == 0) {
ESP_LOGD(TAG, "type = Basic");
client->connection_info.auth_type = HTTP_AUTH_TYPE_BASIC;
} else {
client->connection_info.auth_type = HTTP_AUTH_TYPE_NONE;
ESP_LOGE(TAG, "This authentication method is not supported: %s", auth_header);
break;
}
_clear_auth_data(client);
client->auth_data->method = strdup(HTTP_METHOD_MAPPING[client->connection_info.method]);
client->auth_data->nc = 1;
client->auth_data->realm = http_utils_get_string_between(auth_header, "realm=\"", "\"");
client->auth_data->algorithm = http_utils_get_string_between(auth_header, "algorithm=", ",");
client->auth_data->qop = http_utils_get_string_between(auth_header, "qop=\"", "\"");
client->auth_data->nonce = http_utils_get_string_between(auth_header, "nonce=\"", "\"");
client->auth_data->opaque = http_utils_get_string_between(auth_header, "opaque=\"", "\"");
client->process_again = 1;
} else {
client->connection_info.auth_type = HTTP_AUTH_TYPE_NONE;
ESP_LOGW(TAG, "This request requires authentication, but does not provide header information for that");
}
}
return ESP_OK;
}
esp_err_t esp_http_client_set_url(esp_http_client_handle_t client, const char *url)
{
char *old_host = NULL;
struct http_parser_url purl;
int old_port;
if (client == NULL || url == NULL) {
ESP_LOGE(TAG, "client or url must not NULL");
return ESP_ERR_INVALID_ARG;
}
http_parser_url_init(&purl);
int parser_status = http_parser_parse_url(url, strlen(url), 0, &purl);
if (parser_status != 0) {
ESP_LOGE(TAG, "Error parse url %s", url);
return ESP_ERR_INVALID_ARG;
}
old_host = client->connection_info.host;
old_port = client->connection_info.port;
if (purl.field_data[UF_HOST].len) {
http_utils_assign_string(&client->connection_info.host, url + purl.field_data[UF_HOST].off, purl.field_data[UF_HOST].len);
HTTP_MEM_CHECK(TAG, client->connection_info.host, return ESP_ERR_NO_MEM);
}
// Close the connection if host was changed
if (old_host && client->connection_info.host
&& strcasecmp(old_host, (const void *)client->connection_info.host) != 0) {
ESP_LOGD(TAG, "New host assign = %s", client->connection_info.host);
if (esp_http_client_set_header(client, "Host", client->connection_info.host) != ESP_OK) {
return ESP_ERR_NO_MEM;
}
esp_http_client_close(client);
}
if (purl.field_data[UF_SCHEMA].len) {
http_utils_assign_string(&client->connection_info.scheme, url + purl.field_data[UF_SCHEMA].off, purl.field_data[UF_SCHEMA].len);
HTTP_MEM_CHECK(TAG, client->connection_info.scheme, return ESP_ERR_NO_MEM);
if (strcasecmp(client->connection_info.scheme, "http") == 0) {
client->connection_info.port = DEFAULT_HTTP_PORT;
} else if (strcasecmp(client->connection_info.scheme, "https") == 0) {
client->connection_info.port = DEFAULT_HTTPS_PORT;
}
}
if (purl.field_data[UF_PORT].len) {
client->connection_info.port = strtol((const char*)(url + purl.field_data[UF_PORT].off), NULL, 10);
}
if (old_port != client->connection_info.port) {
esp_http_client_close(client);
}
if (purl.field_data[UF_USERINFO].len) {
char *user_info = NULL;
http_utils_assign_string(&user_info, url + purl.field_data[UF_USERINFO].off, purl.field_data[UF_USERINFO].len);
if (user_info) {
char *username = user_info;
char *password = strchr(user_info, ':');
if (password) {
*password = 0;
password ++;
http_utils_assign_string(&client->connection_info.password, password, 0);
HTTP_MEM_CHECK(TAG, client->connection_info.password, return ESP_ERR_NO_MEM);
}
http_utils_assign_string(&client->connection_info.username, username, 0);
HTTP_MEM_CHECK(TAG, client->connection_info.username, return ESP_ERR_NO_MEM);
free(user_info);
} else {
return ESP_ERR_NO_MEM;
}
} else {
free(client->connection_info.username);
free(client->connection_info.password);
client->connection_info.username = NULL;
client->connection_info.password = NULL;
}
//Reset path and query if there are no information
if (purl.field_data[UF_PATH].len) {
http_utils_assign_string(&client->connection_info.path, url + purl.field_data[UF_PATH].off, purl.field_data[UF_PATH].len);
} else {
http_utils_assign_string(&client->connection_info.path, "/", 0);
}
HTTP_MEM_CHECK(TAG, client->connection_info.path, return ESP_ERR_NO_MEM);
if (purl.field_data[UF_QUERY].len) {
http_utils_assign_string(&client->connection_info.query, url + purl.field_data[UF_QUERY].off, purl.field_data[UF_QUERY].len);
HTTP_MEM_CHECK(TAG, client->connection_info.query, return ESP_ERR_NO_MEM);
} else if (client->connection_info.query) {
free(client->connection_info.query);
client->connection_info.query = NULL;
}
return ESP_OK;
}
esp_err_t esp_http_client_set_method(esp_http_client_handle_t client, esp_http_client_method_t method)
{
client->connection_info.method = method;
return ESP_OK;
}
static int esp_http_client_get_data(esp_http_client_handle_t client)
{
if (client->state < HTTP_STATE_RES_COMPLETE_HEADER) {
return ESP_FAIL;
}
if (client->connection_info.method == HTTP_METHOD_HEAD) {
return 0;
}
esp_http_buffer_t *res_buffer = client->response->buffer;
ESP_LOGD(TAG, "data_process=%d, content_length=%d", client->response->data_process, client->response->content_length);
int rlen = transport_read(client->transport, res_buffer->data, client->buffer_size, client->timeout_ms);
if (rlen >= 0) {
http_parser_execute(client->parser, client->parser_settings, res_buffer->data, rlen);
}
return rlen;
}
int esp_http_client_read(esp_http_client_handle_t client, char *buffer, int len)
{
esp_http_buffer_t *res_buffer = client->response->buffer;
int rlen = ESP_FAIL, ridx = 0;
if (res_buffer->raw_len) {
int remain_len = client->response->buffer->raw_len;
if (remain_len > len) {
remain_len = len;
}
memcpy(buffer, res_buffer->raw_data, remain_len);
res_buffer->raw_len -= remain_len;
res_buffer->raw_data += remain_len;
ridx = remain_len;
}
int need_read = len - ridx;
bool is_data_remain = true;
while (need_read > 0 && is_data_remain) {
if (client->response->is_chunked) {
is_data_remain = !client->is_chunk_complete;
} else {
is_data_remain = client->response->data_process < client->response->content_length;
}
ESP_LOGD(TAG, "is_data_remain=%d, is_chunked=%d", is_data_remain, client->response->is_chunked);
if (!is_data_remain) {
break;
}
int byte_to_read = need_read;
if (byte_to_read > client->buffer_size) {
byte_to_read = client->buffer_size;
}
rlen = transport_read(client->transport, res_buffer->data, byte_to_read, client->timeout_ms);
ESP_LOGD(TAG, "need_read=%d, byte_to_read=%d, rlen=%d, ridx=%d", need_read, byte_to_read, rlen, ridx);
if (rlen <= 0) {
return ridx;
}
res_buffer->output_ptr = buffer + ridx;
http_parser_execute(client->parser, client->parser_settings, res_buffer->data, rlen);
ridx += res_buffer->raw_len;
need_read -= res_buffer->raw_len;
res_buffer->raw_len = 0; //clear
res_buffer->output_ptr = NULL;
}
return ridx;
}
esp_err_t esp_http_client_perform(esp_http_client_handle_t client)
{
esp_err_t err;
if (client == NULL) {
return ESP_ERR_INVALID_ARG;
}
do {
if ((err = esp_http_client_open(client, client->post_len)) != ESP_OK) {
return err;
}
if (client->post_data && client->post_len) {
if (esp_http_client_write(client, client->post_data, client->post_len) <= 0) {
ESP_LOGE(TAG, "Error upload data");
return ESP_ERR_HTTP_WRITE_DATA;
}
}
if (esp_http_client_fetch_headers(client) < 0) {
return ESP_ERR_HTTP_FETCH_HEADER;
}
if ((err = esp_http_check_response(client)) != ESP_OK) {
ESP_LOGE(TAG, "Error response");
return err;
}
while (client->response->is_chunked && !client->is_chunk_complete) {
if (esp_http_client_get_data(client) <= 0) {
ESP_LOGD(TAG, "Read finish or server requests close");
break;
}
}
while (client->response->data_process < client->response->content_length) {
if (esp_http_client_get_data(client) <= 0) {
ESP_LOGD(TAG, "Read finish or server requests close");
break;
}
}
http_dispatch_event(client, HTTP_EVENT_ON_FINISH, NULL, 0);
if (!http_should_keep_alive(client->parser)) {
ESP_LOGD(TAG, "Close connection");
esp_http_client_close(client);
} else {
if (client->state > HTTP_STATE_CONNECTED) {
client->state = HTTP_STATE_CONNECTED;
}
}
} while (client->process_again);
return ESP_OK;
}
int esp_http_client_fetch_headers(esp_http_client_handle_t client)
{
if (client->state < HTTP_STATE_REQ_COMPLETE_HEADER) {
return ESP_FAIL;
}
client->state = HTTP_STATE_REQ_COMPLETE_DATA;
esp_http_buffer_t *buffer = client->response->buffer;
client->response->status_code = -1;
while (client->state < HTTP_STATE_RES_COMPLETE_HEADER) {
buffer->len = transport_read(client->transport, buffer->data, client->buffer_size, client->timeout_ms);
if (buffer->len <= 0) {
return ESP_FAIL;
}
http_parser_execute(client->parser, client->parser_settings, buffer->data, buffer->len);
}
ESP_LOGD(TAG, "content_length = %d", client->response->content_length);
if (client->response->content_length <= 0) {
client->response->is_chunked = true;
return 0;
}
return client->response->content_length;
}
esp_err_t esp_http_client_open(esp_http_client_handle_t client, int write_len)
{
esp_err_t err;
if (client->state == HTTP_STATE_UNINIT) {
ESP_LOGE(TAG, "Client has not been initialized");
return ESP_ERR_INVALID_STATE;
}
if ((err = esp_http_client_prepare(client)) != ESP_OK) {
ESP_LOGE(TAG, "Failed to initialize request data");
esp_http_client_close(client);
return err;
}
if (client->state < HTTP_STATE_CONNECTED) {
ESP_LOGD(TAG, "Begin connect to: %s://%s:%d", client->connection_info.scheme, client->connection_info.host, client->connection_info.port);
client->transport = transport_list_get_transport(client->transport_list, client->connection_info.scheme);
if (client->transport == NULL) {
ESP_LOGE(TAG, "No transport found");
#ifndef CONFIG_ESP_HTTP_CLIENT_ENABLE_HTTPS
if (strcasecmp(client->connection_info.scheme, "https") == 0) {
ESP_LOGE(TAG, "Please enable HTTPS at menuconfig to allow requesting via https");
}
#endif
return ESP_ERR_HTTP_INVALID_TRANSPORT;
}
if (transport_connect(client->transport, client->connection_info.host, client->connection_info.port, client->timeout_ms) < 0) {
ESP_LOGE(TAG, "Connection failed");
return ESP_ERR_HTTP_CONNECT;
}
http_dispatch_event(client, HTTP_EVENT_ON_CONNECTED, NULL, 0);
client->state = HTTP_STATE_CONNECTED;
}
if (write_len >= 0) {
http_header_set_format(client->request->headers, "Content-Length", "%d", write_len);
} else if (write_len < 0) {
esp_http_client_set_header(client, "Transfer-Encoding", "chunked");
esp_http_client_set_method(client, HTTP_METHOD_POST);
}
int header_index = 0;
int wlen = client->buffer_size;
const char *method = HTTP_METHOD_MAPPING[client->connection_info.method];
int first_line = snprintf(client->request->buffer->data,
client->buffer_size, "%s %s",
method,
client->connection_info.path);
if (first_line > client->buffer_size) {
ESP_LOGE(TAG, "Out of buffer");
return ESP_ERR_HTTP_CONNECT;
}
if (client->connection_info.query) {
first_line += snprintf(client->request->buffer->data + first_line,
client->buffer_size - first_line, "?%s", client->connection_info.query);
if (first_line > client->buffer_size) {
ESP_LOGE(TAG, "Out of buffer");
return ESP_ERR_HTTP_CONNECT;
}
}
first_line += snprintf(client->request->buffer->data + first_line,
client->buffer_size - first_line, " %s\r\n", DEFAULT_HTTP_PROTOCOL);
if (first_line > client->buffer_size) {
ESP_LOGE(TAG, "Out of buffer");
return ESP_ERR_HTTP_CONNECT;
}
wlen -= first_line;
while ((header_index = http_header_generate_string(client->request->headers, header_index, client->request->buffer->data + first_line, &wlen))) {
if (wlen <= 0) {
break;
}
if (first_line) {
wlen += first_line;
first_line = 0;
}
client->request->buffer->data[wlen] = 0;
ESP_LOGD(TAG, "Write header[%d]: %s", header_index, client->request->buffer->data);
int widx = 0, wret = 0;
while (wlen > 0) {
wret = transport_write(client->transport, client->request->buffer->data + widx, wlen, client->timeout_ms);
if (wret <= 0) {
ESP_LOGE(TAG, "Error write request");
esp_http_client_close(client);
return ESP_ERR_HTTP_WRITE_DATA;
}
widx += wret;
wlen -= wret;
}
wlen = client->buffer_size;
}
client->state = HTTP_STATE_REQ_COMPLETE_HEADER;
return ESP_OK;
}
int esp_http_client_write(esp_http_client_handle_t client, const char *buffer, int len)
{
if (client->state < HTTP_STATE_REQ_COMPLETE_HEADER) {
return ESP_FAIL;
}
int wlen = 0, widx = 0;
while (len > 0) {
wlen = transport_write(client->transport, buffer + widx, len, client->timeout_ms);
if (wlen <= 0) {
return wlen;
}
widx += wlen;
len -= wlen;
}
return widx;
}
esp_err_t esp_http_client_close(esp_http_client_handle_t client)
{
if (client->state >= HTTP_STATE_INIT) {
http_dispatch_event(client, HTTP_EVENT_DISCONNECTED, NULL, 0);
client->state = HTTP_STATE_INIT;
return transport_close(client->transport);
}
return ESP_OK;
}
esp_err_t esp_http_client_set_post_field(esp_http_client_handle_t client, const char *data, int len)
{
esp_err_t err = ESP_OK;
client->post_data = (char *)data;
client->post_len = len;
ESP_LOGD(TAG, "set post file length = %d", len);
if (client->post_data) {
char *value = NULL;
if ((err = esp_http_client_get_header(client, "Content-Type", &value)) != ESP_OK) {
return err;
}
if (value == NULL) {
err = esp_http_client_set_header(client, "Content-Type", "application/x-www-form-urlencoded");
}
} else {
client->post_len = 0;
err = esp_http_client_set_header(client, "Content-Type", NULL);
}
return err;
}
int esp_http_client_get_post_field(esp_http_client_handle_t client, char **data)
{
if (client->post_data) {
*data = client->post_data;
return client->post_len;
}
return 0;
}
int esp_http_client_get_status_code(esp_http_client_handle_t client)
{
return client->response->status_code;
}
int esp_http_client_get_content_length(esp_http_client_handle_t client)
{
return client->response->content_length;
}
bool esp_http_client_is_chunked_response(esp_http_client_handle_t client)
{
return client->response->is_chunked;
}
esp_http_client_transport_t esp_http_client_get_transport_type(esp_http_client_handle_t client)
{
if (!strcmp(client->connection_info.scheme, "https") ) {
return HTTP_TRANSPORT_OVER_SSL;
} else if (!strcmp(client->connection_info.scheme, "http")) {
return HTTP_TRANSPORT_OVER_TCP;
} else {
return HTTP_TRANSPORT_UNKNOWN;
}
}
Reference in a new issue View git blame Copy permalink