724 lines
23 KiB
C++
724 lines
23 KiB
C++
#include "http_client.h"
|
||
#include "network_interface.h"
|
||
#include <esp_log.h>
|
||
#include <cstring>
|
||
#include <cstdlib>
|
||
#include <sstream>
|
||
#include <chrono>
|
||
#include <algorithm>
|
||
#include <cctype>
|
||
|
||
static const char *TAG = "HttpClient";
|
||
|
||
HttpClient::HttpClient(NetworkInterface* network, int connect_id) : network_(network), connect_id_(connect_id) {
|
||
event_group_handle_ = xEventGroupCreate();
|
||
}
|
||
|
||
HttpClient::~HttpClient() {
|
||
if (connected_) {
|
||
Close();
|
||
}
|
||
vEventGroupDelete(event_group_handle_);
|
||
}
|
||
|
||
void HttpClient::SetTimeout(int timeout_ms) {
|
||
timeout_ms_ = timeout_ms;
|
||
}
|
||
|
||
void HttpClient::SetHeader(const std::string& key, const std::string& value) {
|
||
// 转换key为小写用于存储和查找，但保留原始key用于输出
|
||
std::string lower_key = key;
|
||
std::transform(lower_key.begin(), lower_key.end(), lower_key.begin(), ::tolower);
|
||
headers_[lower_key] = HeaderEntry(key, value);
|
||
}
|
||
|
||
void HttpClient::SetContent(std::string&& content) {
|
||
content_ = std::move(content);
|
||
}
|
||
|
||
bool HttpClient::ParseUrl(const std::string& url) {
|
||
// 解析 URL: protocol://host:port/path
|
||
size_t protocol_end = url.find("://");
|
||
if (protocol_end == std::string::npos) {
|
||
ESP_LOGE(TAG, "Invalid URL format: %s", url.c_str());
|
||
return false;
|
||
}
|
||
|
||
protocol_ = url.substr(0, protocol_end);
|
||
std::transform(protocol_.begin(), protocol_.end(), protocol_.begin(), ::tolower);
|
||
|
||
size_t host_start = protocol_end + 3;
|
||
size_t path_start = url.find("/", host_start);
|
||
size_t port_start = url.find(":", host_start);
|
||
|
||
// 默认端口
|
||
if (protocol_ == "https") {
|
||
port_ = 443;
|
||
} else {
|
||
port_ = 80;
|
||
}
|
||
|
||
if (path_start == std::string::npos) {
|
||
path_ = "/";
|
||
if (port_start != std::string::npos) {
|
||
host_ = url.substr(host_start, port_start - host_start);
|
||
std::string port_str = url.substr(port_start + 1);
|
||
char* endptr;
|
||
long port = strtol(port_str.c_str(), &endptr, 10);
|
||
if (endptr != port_str.c_str() && *endptr == '\0' && port > 0 && port <= 65535) {
|
||
port_ = static_cast<int>(port);
|
||
} else {
|
||
ESP_LOGE(TAG, "Invalid port: %s", port_str.c_str());
|
||
return false;
|
||
}
|
||
} else {
|
||
host_ = url.substr(host_start);
|
||
}
|
||
} else {
|
||
path_ = url.substr(path_start);
|
||
if (port_start != std::string::npos && port_start < path_start) {
|
||
host_ = url.substr(host_start, port_start - host_start);
|
||
std::string port_str = url.substr(port_start + 1, path_start - port_start - 1);
|
||
char* endptr;
|
||
long port = strtol(port_str.c_str(), &endptr, 10);
|
||
if (endptr != port_str.c_str() && *endptr == '\0' && port > 0 && port <= 65535) {
|
||
port_ = static_cast<int>(port);
|
||
} else {
|
||
ESP_LOGE(TAG, "Invalid port: %s", port_str.c_str());
|
||
return false;
|
||
}
|
||
} else {
|
||
host_ = url.substr(host_start, path_start - host_start);
|
||
}
|
||
}
|
||
|
||
ESP_LOGD(TAG, "Parsed URL: protocol=%s, host=%s, port=%d, path=%s",
|
||
protocol_.c_str(), host_.c_str(), port_, path_.c_str());
|
||
return true;
|
||
}
|
||
|
||
std::string HttpClient::BuildHttpRequest() {
|
||
std::ostringstream request;
|
||
|
||
// 请求行
|
||
request << method_ << " " << path_ << " HTTP/1.1\r\n";
|
||
|
||
// Host 头
|
||
request << "Host: " << host_;
|
||
if ((protocol_ == "http" && port_ != 80) || (protocol_ == "https" && port_ != 443)) {
|
||
request << ":" << port_;
|
||
}
|
||
request << "\r\n";
|
||
|
||
// 用户自定义头部（使用原始key输出）
|
||
for (const auto& [lower_key, header_entry] : headers_) {
|
||
request << header_entry.original_key << ": " << header_entry.value << "\r\n";
|
||
}
|
||
|
||
// 内容相关头部（仅在用户未设置时添加）
|
||
bool user_set_content_length = headers_.find("content-length") != headers_.end();
|
||
bool user_set_transfer_encoding = headers_.find("transfer-encoding") != headers_.end();
|
||
bool has_content = content_.has_value() && !content_->empty();
|
||
if (has_content && !user_set_content_length) {
|
||
request << "Content-Length: " << content_->size() << "\r\n";
|
||
} else if ((method_ == "POST" || method_ == "PUT") && !user_set_content_length && !user_set_transfer_encoding) {
|
||
if (request_chunked_) {
|
||
request << "Transfer-Encoding: chunked\r\n";
|
||
} else {
|
||
request << "Content-Length: 0\r\n";
|
||
}
|
||
}
|
||
|
||
// 连接控制（仅在用户未设置时添加）
|
||
if (headers_.find("connection") == headers_.end()) {
|
||
request << "Connection: close\r\n";
|
||
}
|
||
|
||
// 结束头部
|
||
request << "\r\n";
|
||
ESP_LOGD(TAG, "HTTP request headers:\n%s", request.str().c_str());
|
||
|
||
// 请求体
|
||
if (has_content) {
|
||
request << *content_;
|
||
}
|
||
|
||
return request.str();
|
||
}
|
||
|
||
bool HttpClient::Open(const std::string& method, const std::string& url) {
|
||
method_ = method;
|
||
url_ = url;
|
||
|
||
// 重置状态
|
||
status_code_ = -1;
|
||
response_headers_.clear();
|
||
{
|
||
std::lock_guard<std::mutex> read_lock(read_mutex_);
|
||
body_chunks_.clear();
|
||
}
|
||
body_offset_ = 0;
|
||
content_length_ = 0;
|
||
total_body_received_ = 0;
|
||
eof_ = false;
|
||
headers_received_ = false;
|
||
response_chunked_ = false;
|
||
connection_error_ = false; // 重置连接错误状态
|
||
parse_state_ = ParseState::STATUS_LINE;
|
||
chunk_size_ = 0;
|
||
chunk_received_ = 0;
|
||
rx_buffer_.clear();
|
||
|
||
xEventGroupClearBits(event_group_handle_,
|
||
EC801E_HTTP_EVENT_HEADERS_RECEIVED |
|
||
EC801E_HTTP_EVENT_BODY_RECEIVED |
|
||
EC801E_HTTP_EVENT_ERROR |
|
||
EC801E_HTTP_EVENT_COMPLETE);
|
||
|
||
// 解析 URL
|
||
if (!ParseUrl(url)) {
|
||
return false;
|
||
}
|
||
|
||
// 建立 TCP 连接
|
||
if (protocol_ == "https") {
|
||
tcp_ = network_->CreateSsl(connect_id_);
|
||
} else {
|
||
tcp_ = network_->CreateTcp(connect_id_);
|
||
}
|
||
|
||
// 设置 TCP 数据接收回调
|
||
tcp_->OnStream([this](const std::string& data) {
|
||
OnTcpData(data);
|
||
});
|
||
|
||
// 设置 TCP 断开连接回调
|
||
tcp_->OnDisconnected([this]() {
|
||
OnTcpDisconnected();
|
||
});
|
||
if (!tcp_->Connect(host_, port_)) {
|
||
ESP_LOGE(TAG, "TCP connection failed");
|
||
return false;
|
||
}
|
||
|
||
connected_ = true;
|
||
request_chunked_ = (method_ == "POST" || method_ == "PUT") && !content_.has_value();
|
||
|
||
// 构建并发送 HTTP 请求
|
||
std::string http_request = BuildHttpRequest();
|
||
if (tcp_->Send(http_request) <= 0) {
|
||
ESP_LOGE(TAG, "Send HTTP request failed");
|
||
tcp_->Disconnect();
|
||
connected_ = false;
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
void HttpClient::Close() {
|
||
if (!connected_) {
|
||
return;
|
||
}
|
||
|
||
connected_ = false;
|
||
write_cv_.notify_all();
|
||
tcp_->Disconnect();
|
||
|
||
eof_ = true;
|
||
cv_.notify_all();
|
||
ESP_LOGD(TAG, "HTTP connection closed");
|
||
}
|
||
|
||
void HttpClient::OnTcpData(const std::string& data) {
|
||
std::lock_guard<std::mutex> lock(mutex_);
|
||
|
||
// 检查 body_chunks_ 大小，如果超过 8KB 且 heap 小于 32KB 则阻塞
|
||
{
|
||
std::unique_lock<std::mutex> read_lock(read_mutex_);
|
||
write_cv_.wait(read_lock, [this, size=data.size()] {
|
||
size_t total_size = size;
|
||
for (const auto& chunk : body_chunks_) {
|
||
total_size += chunk.data.size();
|
||
}
|
||
size_t free_heap = esp_get_free_heap_size();
|
||
return total_size < MAX_BODY_CHUNKS_SIZE || !connected_ || free_heap >= 32768;
|
||
});
|
||
}
|
||
|
||
rx_buffer_.append(data);
|
||
ProcessReceivedData();
|
||
cv_.notify_one();
|
||
}
|
||
|
||
void HttpClient::OnTcpDisconnected() {
|
||
std::lock_guard<std::mutex> lock(mutex_);
|
||
connected_ = false;
|
||
|
||
// 检查数据是否完整接收
|
||
if (headers_received_ && !IsDataComplete()) {
|
||
// 如果已接收头部但数据不完整，标记为连接错误
|
||
connection_error_ = true;
|
||
ESP_LOGE(TAG, "Connection closed prematurely, expected %u bytes but only received %u bytes",
|
||
content_length_, total_body_received_);
|
||
} else {
|
||
// 数据完整或还未开始接收响应体，正常结束
|
||
eof_ = true;
|
||
}
|
||
|
||
cv_.notify_all(); // 通知所有等待的读取操作
|
||
}
|
||
|
||
void HttpClient::ProcessReceivedData() {
|
||
while (!rx_buffer_.empty() && parse_state_ != ParseState::COMPLETE) {
|
||
switch (parse_state_) {
|
||
case ParseState::STATUS_LINE: {
|
||
if (!HasCompleteLine(rx_buffer_)) return; // 需要更多数据
|
||
|
||
std::string line = GetNextLine(rx_buffer_);
|
||
|
||
if (ParseStatusLine(line)) {
|
||
parse_state_ = ParseState::HEADERS;
|
||
} else {
|
||
SetError();
|
||
return;
|
||
}
|
||
break;
|
||
}
|
||
|
||
case ParseState::HEADERS: {
|
||
if (!HasCompleteLine(rx_buffer_)) return; // 需要更多数据
|
||
|
||
std::string line = GetNextLine(rx_buffer_);
|
||
|
||
// 检查是否为空行（头部结束标记）
|
||
// GetNextLine 已经移除了 \r，所以空行就是 empty()
|
||
if (line.empty()) {
|
||
// 检查是否为 chunked 编码
|
||
auto it = response_headers_.find("transfer-encoding");
|
||
if (it != response_headers_.end() &&
|
||
it->second.value.find("chunked") != std::string::npos) {
|
||
response_chunked_ = true;
|
||
parse_state_ = ParseState::CHUNK_SIZE;
|
||
} else {
|
||
parse_state_ = ParseState::BODY;
|
||
auto cl_it = response_headers_.find("content-length");
|
||
if (cl_it != response_headers_.end()) {
|
||
char* endptr;
|
||
unsigned long length = strtoul(cl_it->second.value.c_str(), &endptr, 10);
|
||
if (endptr != cl_it->second.value.c_str() && *endptr == '\0') {
|
||
content_length_ = static_cast<size_t>(length);
|
||
} else {
|
||
ESP_LOGE(TAG, "Invalid Content-Length: %s", cl_it->second.value.c_str());
|
||
content_length_ = 0;
|
||
}
|
||
}
|
||
}
|
||
// 头部结束
|
||
headers_received_ = true;
|
||
xEventGroupSetBits(event_group_handle_, EC801E_HTTP_EVENT_HEADERS_RECEIVED);
|
||
} else {
|
||
if (!ParseHeaderLine(line)) {
|
||
SetError();
|
||
return;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
|
||
case ParseState::BODY: {
|
||
if (response_chunked_) {
|
||
ParseChunkedBody(rx_buffer_);
|
||
} else {
|
||
ParseRegularBody(rx_buffer_);
|
||
}
|
||
break;
|
||
}
|
||
|
||
case ParseState::CHUNK_SIZE: {
|
||
if (!HasCompleteLine(rx_buffer_)) return; // 需要更多数据
|
||
|
||
std::string line = GetNextLine(rx_buffer_);
|
||
|
||
chunk_size_ = ParseChunkSize(line);
|
||
chunk_received_ = 0;
|
||
|
||
if (chunk_size_ == 0) {
|
||
parse_state_ = ParseState::CHUNK_TRAILER;
|
||
} else {
|
||
parse_state_ = ParseState::CHUNK_DATA;
|
||
}
|
||
break;
|
||
}
|
||
|
||
case ParseState::CHUNK_DATA: {
|
||
size_t available = std::min(rx_buffer_.size(), chunk_size_ - chunk_received_);
|
||
if (available > 0) {
|
||
std::string chunk_data = rx_buffer_.substr(0, available);
|
||
AddBodyData(std::move(chunk_data));
|
||
total_body_received_ += available;
|
||
rx_buffer_.erase(0, available);
|
||
chunk_received_ += available;
|
||
|
||
if (chunk_received_ == chunk_size_) {
|
||
// 跳过 chunk 后的 CRLF
|
||
if (rx_buffer_.size() >= 2 && rx_buffer_.substr(0, 2) == "\r\n") {
|
||
rx_buffer_.erase(0, 2);
|
||
}
|
||
parse_state_ = ParseState::CHUNK_SIZE;
|
||
}
|
||
}
|
||
if (available == 0) return; // 需要更多数据
|
||
break;
|
||
}
|
||
|
||
case ParseState::CHUNK_TRAILER: {
|
||
if (!HasCompleteLine(rx_buffer_)) return; // 需要更多数据
|
||
|
||
std::string line = GetNextLine(rx_buffer_);
|
||
|
||
if (line.empty()) {
|
||
parse_state_ = ParseState::COMPLETE;
|
||
eof_ = true;
|
||
xEventGroupSetBits(event_group_handle_, EC801E_HTTP_EVENT_COMPLETE);
|
||
}
|
||
// 忽略 trailer 头部
|
||
break;
|
||
}
|
||
|
||
case ParseState::COMPLETE:
|
||
return;
|
||
}
|
||
}
|
||
|
||
// 检查是否完成（非 chunked 模式）
|
||
if (parse_state_ == ParseState::BODY && !response_chunked_ &&
|
||
content_length_ > 0 && total_body_received_ >= content_length_) {
|
||
parse_state_ = ParseState::COMPLETE;
|
||
eof_ = true;
|
||
xEventGroupSetBits(event_group_handle_, EC801E_HTTP_EVENT_COMPLETE);
|
||
ESP_LOGD(TAG, "HTTP response body received: %u/%u bytes", total_body_received_, content_length_);
|
||
}
|
||
}
|
||
|
||
bool HttpClient::ParseStatusLine(const std::string& line) {
|
||
// HTTP/1.1 200 OK
|
||
std::istringstream iss(line);
|
||
std::string version, status_str, reason;
|
||
|
||
if (!(iss >> version >> status_str)) {
|
||
ESP_LOGE(TAG, "Invalid status line: %s", line.c_str());
|
||
return false;
|
||
}
|
||
|
||
std::getline(iss, reason); // 获取剩余部分作为原因短语
|
||
|
||
// 安全地解析状态码
|
||
char* endptr;
|
||
long status = strtol(status_str.c_str(), &endptr, 10);
|
||
|
||
if (endptr == status_str.c_str() || *endptr != '\0' || status < 100 || status > 999) {
|
||
ESP_LOGE(TAG, "Parse status code failed: %s", status_str.c_str());
|
||
return false;
|
||
}
|
||
|
||
status_code_ = static_cast<int>(status);
|
||
ESP_LOGD(TAG, "HTTP status code: %d", status_code_);
|
||
return true;
|
||
}
|
||
|
||
bool HttpClient::ParseHeaderLine(const std::string& line) {
|
||
size_t colon_pos = line.find(':');
|
||
if (colon_pos == std::string::npos) {
|
||
ESP_LOGE(TAG, "Invalid header line: %s", line.c_str());
|
||
return false;
|
||
}
|
||
|
||
std::string key = line.substr(0, colon_pos);
|
||
std::string value = line.substr(colon_pos + 1);
|
||
|
||
// 去除前后空格
|
||
key.erase(0, key.find_first_not_of(" \t"));
|
||
key.erase(key.find_last_not_of(" \t") + 1);
|
||
value.erase(0, value.find_first_not_of(" \t"));
|
||
value.erase(value.find_last_not_of(" \t\r\n") + 1);
|
||
|
||
// 转换为小写键名用于存储和查找，同时保存原始key
|
||
std::string lower_key = key;
|
||
std::transform(lower_key.begin(), lower_key.end(), lower_key.begin(), ::tolower);
|
||
|
||
response_headers_[lower_key] = HeaderEntry(key, value);
|
||
|
||
return true;
|
||
}
|
||
|
||
void HttpClient::ParseChunkedBody(const std::string& data) {
|
||
// Chunked body 在 ProcessReceivedData 中的状态机中处理
|
||
}
|
||
|
||
void HttpClient::ParseRegularBody(const std::string& data) {
|
||
if (!data.empty()) {
|
||
AddBodyData(data); // 使用新的方法添加数据
|
||
total_body_received_ += data.size(); // 累加接收的字节数
|
||
rx_buffer_.clear();
|
||
}
|
||
}
|
||
|
||
size_t HttpClient::ParseChunkSize(const std::string& chunk_size_line) {
|
||
// 解析 chunk size（十六进制）
|
||
std::string size_str = chunk_size_line;
|
||
|
||
// 移除 CRLF 和任何扩展
|
||
size_t semi_pos = size_str.find(';');
|
||
if (semi_pos != std::string::npos) {
|
||
size_str = size_str.substr(0, semi_pos);
|
||
}
|
||
|
||
size_str.erase(size_str.find_last_not_of(" \t\r\n") + 1);
|
||
|
||
// 安全地解析十六进制 chunk 大小
|
||
char* endptr;
|
||
unsigned long chunk_size = strtoul(size_str.c_str(), &endptr, 16);
|
||
|
||
if (endptr == size_str.c_str() || *endptr != '\0') {
|
||
ESP_LOGE(TAG, "Parse chunk size failed: %s", size_str.c_str());
|
||
return 0;
|
||
}
|
||
|
||
return static_cast<size_t>(chunk_size);
|
||
}
|
||
|
||
std::string HttpClient::GetNextLine(std::string& buffer) {
|
||
size_t pos = buffer.find('\n');
|
||
if (pos == std::string::npos) {
|
||
return ""; // 没有完整的行
|
||
}
|
||
|
||
std::string line = buffer.substr(0, pos);
|
||
buffer.erase(0, pos + 1);
|
||
|
||
// 移除 CR
|
||
if (!line.empty() && line.back() == '\r') {
|
||
line.pop_back();
|
||
}
|
||
|
||
return line;
|
||
}
|
||
|
||
bool HttpClient::HasCompleteLine(const std::string& buffer) {
|
||
return buffer.find('\n') != std::string::npos;
|
||
}
|
||
|
||
void HttpClient::SetError() {
|
||
ESP_LOGE(TAG, "HTTP parse error");
|
||
xEventGroupSetBits(event_group_handle_, EC801E_HTTP_EVENT_ERROR);
|
||
}
|
||
|
||
int HttpClient::Read(char* buffer, size_t buffer_size) {
|
||
std::unique_lock<std::mutex> read_lock(read_mutex_);
|
||
|
||
// 如果连接异常断开，返回错误
|
||
if (connection_error_) {
|
||
return -1;
|
||
}
|
||
|
||
// 如果已经到达文件末尾且没有更多数据，返回0
|
||
if (eof_ && body_chunks_.empty()) {
|
||
return 0;
|
||
}
|
||
|
||
// 如果有数据可读，直接返回
|
||
while (!body_chunks_.empty()) {
|
||
auto& front_chunk = body_chunks_.front();
|
||
size_t bytes_read = front_chunk.read(buffer, buffer_size);
|
||
|
||
if (bytes_read > 0) {
|
||
// 如果当前chunk已读完，移除它
|
||
if (front_chunk.empty()) {
|
||
body_chunks_.pop_front();
|
||
}
|
||
// 通知等待的写入操作
|
||
write_cv_.notify_one();
|
||
return static_cast<int>(bytes_read);
|
||
}
|
||
|
||
// 如果chunk为空，移除它并继续下一个
|
||
body_chunks_.pop_front();
|
||
}
|
||
|
||
// 如果连接已断开，检查是否有错误
|
||
if (!connected_) {
|
||
if (connection_error_) {
|
||
return -1; // 连接异常断开
|
||
}
|
||
return 0; // 正常结束
|
||
}
|
||
|
||
// 等待数据或连接关闭
|
||
auto timeout = std::chrono::milliseconds(timeout_ms_);
|
||
bool received = cv_.wait_for(read_lock, timeout, [this] {
|
||
return !body_chunks_.empty() || eof_ || !connected_ || connection_error_;
|
||
});
|
||
|
||
if (!received) {
|
||
ESP_LOGE(TAG, "Wait for HTTP content receive timeout");
|
||
return -1;
|
||
}
|
||
|
||
// 再次检查连接错误状态
|
||
if (connection_error_) {
|
||
return -1;
|
||
}
|
||
|
||
// 再次检查是否有数据可读
|
||
while (!body_chunks_.empty()) {
|
||
auto& front_chunk = body_chunks_.front();
|
||
size_t bytes_read = front_chunk.read(buffer, buffer_size);
|
||
|
||
if (bytes_read > 0) {
|
||
// 如果当前chunk已读完，移除它
|
||
if (front_chunk.empty()) {
|
||
body_chunks_.pop_front();
|
||
}
|
||
// 通知等待的写入操作
|
||
write_cv_.notify_one();
|
||
return static_cast<int>(bytes_read);
|
||
}
|
||
|
||
// 如果chunk为空，移除它并继续下一个
|
||
body_chunks_.pop_front();
|
||
}
|
||
|
||
// 连接已关闭或到达EOF，返回0
|
||
return 0;
|
||
}
|
||
|
||
int HttpClient::Write(const char* buffer, size_t buffer_size) {
|
||
if (!connected_ || !request_chunked_) {
|
||
ESP_LOGE(TAG, "Cannot write: connection closed or not chunked mode");
|
||
return -1;
|
||
}
|
||
|
||
if (buffer_size == 0) {
|
||
// 发送结束 chunk
|
||
std::string end_chunk = "0\r\n\r\n";
|
||
return tcp_->Send(end_chunk);
|
||
}
|
||
|
||
// 发送 chunk
|
||
std::ostringstream chunk;
|
||
chunk << std::hex << buffer_size << "\r\n";
|
||
chunk.write(buffer, buffer_size);
|
||
chunk << "\r\n";
|
||
|
||
std::string chunk_data = chunk.str();
|
||
return tcp_->Send(chunk_data);
|
||
}
|
||
|
||
int HttpClient::GetStatusCode() {
|
||
if (!headers_received_) {
|
||
// 等待头部接收
|
||
auto bits = xEventGroupWaitBits(event_group_handle_,
|
||
EC801E_HTTP_EVENT_HEADERS_RECEIVED | EC801E_HTTP_EVENT_ERROR,
|
||
pdFALSE, pdFALSE,
|
||
pdMS_TO_TICKS(timeout_ms_));
|
||
|
||
if (bits & EC801E_HTTP_EVENT_ERROR) {
|
||
return -1;
|
||
}
|
||
if (!(bits & EC801E_HTTP_EVENT_HEADERS_RECEIVED)) {
|
||
ESP_LOGE(TAG, "Wait for HTTP headers receive timeout");
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
return status_code_;
|
||
}
|
||
|
||
std::string HttpClient::GetResponseHeader(const std::string& key) const {
|
||
// 转换为小写进行查找
|
||
std::string lower_key = key;
|
||
std::transform(lower_key.begin(), lower_key.end(), lower_key.begin(), ::tolower);
|
||
|
||
auto it = response_headers_.find(lower_key);
|
||
if (it != response_headers_.end()) {
|
||
return it->second.value;
|
||
}
|
||
return "";
|
||
}
|
||
|
||
size_t HttpClient::GetBodyLength() {
|
||
if (!headers_received_) {
|
||
GetStatusCode(); // 这会等待头部接收
|
||
}
|
||
|
||
if (response_chunked_) {
|
||
return 0; // Chunked 模式下长度未知
|
||
}
|
||
|
||
return content_length_;
|
||
}
|
||
|
||
void HttpClient::AddBodyData(const std::string& data) {
|
||
if (data.empty()) return;
|
||
|
||
std::lock_guard<std::mutex> read_lock(read_mutex_);
|
||
body_chunks_.emplace_back(data); // 使用构造函数，避免额外的拷贝
|
||
cv_.notify_one(); // 通知有新数据
|
||
write_cv_.notify_one(); // 通知写入操作
|
||
}
|
||
|
||
void HttpClient::AddBodyData(std::string&& data) {
|
||
if (data.empty()) return;
|
||
|
||
std::lock_guard<std::mutex> read_lock(read_mutex_);
|
||
body_chunks_.emplace_back(std::move(data)); // 使用移动语义，避免拷贝
|
||
cv_.notify_one(); // 通知有新数据
|
||
write_cv_.notify_one(); // 通知写入操作
|
||
}
|
||
|
||
std::string HttpClient::ReadAll() {
|
||
std::unique_lock<std::mutex> lock(mutex_);
|
||
|
||
// 等待完成或出错
|
||
auto timeout = std::chrono::milliseconds(timeout_ms_);
|
||
bool completed = cv_.wait_for(lock, timeout, [this] {
|
||
return eof_ || connection_error_;
|
||
});
|
||
|
||
if (!completed) {
|
||
ESP_LOGE(TAG, "Wait for HTTP content receive complete timeout");
|
||
return ""; // 超时返回空字符串
|
||
}
|
||
|
||
// 如果连接异常断开，返回空字符串并记录错误
|
||
if (connection_error_) {
|
||
ESP_LOGE(TAG, "Cannot read all data: connection closed prematurely");
|
||
return "";
|
||
}
|
||
|
||
// 收集所有数据
|
||
std::string result;
|
||
std::lock_guard<std::mutex> read_lock(read_mutex_);
|
||
for (const auto& chunk : body_chunks_) {
|
||
result.append(chunk.data);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
bool HttpClient::IsDataComplete() const {
|
||
// 对于chunked编码，如果parse_state_是COMPLETE，说明接收完整
|
||
if (response_chunked_) {
|
||
return parse_state_ == ParseState::COMPLETE;
|
||
}
|
||
|
||
// 对于固定长度，检查是否接收了完整的content-length
|
||
if (content_length_ > 0) {
|
||
return total_body_received_ >= content_length_;
|
||
}
|
||
|
||
// 如果没有content-length且不是chunked，当连接关闭时认为完整
|
||
// 这种情况通常用于HTTP/1.0或者content-length为0的响应
|
||
return true;
|
||
} |