404 lines
14 KiB
C++
404 lines
14 KiB
C++
//
|
|
// Copyright (C) 2019 The Android Open Source Project
|
|
//
|
|
// 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 "host/libs/web/curl_wrapper.h"
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <fstream>
|
|
#include <mutex>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <thread>
|
|
|
|
#include <android-base/logging.h>
|
|
#include <curl/curl.h>
|
|
#include <json/json.h>
|
|
|
|
namespace cuttlefish {
|
|
namespace {
|
|
|
|
size_t curl_to_function_cb(char* ptr, size_t, size_t nmemb, void* userdata) {
|
|
CurlWrapper::DataCallback* callback = (CurlWrapper::DataCallback*)userdata;
|
|
if (!(*callback)(ptr, nmemb)) {
|
|
return 0; // Signals error to curl
|
|
}
|
|
return nmemb;
|
|
}
|
|
|
|
size_t file_write_callback(char *ptr, size_t, size_t nmemb, void *userdata) {
|
|
std::stringstream* stream = (std::stringstream*) userdata;
|
|
stream->write(ptr, nmemb);
|
|
return nmemb;
|
|
}
|
|
|
|
curl_slist* build_slist(const std::vector<std::string>& strings) {
|
|
curl_slist* curl_headers = nullptr;
|
|
for (const auto& str : strings) {
|
|
curl_slist* temp = curl_slist_append(curl_headers, str.c_str());
|
|
if (temp == nullptr) {
|
|
LOG(ERROR) << "curl_slist_append failed to add " << str;
|
|
if (curl_headers) {
|
|
curl_slist_free_all(curl_headers);
|
|
return nullptr;
|
|
}
|
|
}
|
|
curl_headers = temp;
|
|
}
|
|
return curl_headers;
|
|
}
|
|
|
|
class CurlWrapperImpl : public CurlWrapper {
|
|
public:
|
|
CurlWrapperImpl() {
|
|
curl_ = curl_easy_init();
|
|
if (!curl_) {
|
|
LOG(ERROR) << "failed to initialize curl";
|
|
return;
|
|
}
|
|
}
|
|
~CurlWrapperImpl() { curl_easy_cleanup(curl_); }
|
|
|
|
CurlResponse<std::string> PostToString(
|
|
const std::string& url, const std::string& data_to_write,
|
|
const std::vector<std::string>& headers) override {
|
|
std::lock_guard<std::mutex> lock(mutex_);
|
|
LOG(INFO) << "Attempting to download \"" << url << "\"";
|
|
if (!curl_) {
|
|
LOG(ERROR) << "curl was not initialized\n";
|
|
return {"", -1};
|
|
}
|
|
curl_slist* curl_headers = build_slist(headers);
|
|
curl_easy_reset(curl_);
|
|
curl_easy_setopt(curl_, CURLOPT_CAINFO,
|
|
"/etc/ssl/certs/ca-certificates.crt");
|
|
curl_easy_setopt(curl_, CURLOPT_HTTPHEADER, curl_headers);
|
|
curl_easy_setopt(curl_, CURLOPT_URL, url.c_str());
|
|
curl_easy_setopt(curl_, CURLOPT_POSTFIELDSIZE, data_to_write.size());
|
|
curl_easy_setopt(curl_, CURLOPT_POSTFIELDS, data_to_write.c_str());
|
|
std::stringstream data_to_read;
|
|
curl_easy_setopt(curl_, CURLOPT_WRITEFUNCTION, file_write_callback);
|
|
curl_easy_setopt(curl_, CURLOPT_WRITEDATA, &data_to_read);
|
|
char error_buf[CURL_ERROR_SIZE];
|
|
curl_easy_setopt(curl_, CURLOPT_ERRORBUFFER, error_buf);
|
|
curl_easy_setopt(curl_, CURLOPT_VERBOSE, 1L);
|
|
CURLcode res = curl_easy_perform(curl_);
|
|
if (curl_headers) {
|
|
curl_slist_free_all(curl_headers);
|
|
}
|
|
if (res != CURLE_OK) {
|
|
LOG(ERROR) << "curl_easy_perform() failed. "
|
|
<< "Code was \"" << res << "\". "
|
|
<< "Strerror was \"" << curl_easy_strerror(res) << "\". "
|
|
<< "Error buffer was \"" << error_buf << "\".";
|
|
return {"", -1};
|
|
}
|
|
long http_code = 0;
|
|
curl_easy_getinfo(curl_, CURLINFO_RESPONSE_CODE, &http_code);
|
|
return {data_to_read.str(), http_code};
|
|
}
|
|
|
|
CurlResponse<Json::Value> PostToJson(
|
|
const std::string& url, const std::string& data_to_write,
|
|
const std::vector<std::string>& headers) override {
|
|
CurlResponse<std::string> response =
|
|
PostToString(url, data_to_write, headers);
|
|
const std::string& contents = response.data;
|
|
Json::CharReaderBuilder builder;
|
|
std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
|
|
Json::Value json;
|
|
std::string errorMessage;
|
|
if (!reader->parse(&*contents.begin(), &*contents.end(), &json,
|
|
&errorMessage)) {
|
|
LOG(ERROR) << "Could not parse json: " << errorMessage;
|
|
json["error"] = "Failed to parse json.";
|
|
json["response"] = contents;
|
|
}
|
|
return {json, response.http_code};
|
|
}
|
|
|
|
CurlResponse<Json::Value> PostToJson(
|
|
const std::string& url, const Json::Value& data_to_write,
|
|
const std::vector<std::string>& headers) override {
|
|
std::stringstream json_str;
|
|
json_str << data_to_write;
|
|
return PostToJson(url, json_str.str(), headers);
|
|
}
|
|
|
|
CurlResponse<bool> DownloadToCallback(
|
|
DataCallback callback, const std::string& url,
|
|
const std::vector<std::string>& headers) {
|
|
std::lock_guard<std::mutex> lock(mutex_);
|
|
LOG(INFO) << "Attempting to download \"" << url << "\"";
|
|
if (!curl_) {
|
|
LOG(ERROR) << "curl was not initialized\n";
|
|
return {false, -1};
|
|
}
|
|
if (!callback(nullptr, 0)) { // Signal start of data
|
|
LOG(ERROR) << "Callback failure\n";
|
|
return {false, -1};
|
|
}
|
|
curl_slist* curl_headers = build_slist(headers);
|
|
curl_easy_reset(curl_);
|
|
curl_easy_setopt(curl_, CURLOPT_CAINFO,
|
|
"/etc/ssl/certs/ca-certificates.crt");
|
|
curl_easy_setopt(curl_, CURLOPT_HTTPHEADER, curl_headers);
|
|
curl_easy_setopt(curl_, CURLOPT_URL, url.c_str());
|
|
curl_easy_setopt(curl_, CURLOPT_WRITEFUNCTION, curl_to_function_cb);
|
|
curl_easy_setopt(curl_, CURLOPT_WRITEDATA, &callback);
|
|
char error_buf[CURL_ERROR_SIZE];
|
|
curl_easy_setopt(curl_, CURLOPT_ERRORBUFFER, error_buf);
|
|
curl_easy_setopt(curl_, CURLOPT_VERBOSE, 1L);
|
|
CURLcode res = curl_easy_perform(curl_);
|
|
if (curl_headers) {
|
|
curl_slist_free_all(curl_headers);
|
|
}
|
|
if (res != CURLE_OK) {
|
|
LOG(ERROR) << "curl_easy_perform() failed. "
|
|
<< "Code was \"" << res << "\". "
|
|
<< "Strerror was \"" << curl_easy_strerror(res) << "\". "
|
|
<< "Error buffer was \"" << error_buf << "\".";
|
|
return {false, -1};
|
|
}
|
|
long http_code = 0;
|
|
curl_easy_getinfo(curl_, CURLINFO_RESPONSE_CODE, &http_code);
|
|
return {true, http_code};
|
|
}
|
|
|
|
CurlResponse<std::string> DownloadToFile(
|
|
const std::string& url, const std::string& path,
|
|
const std::vector<std::string>& headers) {
|
|
LOG(INFO) << "Attempting to save \"" << url << "\" to \"" << path << "\"";
|
|
std::fstream stream;
|
|
auto callback = [&stream, path](char* data, size_t size) -> bool {
|
|
if (data == nullptr) {
|
|
stream.open(path, std::ios::out | std::ios::binary | std::ios::trunc);
|
|
return !stream.fail();
|
|
}
|
|
stream.write(data, size);
|
|
return !stream.fail();
|
|
};
|
|
auto callback_res = DownloadToCallback(callback, url, headers);
|
|
if (!callback_res.data) {
|
|
return {"", callback_res.http_code};
|
|
}
|
|
return {path, callback_res.http_code};
|
|
std::lock_guard<std::mutex> lock(mutex_);
|
|
if (!curl_) {
|
|
LOG(ERROR) << "curl was not initialized\n";
|
|
return {"", -1};
|
|
}
|
|
}
|
|
|
|
CurlResponse<std::string> DownloadToString(
|
|
const std::string& url, const std::vector<std::string>& headers) {
|
|
std::stringstream stream;
|
|
auto callback = [&stream](char* data, size_t size) -> bool {
|
|
if (data == nullptr) {
|
|
stream = std::stringstream();
|
|
return true;
|
|
}
|
|
stream.write(data, size);
|
|
return true;
|
|
};
|
|
auto callback_res = DownloadToCallback(callback, url, headers);
|
|
if (!callback_res.data) {
|
|
return {"", callback_res.http_code};
|
|
}
|
|
return {stream.str(), callback_res.http_code};
|
|
}
|
|
|
|
CurlResponse<Json::Value> DownloadToJson(
|
|
const std::string& url, const std::vector<std::string>& headers) {
|
|
CurlResponse<std::string> response = DownloadToString(url, headers);
|
|
const std::string& contents = response.data;
|
|
Json::CharReaderBuilder builder;
|
|
std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
|
|
Json::Value json;
|
|
std::string errorMessage;
|
|
if (!reader->parse(&*contents.begin(), &*contents.end(), &json,
|
|
&errorMessage)) {
|
|
LOG(ERROR) << "Could not parse json: " << errorMessage;
|
|
json["error"] = "Failed to parse json.";
|
|
json["response"] = contents;
|
|
}
|
|
return {json, response.http_code};
|
|
}
|
|
|
|
CurlResponse<Json::Value> DeleteToJson(
|
|
const std::string& url,
|
|
const std::vector<std::string>& headers) override {
|
|
std::lock_guard<std::mutex> lock(mutex_);
|
|
LOG(INFO) << "Attempting to download \"" << url << "\"";
|
|
if (!curl_) {
|
|
LOG(ERROR) << "curl was not initialized\n";
|
|
return {"", -1};
|
|
}
|
|
curl_slist* curl_headers = build_slist(headers);
|
|
curl_easy_reset(curl_);
|
|
curl_easy_setopt(curl_, CURLOPT_CUSTOMREQUEST, "DELETE");
|
|
curl_easy_setopt(curl_, CURLOPT_CAINFO,
|
|
"/etc/ssl/certs/ca-certificates.crt");
|
|
curl_easy_setopt(curl_, CURLOPT_HTTPHEADER, curl_headers);
|
|
curl_easy_setopt(curl_, CURLOPT_URL, url.c_str());
|
|
std::stringstream data_to_read;
|
|
curl_easy_setopt(curl_, CURLOPT_WRITEFUNCTION, file_write_callback);
|
|
curl_easy_setopt(curl_, CURLOPT_WRITEDATA, &data_to_read);
|
|
char error_buf[CURL_ERROR_SIZE];
|
|
curl_easy_setopt(curl_, CURLOPT_ERRORBUFFER, error_buf);
|
|
curl_easy_setopt(curl_, CURLOPT_VERBOSE, 1L);
|
|
CURLcode res = curl_easy_perform(curl_);
|
|
if (curl_headers) {
|
|
curl_slist_free_all(curl_headers);
|
|
}
|
|
if (res != CURLE_OK) {
|
|
LOG(ERROR) << "curl_easy_perform() failed. "
|
|
<< "Code was \"" << res << "\". "
|
|
<< "Strerror was \"" << curl_easy_strerror(res) << "\". "
|
|
<< "Error buffer was \"" << error_buf << "\".";
|
|
return {"", -1};
|
|
}
|
|
long http_code = 0;
|
|
curl_easy_getinfo(curl_, CURLINFO_RESPONSE_CODE, &http_code);
|
|
|
|
auto contents = data_to_read.str();
|
|
Json::CharReaderBuilder builder;
|
|
std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
|
|
Json::Value json;
|
|
std::string errorMessage;
|
|
if (!reader->parse(&*contents.begin(), &*contents.end(), &json,
|
|
&errorMessage)) {
|
|
LOG(ERROR) << "Could not parse json: " << errorMessage;
|
|
json["error"] = "Failed to parse json.";
|
|
json["response"] = contents;
|
|
}
|
|
return {json, http_code};
|
|
}
|
|
|
|
std::string UrlEscape(const std::string& text) override {
|
|
char* escaped_str = curl_easy_escape(curl_, text.c_str(), text.size());
|
|
std::string ret{escaped_str};
|
|
curl_free(escaped_str);
|
|
return ret;
|
|
}
|
|
|
|
private:
|
|
CURL* curl_;
|
|
std::mutex mutex_;
|
|
};
|
|
|
|
class CurlServerErrorRetryingWrapper : public CurlWrapper {
|
|
public:
|
|
CurlServerErrorRetryingWrapper(CurlWrapper& inner, int retry_attempts,
|
|
std::chrono::milliseconds retry_delay)
|
|
: inner_curl_(inner),
|
|
retry_attempts_(retry_attempts),
|
|
retry_delay_(retry_delay) {}
|
|
|
|
CurlResponse<std::string> PostToString(
|
|
const std::string& url, const std::string& data,
|
|
const std::vector<std::string>& headers) override {
|
|
return RetryImpl<std::string>(
|
|
[&, this]() { return inner_curl_.PostToString(url, data, headers); });
|
|
}
|
|
|
|
CurlResponse<Json::Value> PostToJson(
|
|
const std::string& url, const Json::Value& data,
|
|
const std::vector<std::string>& headers) override {
|
|
return RetryImpl<Json::Value>(
|
|
[&, this]() { return inner_curl_.PostToJson(url, data, headers); });
|
|
}
|
|
|
|
CurlResponse<Json::Value> PostToJson(
|
|
const std::string& url, const std::string& data,
|
|
const std::vector<std::string>& headers) override {
|
|
return RetryImpl<Json::Value>(
|
|
[&, this]() { return inner_curl_.PostToJson(url, data, headers); });
|
|
}
|
|
|
|
CurlResponse<std::string> DownloadToFile(
|
|
const std::string& url, const std::string& path,
|
|
const std::vector<std::string>& headers) {
|
|
return RetryImpl<std::string>(
|
|
[&, this]() { return inner_curl_.DownloadToFile(url, path, headers); });
|
|
}
|
|
|
|
CurlResponse<std::string> DownloadToString(
|
|
const std::string& url, const std::vector<std::string>& headers) {
|
|
return RetryImpl<std::string>(
|
|
[&, this]() { return inner_curl_.DownloadToString(url, headers); });
|
|
}
|
|
|
|
CurlResponse<Json::Value> DownloadToJson(
|
|
const std::string& url, const std::vector<std::string>& headers) {
|
|
return RetryImpl<Json::Value>(
|
|
[&, this]() { return inner_curl_.DownloadToJson(url, headers); });
|
|
}
|
|
|
|
CurlResponse<bool> DownloadToCallback(
|
|
DataCallback cb, const std::string& url,
|
|
const std::vector<std::string>& hdrs) override {
|
|
return RetryImpl<bool>(
|
|
[&, this]() { return inner_curl_.DownloadToCallback(cb, url, hdrs); });
|
|
}
|
|
CurlResponse<Json::Value> DeleteToJson(
|
|
const std::string& url,
|
|
const std::vector<std::string>& headers) override {
|
|
return RetryImpl<Json::Value>(
|
|
[&, this]() { return inner_curl_.DeleteToJson(url, headers); });
|
|
}
|
|
|
|
std::string UrlEscape(const std::string& text) override {
|
|
return inner_curl_.UrlEscape(text);
|
|
}
|
|
|
|
private:
|
|
template <typename T>
|
|
CurlResponse<T> RetryImpl(std::function<CurlResponse<T>()> attempt_fn) {
|
|
CurlResponse<T> response;
|
|
for (int attempt = 0; attempt != retry_attempts_; ++attempt) {
|
|
if (attempt != 0) {
|
|
std::this_thread::sleep_for(retry_delay_);
|
|
}
|
|
response = attempt_fn();
|
|
if (!response.HttpServerError()) {
|
|
return response;
|
|
}
|
|
}
|
|
return response;
|
|
}
|
|
|
|
private:
|
|
CurlWrapper& inner_curl_;
|
|
int retry_attempts_;
|
|
std::chrono::milliseconds retry_delay_;
|
|
};
|
|
|
|
} // namespace
|
|
|
|
/* static */ std::unique_ptr<CurlWrapper> CurlWrapper::Create() {
|
|
return std::unique_ptr<CurlWrapper>(new CurlWrapperImpl());
|
|
}
|
|
|
|
/* static */ std::unique_ptr<CurlWrapper> CurlWrapper::WithServerErrorRetry(
|
|
CurlWrapper& inner, int retry_attempts,
|
|
std::chrono::milliseconds retry_delay) {
|
|
return std::unique_ptr<CurlWrapper>(
|
|
new CurlServerErrorRetryingWrapper(inner, retry_attempts, retry_delay));
|
|
}
|
|
|
|
CurlWrapper::~CurlWrapper() = default;
|
|
}
|