1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
// Copyright 2017 Dolphin Emulator Project
// Licensed under GPLv2+
// Refer to the license.txt file included.
#include "Common/HttpRequest.h"
#include <cstddef>
#include <curl/curl.h>
#include "Common/Logging/Log.h"
#include "Common/ScopeGuard.h"
#include "Common/StringUtil.h"
namespace Common
{
class HttpRequest::Impl final
{
public:
enum class Method
{
GET,
POST,
};
Impl(int timeout_ms);
bool IsValid() const;
Response Fetch(const std::string& url, Method method, const Headers& headers, const u8* payload,
size_t size);
private:
std::unique_ptr<CURL, decltype(&curl_easy_cleanup)> m_curl{curl_easy_init(), curl_easy_cleanup};
};
HttpRequest::HttpRequest(int timeout_ms) : m_impl(std::make_unique<Impl>(timeout_ms))
{
}
HttpRequest::~HttpRequest() = default;
bool HttpRequest::IsValid() const
{
return m_impl->IsValid();
}
HttpRequest::Response HttpRequest::Get(const std::string& url, const Headers& headers)
{
return m_impl->Fetch(url, Impl::Method::GET, headers, nullptr, 0);
}
HttpRequest::Response HttpRequest::Post(const std::string& url, const std::vector<u8>& payload,
const Headers& headers)
{
return m_impl->Fetch(url, Impl::Method::POST, headers, payload.data(), payload.size());
}
HttpRequest::Response HttpRequest::Post(const std::string& url, const std::string& payload,
const Headers& headers)
{
return m_impl->Fetch(url, Impl::Method::POST, headers,
reinterpret_cast<const u8*>(payload.data()), payload.size());
}
HttpRequest::Impl::Impl(int timeout_ms)
{
if (!m_curl)
return;
// libcurl may not have been built with async DNS support, so we disable
// signal handlers to avoid a possible and likely crash if a resolve times out.
curl_easy_setopt(m_curl.get(), CURLOPT_NOSIGNAL, true);
curl_easy_setopt(m_curl.get(), CURLOPT_TIMEOUT_MS, timeout_ms);
#ifdef _WIN32
// ALPN support is enabled by default but requires Windows >= 8.1.
curl_easy_setopt(m_curl.get(), CURLOPT_SSL_ENABLE_ALPN, false);
#endif
}
bool HttpRequest::Impl::IsValid() const
{
return m_curl != nullptr;
}
static size_t CurlCallback(char* data, size_t size, size_t nmemb, void* userdata)
{
auto* buffer = static_cast<std::vector<u8>*>(userdata);
const size_t actual_size = size * nmemb;
buffer->insert(buffer->end(), data, data + actual_size);
return actual_size;
}
HttpRequest::Response HttpRequest::Impl::Fetch(const std::string& url, Method method,
const Headers& headers, const u8* payload,
size_t size)
{
curl_easy_setopt(m_curl.get(), CURLOPT_POST, method == Method::POST);
curl_easy_setopt(m_curl.get(), CURLOPT_URL, url.c_str());
if (method == Method::POST)
{
curl_easy_setopt(m_curl.get(), CURLOPT_POSTFIELDS, payload);
curl_easy_setopt(m_curl.get(), CURLOPT_POSTFIELDSIZE, size);
}
curl_slist* list = nullptr;
Common::ScopeGuard list_guard{[&list] { curl_slist_free_all(list); }};
for (const std::pair<std::string, std::optional<std::string>>& header : headers)
{
if (!header.second)
list = curl_slist_append(list, (header.first + ":").c_str());
else if (header.second->empty())
list = curl_slist_append(list, (header.first + ";").c_str());
else
list = curl_slist_append(list, (header.first + ": " + *header.second).c_str());
}
curl_easy_setopt(m_curl.get(), CURLOPT_HTTPHEADER, list);
std::vector<u8> buffer;
curl_easy_setopt(m_curl.get(), CURLOPT_WRITEFUNCTION, CurlCallback);
curl_easy_setopt(m_curl.get(), CURLOPT_WRITEDATA, &buffer);
const char* type = method == Method::POST ? "POST" : "GET";
const CURLcode res = curl_easy_perform(m_curl.get());
if (res != CURLE_OK)
{
ERROR_LOG(COMMON, "Failed to %s %s: %s", type, url.c_str(), curl_easy_strerror(res));
return {};
}
long response_code = 0;
curl_easy_getinfo(m_curl.get(), CURLINFO_RESPONSE_CODE, &response_code);
if (response_code != 200)
{
ERROR_LOG(COMMON, "Failed to %s %s: server replied with code %li and body\n\x1b[0m%s", type,
url.c_str(), response_code, buffer.data());
return {};
}
return buffer;
}
} // namespace Common
|
