mirror of
https://github.com/shadps4-emu/shadPS4.git
synced 2026-07-10 02:04:42 -06:00
4210 lines
156 KiB
C++
4210 lines
156 KiB
C++
// SPDX-FileCopyrightText: Copyright 2024-2026 shadPS4 Emulator Project
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#include <algorithm>
|
|
#include <atomic>
|
|
#include <cctype>
|
|
#include <chrono>
|
|
#include <condition_variable>
|
|
#include <cstring>
|
|
#include <deque>
|
|
#include <fstream>
|
|
#include <memory>
|
|
#include <mutex>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <thread>
|
|
#include <unordered_map>
|
|
#include <unordered_set>
|
|
#include <vector>
|
|
#include <nlohmann/json.hpp>
|
|
#include "common/elf_info.h"
|
|
#include "common/logging/log.h"
|
|
#include "common/path_util.h"
|
|
#include "core/emulator_settings.h"
|
|
#include "core/libraries/error_codes.h"
|
|
#include "core/libraries/kernel/orbis_error.h"
|
|
#include "core/libraries/kernel/process.h"
|
|
#include "core/libraries/libs.h"
|
|
#include "core/libraries/network/http.h"
|
|
#include "http_error.h"
|
|
|
|
#if __has_include(<httplib.h>)
|
|
#include <httplib.h>
|
|
#define ORBIS_HTTP_WITH_HTTPLIB 1
|
|
#endif
|
|
|
|
namespace Libraries::Http {
|
|
|
|
enum class HttpRequestState {
|
|
Created,
|
|
Sending,
|
|
Sent,
|
|
Aborted,
|
|
};
|
|
|
|
struct HttpSettings {
|
|
u32 connect_timeout_us = 0;
|
|
u32 send_timeout_us = 0;
|
|
u32 recv_timeout_us = 0;
|
|
u32 resolve_timeout_us = 0; // DNS resolution timeout (sceHttpSetResolveTimeOut)
|
|
s32 resolve_retry = 0; // DNS retry count (sceHttpSetResolveRetry)
|
|
u64 recv_block_size = 0; // Hint to streaming receiver; 0 = default
|
|
u64 response_header_max = 0; // Max response-header bytes accepted; 0 = default
|
|
bool auto_redirect = true;
|
|
bool inflate_gzip = true; // Auto-decompress response body if gzipped
|
|
bool accept_encoding_gzip = true; // Send "Accept-Encoding: gzip" request header
|
|
u32 ssl_flags = ORBIS_HTTPS_FLAG_SDK_DEFAULT; // SSL flag mask. Bitmask of OrbisHttpsFlags.
|
|
bool nonblock = false; // false = blocking (default), true = nonblock (EAGAIN)
|
|
// (0 = no proxy, 1 = manual host:port, 2 = automatic/PAC).
|
|
std::string proxy_host;
|
|
u16 proxy_port = 0;
|
|
int proxy_http_conf = 0;
|
|
int proxy_wlan_conf = 0;
|
|
};
|
|
|
|
struct Epoll {
|
|
int ctx_id = 0;
|
|
std::deque<OrbisHttpNBEvent> events;
|
|
std::condition_variable cv;
|
|
bool destroyed = false;
|
|
bool abort_requested = false;
|
|
};
|
|
|
|
struct HttpTemplate {
|
|
int ctx_id = 0; // Owning libhttp context
|
|
std::string user_agent;
|
|
int http_version;
|
|
int auto_proxy_conf;
|
|
HttpSettings settings;
|
|
int epoll_id = 0;
|
|
void* epoll_user_arg = nullptr;
|
|
std::vector<std::pair<std::string, std::string>> headers;
|
|
};
|
|
|
|
struct HttpConnection {
|
|
int tmpl_id; // Owning template (looked up to inherit user_agent etc.)
|
|
std::string url; // Reconstructed "scheme://host:port" or the raw URL the
|
|
// game gave us via sceHttpCreateConnectionWithURL.
|
|
std::string scheme; // "http" or "https".
|
|
std::string hostname; // Host portion only. Used for the Host: request header.
|
|
u16 port = 0; // Numeric port. 80 / 443 if scheme-default.
|
|
bool keep_alive = false; // Game-controlled keep-alive intent.
|
|
bool is_secure = false; // True if scheme == "https".
|
|
HttpSettings settings;
|
|
int epoll_id = 0;
|
|
void* epoll_user_arg = nullptr;
|
|
std::vector<std::pair<std::string, std::string>> headers;
|
|
};
|
|
|
|
struct HttpResponse {
|
|
int status_code = 0;
|
|
u64 content_length = 0;
|
|
int content_length_result = ORBIS_HTTP_ERROR_NO_CONTENT_LENGTH;
|
|
std::vector<u8> body;
|
|
u64 read_cursor = 0;
|
|
std::string all_headers_blob; // Pre-formatted "Name: Value\r\n..." string.
|
|
};
|
|
|
|
struct HttpRequest {
|
|
int conn_id = 0;
|
|
int method = 0;
|
|
std::string method_str;
|
|
std::string url;
|
|
u64 content_length = 0;
|
|
HttpRequestState state = HttpRequestState::Created;
|
|
bool deleted = false;
|
|
s32 last_errno = 0; // populated by SendRequest, read by GetLastErrno
|
|
HttpSettings settings;
|
|
HttpResponse res;
|
|
std::condition_variable cv; // waiters in blocking getters block on this
|
|
// notified when state leaves Sending.
|
|
int epoll_id = 0;
|
|
void* epoll_user_arg = nullptr;
|
|
std::vector<std::pair<std::string, std::string>> headers;
|
|
};
|
|
|
|
struct HttpState {
|
|
std::mutex m_mutex;
|
|
bool inited = false;
|
|
int next_ctx_id = 0;
|
|
int next_obj_id = 0;
|
|
bool default_accept_encoding_gzip = true; // Library-wide default for new templates
|
|
std::unordered_set<int> active_contexts;
|
|
// Contexts where sceHttpsLoadCert was called. We can't actually parse the
|
|
// PS4 cert blobs, but we use this as a signal that
|
|
// the game expects custom CA validation. Connections under these contexts
|
|
// bypass cpp-httplib's default verification so endpoints aren't blocked
|
|
std::unordered_set<int> contexts_with_loaded_certs;
|
|
std::unordered_map<int, HttpTemplate> templates;
|
|
std::unordered_map<int, HttpConnection> connections;
|
|
std::unordered_map<int, std::shared_ptr<HttpRequest>> requests;
|
|
std::unordered_map<int, std::shared_ptr<Epoll>> epolls;
|
|
std::atomic<bool> shutting_down{false};
|
|
};
|
|
|
|
static HttpState g_state;
|
|
|
|
//***********************************
|
|
// Helper functions
|
|
//***********************************
|
|
|
|
static HttpSettings* ResolveSettings(int id, const char*& level) {
|
|
if (auto it = g_state.templates.find(id); it != g_state.templates.end()) {
|
|
level = "template";
|
|
return &it->second.settings;
|
|
}
|
|
if (auto it = g_state.connections.find(id); it != g_state.connections.end()) {
|
|
level = "connection";
|
|
return &it->second.settings;
|
|
}
|
|
if (auto it = g_state.requests.find(id); it != g_state.requests.end()) {
|
|
level = "request";
|
|
return &it->second->settings;
|
|
}
|
|
level = "";
|
|
return nullptr;
|
|
}
|
|
|
|
static OrbisHttpEpollHandle EncodeEpollHandle(int id) {
|
|
return reinterpret_cast<OrbisHttpEpollHandle>(static_cast<intptr_t>(id));
|
|
}
|
|
|
|
static int DecodeEpollHandle(OrbisHttpEpollHandle eh) {
|
|
return static_cast<int>(reinterpret_cast<intptr_t>(eh));
|
|
}
|
|
|
|
// Resolve the (epoll_id*, epoll_user_arg*) pair on a template/connection/request
|
|
static bool ResolveEpollBinding(int id, int*& epoll_id_out, void**& user_arg_out,
|
|
const char*& level) {
|
|
if (auto it = g_state.templates.find(id); it != g_state.templates.end()) {
|
|
epoll_id_out = &it->second.epoll_id;
|
|
user_arg_out = &it->second.epoll_user_arg;
|
|
level = "template";
|
|
return true;
|
|
}
|
|
if (auto it = g_state.connections.find(id); it != g_state.connections.end()) {
|
|
epoll_id_out = &it->second.epoll_id;
|
|
user_arg_out = &it->second.epoll_user_arg;
|
|
level = "connection";
|
|
return true;
|
|
}
|
|
if (auto it = g_state.requests.find(id); it != g_state.requests.end()) {
|
|
epoll_id_out = &it->second->epoll_id;
|
|
user_arg_out = &it->second->epoll_user_arg;
|
|
level = "request";
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool HeaderNameMatches(std::string_view a, std::string_view b);
|
|
static std::string HttpStatusLabel(int sc);
|
|
|
|
// JSON shape: flat object mapping endpoint -> replacement URL. Example:
|
|
// {
|
|
// "api.something.dev": "http://localhost:8080",
|
|
// "discovery.something.com:5300": "http://localhost:8080",
|
|
// "https://api.example.com:443": "http://localhost:8081",
|
|
// "*": "http://localhost:8080"
|
|
// }
|
|
//
|
|
// Keys are tried in order of specificity, most-specific first:
|
|
// 1. "scheme://host:port" - matches that exact endpoint
|
|
// 2. "host:port" - matches host+port on any scheme
|
|
// 3. "host" - matches host on any scheme/port (most common)
|
|
// 4. "*" - catch-all fallback
|
|
//
|
|
// Replacement value is a URL with scheme + host + optional port. When port is
|
|
// omitted the default for the scheme is used (80 for http, 443 for https).
|
|
// When scheme is omitted the connection's original scheme is preserved.
|
|
struct HostOverrideTarget {
|
|
std::string scheme; // "http", "https", or "" to mean "preserve original"
|
|
std::string host;
|
|
u16 port = 0; // 0 means "preserve original (or default-for-scheme if scheme changed)"
|
|
};
|
|
|
|
// Parse a JSON string into a hostname to target map
|
|
std::unordered_map<std::string, HostOverrideTarget> ParseHostOverridesJson(
|
|
const std::string& json_text);
|
|
|
|
bool ApplyHostOverride(std::string& scheme, std::string& host, u16& port, bool& is_secure);
|
|
|
|
// Populate a response object with the shape a transport-level failure produces:
|
|
// no status line, no headers, no body. Used by the no-internet path.
|
|
static void SynthesizeTransportFailureResponse(HttpResponse& res) {
|
|
res.status_code = 0;
|
|
res.content_length = 0;
|
|
res.content_length_result = ORBIS_HTTP_ERROR_NO_CONTENT_LENGTH;
|
|
res.body.clear();
|
|
res.read_cursor = 0;
|
|
res.all_headers_blob.clear();
|
|
}
|
|
|
|
// Parse a single replacement value into a HostOverrideTarget. Accepts forms:
|
|
// "host" preserve scheme, preserve port
|
|
// "host:port" preserve scheme, set port
|
|
// "http://host" set scheme to http, port defaults to 80
|
|
// "https://host" set scheme to https, port defaults to 443
|
|
// "http://host:port" set scheme + port explicitly
|
|
// "https://host:port" set scheme + port explicitly
|
|
// Bad ports fall back to port=0
|
|
static HostOverrideTarget ParseHostOverrideTarget(std::string_view value) {
|
|
HostOverrideTarget out;
|
|
|
|
// Pull off scheme prefix if present.
|
|
if (const auto scheme_end = value.find("://"); scheme_end != std::string_view::npos) {
|
|
std::string scheme(value.substr(0, scheme_end));
|
|
std::transform(scheme.begin(), scheme.end(), scheme.begin(),
|
|
[](unsigned char c) { return std::tolower(c); });
|
|
if (scheme == "http" || scheme == "https") {
|
|
out.scheme = std::move(scheme);
|
|
}
|
|
// Unknown scheme,leave out.scheme empty
|
|
value = value.substr(scheme_end + 3);
|
|
}
|
|
|
|
// Now value is "host" or "host:port".
|
|
if (const auto colon = value.find(':'); colon != std::string_view::npos) {
|
|
out.host.assign(value.substr(0, colon));
|
|
try {
|
|
const unsigned long p = std::stoul(std::string(value.substr(colon + 1)));
|
|
if (p > 0 && p <= 65535) {
|
|
out.port = static_cast<u16>(p);
|
|
}
|
|
} catch (...) {
|
|
// ignore - port stays 0
|
|
}
|
|
} else {
|
|
out.host.assign(value);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
std::unordered_map<std::string, HostOverrideTarget> ParseHostOverridesJson(
|
|
const std::string& json_text) {
|
|
std::unordered_map<std::string, HostOverrideTarget> out;
|
|
if (json_text.empty()) {
|
|
return out;
|
|
}
|
|
nlohmann::json root;
|
|
try {
|
|
root = nlohmann::json::parse(json_text);
|
|
} catch (const std::exception& e) {
|
|
LOG_ERROR(Lib_Http, "host overrides JSON parse failed: {}", e.what());
|
|
return out;
|
|
}
|
|
if (!root.is_object()) {
|
|
LOG_ERROR(Lib_Http, "host overrides JSON root must be an object");
|
|
return out;
|
|
}
|
|
for (auto it = root.begin(); it != root.end(); ++it) {
|
|
if (!it.key().empty() && it.key().front() == '_') {
|
|
continue;
|
|
}
|
|
if (!it.value().is_string()) {
|
|
LOG_ERROR(Lib_Http, "host overrides JSON: value for '{}' is not a string; skipped",
|
|
it.key());
|
|
continue;
|
|
}
|
|
const std::string value = it.value().get<std::string>();
|
|
if (value.empty()) {
|
|
LOG_ERROR(Lib_Http, "host overrides JSON: value for '{}' is empty; skipped", it.key());
|
|
continue;
|
|
}
|
|
out.emplace(it.key(), ParseHostOverrideTarget(value));
|
|
}
|
|
return out;
|
|
}
|
|
|
|
struct HostOverrideState {
|
|
bool loaded = false;
|
|
std::unordered_map<std::string, HostOverrideTarget> entries;
|
|
};
|
|
|
|
static HostOverrideState LoadHostOverrideState() {
|
|
HostOverrideState s;
|
|
s.loaded = true;
|
|
std::filesystem::path path;
|
|
if (const char* path_env = std::getenv("SHADPS4_HTTP_HOST_OVERRIDES_JSON");
|
|
path_env && path_env[0]) {
|
|
// Explicit override path - useful for dev / testing.
|
|
path = path_env;
|
|
} else {
|
|
path = Common::FS::GetUserPath(Common::FS::PathType::UserDir) / "host_overrides.json";
|
|
}
|
|
std::ifstream f(path);
|
|
if (!f.is_open()) {
|
|
return s;
|
|
}
|
|
std::stringstream buf;
|
|
buf << f.rdbuf();
|
|
s.entries = ParseHostOverridesJson(buf.str());
|
|
LOG_INFO(Lib_Http, "loaded {} host override entries from {}", s.entries.size(), path.string());
|
|
return s;
|
|
}
|
|
|
|
static const HostOverrideState& GetHostOverrideState() {
|
|
static const HostOverrideState s = LoadHostOverrideState();
|
|
return s;
|
|
}
|
|
|
|
bool ApplyHostOverride(std::string& scheme, std::string& host, u16& port, bool& is_secure) {
|
|
const auto& state = GetHostOverrideState();
|
|
if (state.entries.empty()) {
|
|
return false;
|
|
}
|
|
// Look up most-specific match first. Keys can be:
|
|
// "scheme://host:port" - matches that exact endpoint
|
|
// "host:port" - matches host+port on any scheme
|
|
// "host" - matches host on any scheme/port
|
|
// "*" - catch-all fallback
|
|
const std::string full_key = scheme + "://" + host + ":" + std::to_string(port);
|
|
const std::string host_port_key = host + ":" + std::to_string(port);
|
|
|
|
auto it = state.entries.find(full_key);
|
|
if (it == state.entries.end()) {
|
|
it = state.entries.find(host_port_key);
|
|
}
|
|
if (it == state.entries.end()) {
|
|
it = state.entries.find(host);
|
|
}
|
|
if (it == state.entries.end()) {
|
|
it = state.entries.find("*");
|
|
}
|
|
if (it == state.entries.end()) {
|
|
return false;
|
|
}
|
|
|
|
const std::string orig_scheme = scheme;
|
|
const std::string orig_host = host;
|
|
const u16 orig_port = port;
|
|
const HostOverrideTarget& target = it->second;
|
|
|
|
host = target.host;
|
|
|
|
// Scheme handling: explicit scheme in JSON wins; otherwise preserve.
|
|
if (!target.scheme.empty()) {
|
|
scheme = target.scheme;
|
|
is_secure = (target.scheme == "https");
|
|
}
|
|
|
|
if (target.port != 0) {
|
|
port = target.port;
|
|
} else if (!target.scheme.empty() && target.scheme != orig_scheme) {
|
|
if (orig_scheme == "https" && port == 443) {
|
|
port = 80;
|
|
} else if (orig_scheme == "http" && port == 80) {
|
|
port = 443;
|
|
}
|
|
}
|
|
|
|
LOG_INFO(Lib_Http, "host override active: {}://{}:{} -> {}://{}:{} (matched key '{}')",
|
|
orig_scheme, orig_host, orig_port, scheme, host, port, it->first);
|
|
return true;
|
|
}
|
|
|
|
struct SendRequestPlan {
|
|
std::string scheme;
|
|
std::string host;
|
|
u16 port = 0;
|
|
std::string path; // Path + query, e.g. "/utility/time" or "/?x=1"
|
|
s32 method = 0;
|
|
std::string method_str; // Only used when method == ORBIS_HTTP_METHOD_CUSTOM
|
|
std::string content_type;
|
|
std::vector<u8> body;
|
|
std::vector<std::pair<std::string, std::string>> headers; // Merged tmpl + conn + req
|
|
HttpSettings settings;
|
|
// True if the request's owning ctx had sceHttpsLoadCert called. In that
|
|
// case we bypass TLS verification because we can't load the game's CAs.
|
|
bool ctx_has_loaded_certs = false;
|
|
};
|
|
|
|
// Extract the path-and-query portion from a full URL
|
|
static std::string ExtractPathFromUrl(const std::string& url) {
|
|
auto scheme_end = url.find("://");
|
|
if (scheme_end == std::string::npos) {
|
|
return "/";
|
|
}
|
|
auto authority_start = scheme_end + 3;
|
|
auto path_start = url.find('/', authority_start);
|
|
if (path_start == std::string::npos) {
|
|
return "/";
|
|
}
|
|
return url.substr(path_start);
|
|
}
|
|
|
|
// Map common HTTP method codes to their name. Used for logging only.
|
|
static const char* HttpMethodName(s32 method) {
|
|
switch (method) {
|
|
case ORBIS_HTTP_METHOD_GET:
|
|
return "GET";
|
|
case ORBIS_HTTP_METHOD_POST:
|
|
return "POST";
|
|
case ORBIS_HTTP_METHOD_HEAD:
|
|
return "HEAD";
|
|
case ORBIS_HTTP_METHOD_OPTIONS:
|
|
return "OPTIONS";
|
|
case ORBIS_HTTP_METHOD_PUT:
|
|
return "PUT";
|
|
case ORBIS_HTTP_METHOD_DELETE:
|
|
return "DELETE";
|
|
case ORBIS_HTTP_METHOD_TRACE:
|
|
return "TRACE";
|
|
case ORBIS_HTTP_METHOD_CONNECT:
|
|
return "CONNECT";
|
|
case ORBIS_HTTP_METHOD_CUSTOM:
|
|
return "CUSTOM";
|
|
default:
|
|
return "?";
|
|
}
|
|
}
|
|
|
|
// Dump every effective setting and the merged header list when a request is
|
|
// about to be sent.
|
|
static void LogSendRequestSettings(const HttpRequest& req, int reqId, u64 body_size) {
|
|
const HttpSettings& s = req.settings;
|
|
LOG_INFO(Lib_Http, "--- SendRequest dump reqId={} ---", reqId);
|
|
const char* method_name = "(unset)";
|
|
if (!req.method_str.empty()) {
|
|
method_name = req.method_str.c_str();
|
|
} else {
|
|
switch (req.method) {
|
|
case ORBIS_HTTP_METHOD_GET:
|
|
method_name = "GET";
|
|
break;
|
|
case ORBIS_HTTP_METHOD_POST:
|
|
method_name = "POST";
|
|
break;
|
|
case ORBIS_HTTP_METHOD_HEAD:
|
|
method_name = "HEAD";
|
|
break;
|
|
case ORBIS_HTTP_METHOD_OPTIONS:
|
|
method_name = "OPTIONS";
|
|
break;
|
|
case ORBIS_HTTP_METHOD_PUT:
|
|
method_name = "PUT";
|
|
break;
|
|
case ORBIS_HTTP_METHOD_DELETE:
|
|
method_name = "DELETE";
|
|
break;
|
|
case ORBIS_HTTP_METHOD_TRACE:
|
|
method_name = "TRACE";
|
|
break;
|
|
case ORBIS_HTTP_METHOD_CONNECT:
|
|
method_name = "CONNECT";
|
|
break;
|
|
case ORBIS_HTTP_METHOD_CUSTOM:
|
|
method_name = "CUSTOM";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
LOG_INFO(Lib_Http, " method={} url={} body_size={}", method_name,
|
|
req.url.empty() ? "(unset)" : req.url.c_str(), body_size);
|
|
|
|
// Resolve the owning connection + template (for full URL context and
|
|
// header inheritance dump).
|
|
const HttpConnection* conn = nullptr;
|
|
const HttpTemplate* tmpl = nullptr;
|
|
if (auto it = g_state.connections.find(req.conn_id); it != g_state.connections.end()) {
|
|
conn = &it->second;
|
|
if (auto tit = g_state.templates.find(conn->tmpl_id); tit != g_state.templates.end()) {
|
|
tmpl = &tit->second;
|
|
}
|
|
}
|
|
if (conn) {
|
|
LOG_INFO(Lib_Http, " connection: {}://{}:{} keep_alive={} secure={}", conn->scheme,
|
|
conn->hostname, conn->port, conn->keep_alive, conn->is_secure);
|
|
}
|
|
if (tmpl) {
|
|
LOG_INFO(Lib_Http, " template: ua=\"{}\" http_ver={} auto_proxy_conf={}", tmpl->user_agent,
|
|
tmpl->http_version, tmpl->auto_proxy_conf);
|
|
}
|
|
|
|
// Timeouts and basic flags
|
|
LOG_INFO(Lib_Http, " timeouts: connect={}us send={}us recv={}us resolve={}us resolve_retry={}",
|
|
s.connect_timeout_us, s.send_timeout_us, s.recv_timeout_us, s.resolve_timeout_us,
|
|
s.resolve_retry);
|
|
LOG_INFO(Lib_Http,
|
|
" flags: auto_redirect={} inflate_gzip={} accept_encoding_gzip={} nonblock={}",
|
|
s.auto_redirect, s.inflate_gzip, s.accept_encoding_gzip, s.nonblock);
|
|
LOG_INFO(Lib_Http, " buffers: recv_block_size={} response_header_max={}", s.recv_block_size,
|
|
s.response_header_max);
|
|
LOG_INFO(Lib_Http, " ssl_flags={:#x}", s.ssl_flags);
|
|
if (!s.proxy_host.empty() || s.proxy_http_conf != 0 || s.proxy_wlan_conf != 0) {
|
|
LOG_INFO(Lib_Http, " proxy: {}:{} http_conf={} wlan_conf={}",
|
|
s.proxy_host.empty() ? "(empty)" : s.proxy_host.c_str(), s.proxy_port,
|
|
s.proxy_http_conf, s.proxy_wlan_conf);
|
|
}
|
|
if (req.epoll_id != 0) {
|
|
LOG_INFO(Lib_Http, " epoll: bound to epoll_id={} user_arg={}", req.epoll_id,
|
|
req.epoll_user_arg);
|
|
}
|
|
|
|
// Merged header view: dump tmpl + conn + req lists
|
|
auto dump_headers = [&](const char* origin,
|
|
const std::vector<std::pair<std::string, std::string>>& h) {
|
|
if (h.empty()) {
|
|
return;
|
|
}
|
|
for (const auto& [name, value] : h) {
|
|
LOG_INFO(Lib_Http, " header[{}] {}: {}", origin, name, value);
|
|
}
|
|
};
|
|
if (tmpl) {
|
|
dump_headers("template", tmpl->headers);
|
|
}
|
|
if (conn) {
|
|
dump_headers("connection", conn->headers);
|
|
}
|
|
dump_headers("request", req.headers);
|
|
LOG_INFO(Lib_Http, "--- end dump reqId={} ---", reqId);
|
|
}
|
|
|
|
#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
|
|
#define ORBIS_HTTP_HAS_HTTPS 1
|
|
#else
|
|
#define ORBIS_HTTP_HAS_HTTPS 0
|
|
#endif
|
|
|
|
#ifdef ORBIS_HTTP_WITH_HTTPLIB
|
|
static s32 TranslateHttplibError(httplib::Error err) {
|
|
using E = httplib::Error;
|
|
switch (err) {
|
|
case E::Success:
|
|
return ORBIS_OK;
|
|
// TCP couldn't be established (DNS resolved but the host refused / no
|
|
// route / unreachable). Closest firmware code is ResolverEnohost.
|
|
case E::Connection:
|
|
return ORBIS_HTTP_ERROR_RESOLVER_ENOHOST;
|
|
// Timed out at connect time or during the request.
|
|
case E::ConnectionTimeout:
|
|
case E::Timeout:
|
|
return ORBIS_HTTP_ERROR_TIMEOUT;
|
|
// TCP set up but the stream broke mid-flight, or peer closed early.
|
|
case E::Read:
|
|
case E::Write:
|
|
case E::ConnectionClosed:
|
|
return ORBIS_HTTP_ERROR_BROKEN;
|
|
// Anything TLS-related.
|
|
case E::SSLConnection:
|
|
case E::SSLLoadingCerts:
|
|
case E::SSLServerVerification:
|
|
case E::SSLServerHostnameVerification:
|
|
return ORBIS_HTTP_ERROR_SSL;
|
|
// CONNECT-method proxy handshake failed.
|
|
case E::ProxyConnection:
|
|
return ORBIS_HTTP_ERROR_PROXY;
|
|
// User aborted or library cancelled.
|
|
case E::Canceled:
|
|
return ORBIS_HTTP_ERROR_ABORTED;
|
|
// Exceeded our redirect-loop bound
|
|
case E::ExceedRedirectCount:
|
|
return ORBIS_HTTP_ERROR_NETWORK;
|
|
// Internal-bug paths that exist across all cpp-httplib versions.
|
|
case E::Unknown:
|
|
case E::BindIPAddress:
|
|
case E::UnsupportedMultipartBoundaryChars:
|
|
case E::Compression:
|
|
return ORBIS_HTTP_ERROR_UNKNOWN;
|
|
default:
|
|
return ORBIS_HTTP_ERROR_UNKNOWN;
|
|
}
|
|
}
|
|
#endif // ORBIS_HTTP_WITH_HTTPLIB
|
|
|
|
constexpr int MaxRedirects = 5;
|
|
|
|
bool IsFollowableRedirect(int status, s32 method) {
|
|
const bool status_in_set = (status >= 300 && status <= 303) || (status == 307);
|
|
if (!status_in_set) {
|
|
return false;
|
|
}
|
|
if (method == ORBIS_HTTP_METHOD_POST && status != 303) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// 303 changes the new method to GET unless original was HEAD
|
|
// Every other followable status preserves the original method.
|
|
s32 MethodAfterRedirect(int status, s32 original_method) {
|
|
if (status == 303 && original_method != ORBIS_HTTP_METHOD_HEAD) {
|
|
return ORBIS_HTTP_METHOD_GET;
|
|
}
|
|
return original_method;
|
|
}
|
|
|
|
struct ResolvedRedirect {
|
|
std::string scheme;
|
|
std::string host;
|
|
u16 port;
|
|
std::string path;
|
|
};
|
|
|
|
// Resolve a Location value relative to the current request's authority.
|
|
// Handles absolute URLs and absolute-path-relative forms
|
|
std::optional<ResolvedRedirect> ResolveRedirectLocation(const std::string& current_scheme,
|
|
const std::string& current_host,
|
|
u16 current_port,
|
|
std::string_view location) {
|
|
if (location.empty()) {
|
|
return std::nullopt;
|
|
}
|
|
if (const auto scheme_end = location.find("://"); scheme_end != std::string_view::npos) {
|
|
ResolvedRedirect out;
|
|
out.scheme.assign(location.substr(0, scheme_end));
|
|
std::transform(out.scheme.begin(), out.scheme.end(), out.scheme.begin(),
|
|
[](unsigned char c) { return std::tolower(c); });
|
|
if (out.scheme != "http" && out.scheme != "https") {
|
|
return std::nullopt;
|
|
}
|
|
const auto authority_start = scheme_end + 3;
|
|
if (authority_start >= location.size()) {
|
|
return std::nullopt;
|
|
}
|
|
const auto path_start = location.find('/', authority_start);
|
|
const std::string_view authority =
|
|
(path_start == std::string_view::npos)
|
|
? location.substr(authority_start)
|
|
: location.substr(authority_start, path_start - authority_start);
|
|
if (authority.empty()) {
|
|
return std::nullopt;
|
|
}
|
|
if (const auto colon = authority.find(':'); colon != std::string_view::npos) {
|
|
out.host.assign(authority.substr(0, colon));
|
|
try {
|
|
const unsigned long p = std::stoul(std::string(authority.substr(colon + 1)));
|
|
if (p == 0 || p > 65535) {
|
|
return std::nullopt;
|
|
}
|
|
out.port = static_cast<u16>(p);
|
|
} catch (...) {
|
|
return std::nullopt;
|
|
}
|
|
} else {
|
|
out.host.assign(authority);
|
|
out.port = (out.scheme == "https") ? 443 : 80;
|
|
}
|
|
out.path =
|
|
(path_start == std::string_view::npos) ? "/" : std::string(location.substr(path_start));
|
|
return out;
|
|
}
|
|
if (location[0] == '/') {
|
|
ResolvedRedirect out;
|
|
out.scheme = current_scheme;
|
|
out.host = current_host;
|
|
out.port = current_port;
|
|
out.path.assign(location);
|
|
return out;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
static s32 RunRealHttpRequest(const SendRequestPlan& plan_in, HttpResponse& out_res,
|
|
u32& out_event_bits) {
|
|
out_event_bits = 0;
|
|
#ifndef ORBIS_HTTP_WITH_HTTPLIB
|
|
// Test or no-httplib build: behave like a transport failure.
|
|
SynthesizeTransportFailureResponse(out_res);
|
|
LOG_INFO(Lib_Http,
|
|
"real I/O path requested but httplib not available; "
|
|
"falling back to transport failure for {}://{}{}",
|
|
plan_in.scheme, plan_in.host, plan_in.path);
|
|
return ORBIS_HTTP_ERROR_RESOLVER_ENODNS;
|
|
#else
|
|
// Mutable copy: PS4-faithful redirect loop rewrites scheme/host/port/path/method.
|
|
SendRequestPlan plan = plan_in;
|
|
|
|
auto pick_timeout_seconds = [](u32 us, u32 default_s) -> std::chrono::seconds {
|
|
if (us == 0) {
|
|
return std::chrono::seconds(default_s);
|
|
}
|
|
u64 secs = (static_cast<u64>(us) + 999999ull) / 1000000ull;
|
|
if (secs == 0) {
|
|
secs = 1;
|
|
}
|
|
return std::chrono::seconds(secs);
|
|
};
|
|
|
|
for (int depth = 0; depth <= MaxRedirects; ++depth) {
|
|
if (plan.scheme == "https" && !ORBIS_HTTP_HAS_HTTPS) {
|
|
LOG_ERROR(Lib_Http, "HTTPS request but cpp-httplib lacks OpenSSL support");
|
|
SynthesizeTransportFailureResponse(out_res);
|
|
return ORBIS_HTTP_ERROR_SSL;
|
|
}
|
|
|
|
std::string base_url = plan.scheme + "://" + plan.host;
|
|
if ((plan.scheme == "https" && plan.port != 443) ||
|
|
(plan.scheme == "http" && plan.port != 80)) {
|
|
base_url += ":" + std::to_string(plan.port);
|
|
}
|
|
httplib::Client cli(base_url);
|
|
cli.set_connection_timeout(pick_timeout_seconds(plan.settings.connect_timeout_us, 30));
|
|
cli.set_read_timeout(pick_timeout_seconds(plan.settings.recv_timeout_us, 120));
|
|
cli.set_write_timeout(pick_timeout_seconds(plan.settings.send_timeout_us, 120));
|
|
|
|
// We always handle redirects manually per PS4 rules
|
|
cli.set_follow_location(false);
|
|
|
|
#ifdef CPPHTTPLIB_ZLIB_SUPPORT
|
|
cli.set_decompress(plan.settings.inflate_gzip);
|
|
#endif
|
|
|
|
#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
|
|
if (plan.scheme == "https") {
|
|
const bool game_disabled_verify =
|
|
(plan.settings.ssl_flags & ORBIS_HTTPS_FLAG_SERVER_VERIFY) == 0;
|
|
bool verify_server = !game_disabled_verify;
|
|
if (verify_server && plan.ctx_has_loaded_certs) {
|
|
verify_server = false;
|
|
LOG_INFO(Lib_Http,
|
|
"{}://{}: ctx loaded custom CAs (libSceSsl integration absent) -> "
|
|
"bypassing cert verification",
|
|
plan.scheme, plan.host);
|
|
}
|
|
cli.enable_server_certificate_verification(verify_server);
|
|
if (game_disabled_verify) {
|
|
LOG_INFO(Lib_Http, "{}://{}: server cert verification disabled (ssl_flags={:#x})",
|
|
plan.scheme, plan.host, plan.settings.ssl_flags);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
httplib::Headers headers;
|
|
for (const auto& [k, v] : plan.headers) {
|
|
headers.emplace(k, v);
|
|
}
|
|
if (plan.settings.accept_encoding_gzip) {
|
|
bool already_set = false;
|
|
for (const auto& [k, v] : plan.headers) {
|
|
if (HeaderNameMatches(k, "Accept-Encoding")) {
|
|
already_set = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!already_set) {
|
|
headers.emplace("Accept-Encoding", "gzip");
|
|
}
|
|
}
|
|
|
|
const char* body_ptr =
|
|
plan.body.empty() ? "" : reinterpret_cast<const char*>(plan.body.data());
|
|
const size_t body_size = plan.body.size();
|
|
|
|
auto result = [&]() {
|
|
switch (plan.method) {
|
|
case ORBIS_HTTP_METHOD_GET:
|
|
return cli.Get(plan.path, headers);
|
|
case ORBIS_HTTP_METHOD_POST:
|
|
return cli.Post(plan.path, headers, body_ptr, body_size, plan.content_type);
|
|
case ORBIS_HTTP_METHOD_HEAD:
|
|
return cli.Head(plan.path, headers);
|
|
case ORBIS_HTTP_METHOD_OPTIONS:
|
|
return cli.Options(plan.path, headers);
|
|
case ORBIS_HTTP_METHOD_PUT:
|
|
return cli.Put(plan.path, headers, body_ptr, body_size, plan.content_type);
|
|
case ORBIS_HTTP_METHOD_DELETE:
|
|
return cli.Delete(plan.path, headers, body_ptr, body_size, plan.content_type);
|
|
case ORBIS_HTTP_METHOD_CUSTOM: {
|
|
httplib::Request creq;
|
|
creq.method = plan.method_str.empty() ? "GET" : plan.method_str;
|
|
creq.path = plan.path;
|
|
creq.headers = headers;
|
|
if (body_size > 0) {
|
|
creq.body.assign(body_ptr, body_size);
|
|
}
|
|
return cli.send(creq);
|
|
}
|
|
default:
|
|
LOG_ERROR(Lib_Http, "Unsupported method {}; using GET", plan.method);
|
|
return cli.Get(plan.path, headers);
|
|
}
|
|
}();
|
|
|
|
if (!result) {
|
|
const int err_val = static_cast<int>(result.error());
|
|
LOG_ERROR(Lib_Http, "cpp-httplib failed for {} {}{}: error={} ({})",
|
|
HttpMethodName(plan.method), base_url, plan.path, err_val,
|
|
httplib::to_string(static_cast<httplib::Error>(err_val)));
|
|
SynthesizeTransportFailureResponse(out_res);
|
|
return TranslateHttplibError(result.error());
|
|
}
|
|
|
|
// Populate response (overwrites any prior-iteration 3xx).
|
|
out_res.status_code = result->status;
|
|
out_res.body.assign(result->body.begin(), result->body.end());
|
|
out_res.content_length = result->body.size();
|
|
out_res.content_length_result = 0;
|
|
out_res.read_cursor = 0;
|
|
std::string reason;
|
|
{
|
|
const std::string label = HttpStatusLabel(result->status);
|
|
const auto space = label.find(' ');
|
|
reason = (space == std::string::npos) ? label : label.substr(space + 1);
|
|
}
|
|
out_res.all_headers_blob =
|
|
"HTTP/1.1 " + std::to_string(result->status) + " " + reason + "\r\n";
|
|
for (const auto& [k, v] : result->headers) {
|
|
out_res.all_headers_blob += k + ": " + v + "\r\n";
|
|
}
|
|
out_res.all_headers_blob += "\r\n";
|
|
|
|
// -- PS4-faithful redirect decision --
|
|
if (!plan.settings.auto_redirect) {
|
|
break;
|
|
}
|
|
if (depth >= MaxRedirects) {
|
|
LOG_INFO(Lib_Http,
|
|
"redirect depth limit ({}) reached; returning final response status={}",
|
|
MaxRedirects, out_res.status_code);
|
|
break;
|
|
}
|
|
if (!IsFollowableRedirect(out_res.status_code, plan.method)) {
|
|
break;
|
|
}
|
|
|
|
std::string location;
|
|
for (const auto& [k, v] : result->headers) {
|
|
if (HeaderNameMatches(k, "Location")) {
|
|
location = v;
|
|
break;
|
|
}
|
|
}
|
|
if (location.empty()) {
|
|
LOG_INFO(Lib_Http, "{} response without Location header; returning as-is",
|
|
out_res.status_code);
|
|
break;
|
|
}
|
|
auto resolved = ResolveRedirectLocation(plan.scheme, plan.host, plan.port, location);
|
|
if (!resolved) {
|
|
LOG_INFO(Lib_Http,
|
|
"{} response Location='{}' unresolvable (relative or malformed); "
|
|
"returning as-is",
|
|
out_res.status_code, location);
|
|
break;
|
|
}
|
|
|
|
const int prev_status = out_res.status_code;
|
|
const s32 prev_method = plan.method;
|
|
const s32 next_method = MethodAfterRedirect(prev_status, prev_method);
|
|
const bool host_changed = (resolved->host != plan.host) || (resolved->port != plan.port);
|
|
|
|
plan.scheme = std::move(resolved->scheme);
|
|
plan.host = std::move(resolved->host);
|
|
plan.port = resolved->port;
|
|
plan.path = std::move(resolved->path);
|
|
plan.method = next_method;
|
|
|
|
// 303 + non-HEAD downgrades the method to GET; drop the request body
|
|
// and the headers that describe it.
|
|
if (prev_status == 303 && prev_method != ORBIS_HTTP_METHOD_HEAD) {
|
|
plan.body.clear();
|
|
plan.content_type.clear();
|
|
plan.headers.erase(
|
|
std::remove_if(plan.headers.begin(), plan.headers.end(),
|
|
[](const auto& kv) {
|
|
return HeaderNameMatches(kv.first, "Content-Type") ||
|
|
HeaderNameMatches(kv.first, "Content-Length");
|
|
}),
|
|
plan.headers.end());
|
|
}
|
|
|
|
// Cross-host: rewrite any game-supplied Host header
|
|
// If the game didn't add one, cpp-httplib auto-generates the correct
|
|
// value from the new base_url on the next iteration.
|
|
if (host_changed) {
|
|
std::string host_value = plan.host;
|
|
const bool default_port = (plan.scheme == "https" && plan.port == 443) ||
|
|
(plan.scheme == "http" && plan.port == 80);
|
|
if (!default_port) {
|
|
host_value += ":" + std::to_string(plan.port);
|
|
}
|
|
for (auto& [k, v] : plan.headers) {
|
|
if (HeaderNameMatches(k, "Host")) {
|
|
v = host_value;
|
|
}
|
|
}
|
|
}
|
|
|
|
LOG_INFO(Lib_Http, "redirect: depth={} status={} {} -> {} {}://{}:{}{}", depth, prev_status,
|
|
HttpMethodName(prev_method), HttpMethodName(next_method), plan.scheme, plan.host,
|
|
plan.port, plan.path);
|
|
}
|
|
|
|
out_event_bits =
|
|
ORBIS_HTTP_NB_EVENT_IN | ORBIS_HTTP_NB_EVENT_OUT | ORBIS_HTTP_NB_EVENT_RESOLVED;
|
|
return 0;
|
|
#endif // ORBIS_HTTP_WITH_HTTPLIB
|
|
}
|
|
|
|
// Case-insensitive ASCII comparison of two HTTP header names.
|
|
static bool HeaderNameMatches(std::string_view a, std::string_view b) {
|
|
if (a.size() != b.size()) {
|
|
return false;
|
|
}
|
|
for (size_t i = 0; i < a.size(); ++i) {
|
|
if (std::tolower(static_cast<unsigned char>(a[i])) !=
|
|
std::tolower(static_cast<unsigned char>(b[i]))) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Resolve the headers vector for a template/connection/request id. Returns
|
|
// nullptr if id is invalid
|
|
static std::vector<std::pair<std::string, std::string>>* ResolveHeaders(int id,
|
|
const char*& level) {
|
|
if (auto it = g_state.templates.find(id); it != g_state.templates.end()) {
|
|
level = "template";
|
|
return &it->second.headers;
|
|
}
|
|
if (auto it = g_state.connections.find(id); it != g_state.connections.end()) {
|
|
level = "connection";
|
|
return &it->second.headers;
|
|
}
|
|
if (auto it = g_state.requests.find(id); it != g_state.requests.end()) {
|
|
level = "request";
|
|
return &it->second->headers;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
// Map common HTTP status codes to strings for logs.
|
|
static std::string HttpStatusLabel(int sc) {
|
|
switch (sc) {
|
|
case 0:
|
|
return "0 (no status)";
|
|
case 200:
|
|
return "200 OK";
|
|
case 204:
|
|
return "204 No Content";
|
|
case 301:
|
|
return "301 Moved Permanently";
|
|
case 302:
|
|
return "302 Found";
|
|
case 304:
|
|
return "304 Not Modified";
|
|
case 400:
|
|
return "400 Bad Request";
|
|
case 401:
|
|
return "401 Unauthorized";
|
|
case 403:
|
|
return "403 Forbidden";
|
|
case 404:
|
|
return "404 Not Found";
|
|
case 500:
|
|
return "500 Internal Server Error";
|
|
case 502:
|
|
return "502 Bad Gateway";
|
|
case 503:
|
|
return "503 Service Unavailable";
|
|
default:
|
|
return std::to_string(sc);
|
|
}
|
|
}
|
|
|
|
static int WaitForResponseReady(HttpRequest& req, std::unique_lock<std::mutex>& lock) {
|
|
if (req.state == HttpRequestState::Aborted) {
|
|
return ORBIS_HTTP_ERROR_ABORTED;
|
|
}
|
|
if (req.state == HttpRequestState::Created) {
|
|
return ORBIS_HTTP_ERROR_BEFORE_SEND;
|
|
}
|
|
if (req.state == HttpRequestState::Sent) {
|
|
return ORBIS_OK;
|
|
}
|
|
// state == Sending. Honor nonblock: return EAGAIN instead of blocking.
|
|
if (req.settings.nonblock) {
|
|
return ORBIS_HTTP_ERROR_EAGAIN;
|
|
}
|
|
req.cv.wait(lock, [&req]() {
|
|
return req.state != HttpRequestState::Sending || g_state.shutting_down.load();
|
|
});
|
|
if (g_state.shutting_down.load() || req.state == HttpRequestState::Aborted) {
|
|
return ORBIS_HTTP_ERROR_ABORTED;
|
|
}
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
void NormalizeAndAppendPath(char* dest, char* src) {
|
|
char* lastSlash;
|
|
u64 length;
|
|
|
|
lastSlash = strrchr(dest, '/');
|
|
if (lastSlash == NULL) {
|
|
length = strlen(dest);
|
|
dest[length] = '/';
|
|
dest[length + 1] = '\0';
|
|
} else {
|
|
lastSlash[1] = '\0';
|
|
}
|
|
if (*src == '/') {
|
|
dest[0] = '\0';
|
|
}
|
|
length = strnlen(dest, 0x3fff);
|
|
strncat(dest, src, 0x3fff - length);
|
|
return;
|
|
}
|
|
|
|
// Returns ORBIS_OK on success or one of {INVALID_VALUE, UNKNOWN_SCHEME}.
|
|
static int CheckScheme(const char* scheme, bool& is_secure) {
|
|
if (!scheme) {
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
auto match_ci = [](const char* s, const char* lit, size_t cap) -> bool {
|
|
for (size_t i = 0; i < cap; ++i) {
|
|
const char a = s[i];
|
|
const char b = lit[i];
|
|
if (a == '\0' && b == '\0')
|
|
return true;
|
|
if (a == '\0' || b == '\0')
|
|
return false;
|
|
const char fa = (a >= 'A' && a <= 'Z') ? char(a - 'A' + 'a') : a;
|
|
const char fb = (b >= 'A' && b <= 'Z') ? char(b - 'A' + 'a') : b;
|
|
if (fa != fb)
|
|
return false;
|
|
}
|
|
return s[cap] == '\0' && lit[cap] == '\0';
|
|
};
|
|
if (match_ci(scheme, "HTTP", 0x20)) {
|
|
is_secure = false;
|
|
return ORBIS_OK;
|
|
}
|
|
if (match_ci(scheme, "HTTPS", 0x20)) {
|
|
is_secure = true;
|
|
return ORBIS_OK;
|
|
}
|
|
return ORBIS_HTTP_ERROR_UNKNOWN_SCHEME;
|
|
}
|
|
|
|
static bool ContainsCrLf(const char* s) {
|
|
if (!s)
|
|
return false;
|
|
for (; *s; ++s) {
|
|
if (*s == '\r' || *s == '\n')
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//***********************************
|
|
// TODO/WIP/Stubbed functions
|
|
//***********************************
|
|
|
|
int PS4_SYSV_ABI sceHttpAddCookie(int libhttpCtxId, const char* url, const char* cookie,
|
|
u64 cookieLength) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called libhttpCtxId={}, url={}, cookie={}, cookieLength={}",
|
|
libhttpCtxId, url ? url : "(null)", cookie ? cookie : "(null)", cookieLength);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpAddQuery() {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpAddRequestHeaderRaw() {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpAuthCacheExport() {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpAuthCacheFlush(int libhttpCtxId) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called libhttpCtxId={}", libhttpCtxId);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpAuthCacheImport() {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpCacheRedirectedConnectionEnabled(int id, int isEnable) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called id={}, isEnable={}", id, isEnable);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpCookieExport(int libhttpCtxId, void* buffer, u64 bufferSize,
|
|
u64* exportSize) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called libhttpCtxId={}, buffer={}, bufferSize={}, exportSize={}",
|
|
libhttpCtxId, fmt::ptr(buffer), bufferSize, fmt::ptr(exportSize));
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpCookieFlush(int libhttpCtxId) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called libhttpCtxId={}", libhttpCtxId);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpCookieImport(int libhttpCtxId, const void* buffer, u64 bufferSize) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called libhttpCtxId={}, buffer={}, bufferSize={}", libhttpCtxId,
|
|
fmt::ptr(buffer), bufferSize);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpCreateConnection(int tmplId, const char* serverName, const char* scheme,
|
|
u16 port, int isEnableKeepalive) {
|
|
LOG_INFO(Lib_Http, "called tmplId={}, serverName={}, scheme={}, port={}, isEnableKeepalive={}",
|
|
tmplId, serverName ? serverName : "(null)", scheme ? scheme : "(null)", port,
|
|
isEnableKeepalive);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (!g_state.templates.contains(tmplId)) {
|
|
LOG_ERROR(Lib_Http, "Invalid tmplId={}", tmplId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
|
|
if (!serverName) {
|
|
LOG_ERROR(Lib_Http, "serverName is null");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
bool is_secure = false;
|
|
if (int sc = CheckScheme(scheme, is_secure); sc < 0) {
|
|
LOG_ERROR(Lib_Http, "scheme rejected: '{}' -> {:#x}", scheme ? scheme : "(null)", sc);
|
|
return sc;
|
|
}
|
|
|
|
std::string scheme_str = is_secure ? "https" : "http";
|
|
std::string host_str = serverName;
|
|
u16 effective_port = port;
|
|
ApplyHostOverride(scheme_str, host_str, effective_port, is_secure);
|
|
const int conn_id = ++g_state.next_obj_id;
|
|
HttpConnection conn;
|
|
conn.tmpl_id = tmplId;
|
|
conn.scheme = scheme_str;
|
|
conn.hostname = host_str;
|
|
conn.port = effective_port;
|
|
conn.keep_alive = (isEnableKeepalive != 0);
|
|
conn.is_secure = is_secure;
|
|
conn.url = scheme_str + "://" + host_str + ":" + std::to_string(effective_port);
|
|
if (auto tmpl_it = g_state.templates.find(tmplId); tmpl_it != g_state.templates.end()) {
|
|
conn.settings = tmpl_it->second.settings;
|
|
conn.epoll_id = tmpl_it->second.epoll_id;
|
|
conn.epoll_user_arg = tmpl_it->second.epoll_user_arg;
|
|
}
|
|
g_state.connections.emplace(conn_id, std::move(conn));
|
|
LOG_INFO(Lib_Http, "created connection connId={} url={}", conn_id,
|
|
g_state.connections[conn_id].url);
|
|
return conn_id;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpCreateConnectionWithURL(int tmplId, const char* url, bool enableKeepalive) {
|
|
LOG_INFO(Lib_Http, "called tmplId={}, url={}, enableKeepalive={}", tmplId, url ? url : "(null)",
|
|
enableKeepalive);
|
|
{
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (!g_state.templates.contains(tmplId)) {
|
|
LOG_ERROR(Lib_Http, "Invalid tmplId={}", tmplId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
}
|
|
if (!url) {
|
|
LOG_ERROR(Lib_Http, "url is null");
|
|
return ORBIS_HTTP_ERROR_INVALID_URL;
|
|
}
|
|
|
|
u64 required = 0;
|
|
int parse_ret = sceHttpUriParse(nullptr, url, nullptr, &required, 0);
|
|
if (parse_ret < 0) {
|
|
LOG_ERROR(Lib_Http, "URI pre-parse failed: {:#x}", parse_ret);
|
|
return parse_ret; // already an ORBIS_HTTP_ERROR_*
|
|
}
|
|
std::vector<char> pool(required);
|
|
OrbisHttpUriElement parsed{};
|
|
parse_ret = sceHttpUriParse(&parsed, url, pool.data(), &required, required);
|
|
if (parse_ret < 0) {
|
|
LOG_ERROR(Lib_Http, "URI parse failed: {:#x}", parse_ret);
|
|
return parse_ret;
|
|
}
|
|
|
|
std::string scheme_str = parsed.scheme ? parsed.scheme : "";
|
|
bool is_secure = false;
|
|
if (int sc = CheckScheme(parsed.scheme, is_secure); sc < 0) {
|
|
LOG_ERROR(Lib_Http, "URL scheme rejected: '{}' -> {:#x}", scheme_str, sc);
|
|
return sc;
|
|
}
|
|
if (!parsed.hostname || !parsed.hostname[0]) {
|
|
LOG_ERROR(Lib_Http, "URL has no hostname");
|
|
return ORBIS_HTTP_ERROR_INVALID_URL;
|
|
}
|
|
|
|
scheme_str = is_secure ? "https" : "http";
|
|
u16 port = parsed.port;
|
|
std::string host_str = parsed.hostname;
|
|
ApplyHostOverride(scheme_str, host_str, port, is_secure);
|
|
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized (raced with Term?)");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (!g_state.templates.contains(tmplId)) {
|
|
LOG_ERROR(Lib_Http, "Invalid tmplId={} (raced with DeleteTemplate?)", tmplId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
|
|
int conn_id = ++g_state.next_obj_id;
|
|
HttpConnection conn;
|
|
conn.tmpl_id = tmplId;
|
|
conn.url = url;
|
|
conn.scheme = scheme_str;
|
|
conn.hostname = host_str;
|
|
conn.port = port;
|
|
conn.keep_alive = enableKeepalive;
|
|
conn.is_secure = is_secure;
|
|
if (auto tmpl_it = g_state.templates.find(tmplId); tmpl_it != g_state.templates.end()) {
|
|
conn.settings = tmpl_it->second.settings;
|
|
conn.epoll_id = tmpl_it->second.epoll_id;
|
|
conn.epoll_user_arg = tmpl_it->second.epoll_user_arg;
|
|
}
|
|
g_state.connections.emplace(conn_id, std::move(conn));
|
|
LOG_INFO(Lib_Http, "created connection connId={} host={} port={} scheme={}", conn_id,
|
|
g_state.connections[conn_id].hostname, port, scheme_str);
|
|
return conn_id;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpCreateRequest(int connId, int method, const char* path, u64 contentLength) {
|
|
LOG_INFO(Lib_Http, "called connId={}, method={}, path={}, contentLength={}", connId, method,
|
|
path ? path : "(null)", contentLength);
|
|
std::string url;
|
|
{
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
auto it = g_state.connections.find(connId);
|
|
if (it == g_state.connections.end()) {
|
|
LOG_ERROR(Lib_Http, "Invalid connId={}", connId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
if (!path) {
|
|
LOG_ERROR(Lib_Http, "path is null");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
if (ContainsCrLf(path)) {
|
|
LOG_ERROR(Lib_Http, "path contains CR/LF (CRLF-injection rejected): {}", path);
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
const auto& conn = it->second;
|
|
url = conn.scheme + "://" + conn.hostname + ":" + std::to_string(conn.port);
|
|
if (path[0] != '\0') {
|
|
if (path[0] != '/') {
|
|
url.push_back('/');
|
|
}
|
|
url.append(path);
|
|
}
|
|
}
|
|
return sceHttpCreateRequestWithURL(connId, method, url.c_str(), contentLength);
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpCreateRequestWithURL(int connId, s32 method, const char* url,
|
|
u64 contentLength) {
|
|
LOG_INFO(Lib_Http, "called connId={}, method={}, url={}, contentLength={}", connId, method,
|
|
url ? url : "(null)", contentLength);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
auto conn_it = g_state.connections.find(connId);
|
|
if (conn_it == g_state.connections.end()) {
|
|
LOG_ERROR(Lib_Http, "Invalid connId={}", connId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
if (!url) {
|
|
LOG_ERROR(Lib_Http, "url is null");
|
|
return ORBIS_HTTP_ERROR_INVALID_URL;
|
|
}
|
|
|
|
if (method > 8 || ((0x177u >> (static_cast<u32>(method) & 0x1f)) & 1u) == 0) {
|
|
LOG_ERROR(Lib_Http, "method {} not accepted", method);
|
|
return ORBIS_HTTP_ERROR_UNKNOWN_METHOD;
|
|
}
|
|
const int req_id = ++g_state.next_obj_id;
|
|
auto req = std::make_shared<HttpRequest>();
|
|
req->conn_id = connId;
|
|
req->method = method;
|
|
req->url = url;
|
|
req->content_length = contentLength;
|
|
req->settings = conn_it->second.settings;
|
|
req->epoll_id = conn_it->second.epoll_id;
|
|
req->epoll_user_arg = conn_it->second.epoll_user_arg;
|
|
g_state.requests.emplace(req_id, std::move(req));
|
|
LOG_INFO(Lib_Http, "created request reqId={}", req_id);
|
|
return req_id;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpCreateTemplate(int libhttpCtxId, const char* userAgent, int httpVer,
|
|
int isAutoProxyConf) {
|
|
LOG_INFO(Lib_Http, "called libhttpCtxId={}, userAgent={}, httpVer={}, isAutoProxyConf={}",
|
|
libhttpCtxId, userAgent ? userAgent : "(null)", httpVer, isAutoProxyConf);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (!g_state.active_contexts.contains(libhttpCtxId)) {
|
|
LOG_ERROR(Lib_Http, "Invalid libhttpCtxId={}", libhttpCtxId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
const int tmpl_id = ++g_state.next_obj_id;
|
|
HttpTemplate tmpl;
|
|
tmpl.ctx_id = libhttpCtxId;
|
|
tmpl.user_agent = userAgent ? userAgent : "";
|
|
tmpl.http_version = httpVer;
|
|
tmpl.auto_proxy_conf = isAutoProxyConf;
|
|
tmpl.settings.accept_encoding_gzip = g_state.default_accept_encoding_gzip;
|
|
g_state.templates.emplace(tmpl_id, std::move(tmpl));
|
|
LOG_INFO(Lib_Http, "created template tmplId={}", tmpl_id);
|
|
return tmpl_id;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpDbgEnableProfile() {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpDbgGetConnectionStat() {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpDbgGetRequestStat() {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpDbgSetPrintf() {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpDbgShowConnectionStat() {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpDbgShowMemoryPoolStat() {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpDbgShowRequestStat() {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpDbgShowStat() {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpGetAuthEnabled(int id, int* isEnable) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called id={}, isEnable={}", id, fmt::ptr(isEnable));
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpGetConnectionStat() {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpGetCookie(int libhttpCtxId, const char* url, char* cookie, u64* required,
|
|
u64 prepared, int isSecure) {
|
|
LOG_ERROR(Lib_Http,
|
|
"(STUBBED) called libhttpCtxId={}, url={}, cookie={}, required={}, prepared={}, "
|
|
"isSecure={}",
|
|
libhttpCtxId, url ? url : "(null)", fmt::ptr(cookie), fmt::ptr(required), prepared,
|
|
isSecure);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpGetCookieEnabled(int id, int* isEnable) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called id={}, isEnable={}", id, fmt::ptr(isEnable));
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpGetCookieStats(int libhttpCtxId, OrbisHttpCookieStats* stats) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called libhttpCtxId={}, stats={}", libhttpCtxId,
|
|
fmt::ptr(stats));
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpGetEpollId() {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpGetMemoryPoolStats(int libhttpCtxId,
|
|
OrbisHttpMemoryPoolStats* currentStat) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called libhttpCtxId={}, currentStat={}", libhttpCtxId,
|
|
fmt::ptr(currentStat));
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpGetRegisteredCtxIds() {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpInit(int libnetMemId, int libsslCtxId, u64 poolSize) {
|
|
LOG_INFO(Lib_Http, "called libnetMemId={}, libsslCtxId={}, poolSize={}", libnetMemId,
|
|
libsslCtxId, poolSize);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (poolSize == 0) {
|
|
LOG_ERROR(Lib_Http, "poolSize is zero");
|
|
return ORBIS_KERNEL_ERROR_EINVAL;
|
|
}
|
|
const int ctx_id = ++g_state.next_ctx_id;
|
|
g_state.active_contexts.insert(ctx_id);
|
|
g_state.inited = true; // true while at least one context is alive
|
|
g_state.shutting_down.store(false);
|
|
LOG_INFO(Lib_Http, "initialized -> ctxId={} (active contexts: {})", ctx_id,
|
|
g_state.active_contexts.size());
|
|
return ctx_id;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpRedirectCacheFlush(int libhttpCtxId) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called libhttpCtxId={}", libhttpCtxId);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpRequestGetAllHeaders() {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSendRequest(int reqId, const void* postData, u64 size) {
|
|
LOG_INFO(Lib_Http, "called reqId={}, postData={}, size={}", reqId, fmt::ptr(postData), size);
|
|
std::shared_ptr<HttpRequest> req_ptr;
|
|
SendRequestPlan plan;
|
|
{
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
auto it = g_state.requests.find(reqId);
|
|
if (it == g_state.requests.end()) {
|
|
LOG_ERROR(Lib_Http, "Invalid reqId={}", reqId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
auto& req = *it->second;
|
|
if (req.state == HttpRequestState::Sending || req.state == HttpRequestState::Sent) {
|
|
LOG_ERROR(Lib_Http, "Request already sent (reqId={})", reqId);
|
|
return ORBIS_HTTP_ERROR_AFTER_SEND;
|
|
}
|
|
if (req.state == HttpRequestState::Aborted) {
|
|
LOG_ERROR(Lib_Http, "Request was aborted (reqId={})", reqId);
|
|
return ORBIS_HTTP_ERROR_ABORTED;
|
|
}
|
|
// Created to Sending. Worker thread will move to Sent.
|
|
req.state = HttpRequestState::Sending;
|
|
req_ptr = it->second;
|
|
LogSendRequestSettings(req, reqId, size);
|
|
|
|
plan.method = req.method;
|
|
plan.method_str = req.method_str;
|
|
plan.path = ExtractPathFromUrl(req.url);
|
|
plan.settings = req.settings;
|
|
if (auto conn_it = g_state.connections.find(req.conn_id);
|
|
conn_it != g_state.connections.end()) {
|
|
plan.scheme = conn_it->second.scheme;
|
|
plan.host = conn_it->second.hostname;
|
|
plan.port = static_cast<u16>(conn_it->second.port);
|
|
// Inherit headers in tmpl to conn to req order
|
|
if (auto tmpl_it = g_state.templates.find(conn_it->second.tmpl_id);
|
|
tmpl_it != g_state.templates.end()) {
|
|
plan.headers = tmpl_it->second.headers;
|
|
// Check if the owning context loaded custom CAs - if so the
|
|
// worker will bypass TLS verification.
|
|
plan.ctx_has_loaded_certs =
|
|
g_state.contexts_with_loaded_certs.contains(tmpl_it->second.ctx_id);
|
|
}
|
|
for (const auto& h : conn_it->second.headers) {
|
|
plan.headers.push_back(h);
|
|
}
|
|
}
|
|
for (const auto& h : req.headers) {
|
|
plan.headers.push_back(h);
|
|
}
|
|
// Pull Content-Type out of headers
|
|
for (const auto& [k, v] : plan.headers) {
|
|
if (HeaderNameMatches(k, "Content-Type")) {
|
|
plan.content_type = v;
|
|
break;
|
|
}
|
|
}
|
|
if (postData && size > 0) {
|
|
plan.body.assign(static_cast<const u8*>(postData),
|
|
static_cast<const u8*>(postData) + size);
|
|
}
|
|
}
|
|
|
|
const bool online = EmulatorSettings.IsConnectedToNetwork();
|
|
LOG_INFO(Lib_Http, "reqId={} dispatched to async worker [{} {} {}://{}:{}{}]", reqId,
|
|
online ? "ONLINE" : "OFFLINE", HttpMethodName(plan.method), plan.scheme, plan.host,
|
|
plan.port, plan.path);
|
|
|
|
std::thread([req_ptr, reqId, plan = std::move(plan), online]() {
|
|
HttpResponse local_res;
|
|
s32 worker_errno = 0;
|
|
u32 success_event_bits = 0; // 0 = no event (offline path uses failure bits)
|
|
|
|
if (!online) {
|
|
SynthesizeTransportFailureResponse(local_res);
|
|
worker_errno = ORBIS_HTTP_ERROR_RESOLVER_ENODNS;
|
|
} else {
|
|
worker_errno = RunRealHttpRequest(plan, local_res, success_event_bits);
|
|
}
|
|
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (g_state.shutting_down.load() || req_ptr->deleted ||
|
|
req_ptr->state == HttpRequestState::Aborted) {
|
|
const char* reason = g_state.shutting_down.load() ? "shutdown"
|
|
: req_ptr->deleted ? "deleted"
|
|
: "aborted";
|
|
LOG_INFO(Lib_Http,
|
|
"reqId={} worker finished but request was {} before completion; "
|
|
"dropping result (would have been status={}, errno={:#x})",
|
|
reqId, reason, local_res.status_code, static_cast<u32>(worker_errno));
|
|
req_ptr->cv.notify_all();
|
|
return;
|
|
}
|
|
req_ptr->res = std::move(local_res);
|
|
req_ptr->state = HttpRequestState::Sent;
|
|
req_ptr->last_errno = worker_errno;
|
|
if (worker_errno == 0) {
|
|
LOG_INFO(Lib_Http, "(SUCCESS) reqId={} status={} body={} bytes", reqId,
|
|
req_ptr->res.status_code, req_ptr->res.body.size());
|
|
} else {
|
|
LOG_INFO(Lib_Http, "(TRANSPORT FAIL) reqId={} -> {} (body {} bytes, errno={:#x})",
|
|
reqId, req_ptr->res.status_code, req_ptr->res.body.size(),
|
|
static_cast<u32>(worker_errno));
|
|
}
|
|
req_ptr->cv.notify_all();
|
|
|
|
// Push an epoll event so sceHttpWaitRequest callers see completion.
|
|
if (req_ptr->epoll_id != 0) {
|
|
auto epoll_it = g_state.epolls.find(req_ptr->epoll_id);
|
|
if (epoll_it != g_state.epolls.end() && !epoll_it->second->destroyed) {
|
|
u32 event_bits;
|
|
if (worker_errno == 0) {
|
|
event_bits = success_event_bits;
|
|
} else {
|
|
event_bits = ORBIS_HTTP_NB_EVENT_RESOLVER_ERR | ORBIS_HTTP_NB_EVENT_HUP;
|
|
}
|
|
OrbisHttpNBEvent ev{};
|
|
ev.events = event_bits;
|
|
ev.eventDetail = event_bits;
|
|
ev.id = reqId;
|
|
ev.userArg = req_ptr->epoll_user_arg;
|
|
epoll_it->second->events.push_back(ev);
|
|
epoll_it->second->cv.notify_all();
|
|
LOG_DEBUG(Lib_Http, "pushed epoll event for reqId={} on epoll={} bits={:#x}", reqId,
|
|
req_ptr->epoll_id, event_bits);
|
|
}
|
|
}
|
|
}).detach();
|
|
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetAuthEnabled(int id, int isEnable) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called id={}, isEnable={}", id, isEnable);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetAuthInfoCallback(int id, OrbisHttpAuthInfoCallback cbfunc,
|
|
void* userArg) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called id={}, cbfunc={}, userArg={}", id,
|
|
fmt::ptr(reinterpret_cast<void*>(cbfunc)), fmt::ptr(userArg));
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetChunkedTransferEnabled(int id, int isEnable) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called id={}, isEnable={}", id, isEnable);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetCookieEnabled(int id, int isEnable) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called id={}, isEnable={}", id, isEnable);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetCookieMaxNum(int libhttpCtxId, u32 num) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called libhttpCtxId={}, num={}", libhttpCtxId, num);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetCookieMaxNumPerDomain(int libhttpCtxId, u32 num) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called libhttpCtxId={}, num={}", libhttpCtxId, num);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetCookieMaxSize(int libhttpCtxId, u32 size) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called libhttpCtxId={}, size={}", libhttpCtxId, size);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetCookieRecvCallback(int id, OrbisHttpCookieRecvCallback cbfunc,
|
|
void* userArg) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called id={}, cbfunc={}, userArg={}", id,
|
|
fmt::ptr(reinterpret_cast<void*>(cbfunc)), fmt::ptr(userArg));
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetCookieSendCallback(int id, OrbisHttpCookieSendCallback cbfunc,
|
|
void* userArg) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called id={}, cbfunc={}, userArg={}", id,
|
|
fmt::ptr(reinterpret_cast<void*>(cbfunc)), fmt::ptr(userArg));
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetCookieTotalMaxSize(int libhttpCtxId, u32 size) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called libhttpCtxId={}, size={}", libhttpCtxId, size);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetDelayBuildRequestEnabled(int id, int isEnable) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called id={}, isEnable={}", id, isEnable);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetEpollId() {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetHttp09Enabled(int id, int isEnable) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called id={}, isEnable={}", id, isEnable);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetPolicyOption() {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetPriorityOption() {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetRedirectCallback(int id, OrbisHttpRedirectCallback cbfunc,
|
|
void* userArg) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called id={}, cbfunc={}, userArg={}", id,
|
|
fmt::ptr(reinterpret_cast<void*>(cbfunc)), fmt::ptr(userArg));
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetRequestStatusCallback(int id, OrbisHttpRequestStatusCallback cbfunc,
|
|
void* userArg) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called id={}, cbfunc={}, userArg={}", id,
|
|
fmt::ptr(reinterpret_cast<void*>(cbfunc)), fmt::ptr(userArg));
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetSocketCreationCallback() {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpsFreeCaList(int libhttpCtxId, OrbisHttpsCaList* caList) {
|
|
LOG_INFO(Lib_Http, "called libhttpCtxId={}, caList={}", libhttpCtxId, fmt::ptr(caList));
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (!g_state.active_contexts.contains(libhttpCtxId)) {
|
|
LOG_ERROR(Lib_Http, "Invalid libhttpCtxId={}", libhttpCtxId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
if (!caList) {
|
|
LOG_ERROR(Lib_Http, "caList is null");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
caList->certsNum = 0;
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpsGetCaList(int httpCtxId, OrbisHttpsCaList* list) {
|
|
LOG_INFO(Lib_Http, "called httpCtxId={}, list={}", httpCtxId, fmt::ptr(list));
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (!g_state.active_contexts.contains(httpCtxId)) {
|
|
LOG_ERROR(Lib_Http, "Invalid httpCtxId={}", httpCtxId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
if (!list) {
|
|
LOG_ERROR(Lib_Http, "list output pointer is null");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
list->certsNum = 0;
|
|
LOG_ERROR(Lib_Http, "returning empty CA list (libSceSsl integration not implemented)");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpsGetSslError(int id, int* errNum, u32* detail) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called id={}, errNum={}, detail={}", id, fmt::ptr(errNum),
|
|
fmt::ptr(detail));
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpsLoadCert(int libhttpCtxId, int caCertNum, const void** caList,
|
|
const void* cert, const void* privKey) {
|
|
LOG_INFO(Lib_Http, "called libhttpCtxId={}, caCertNum={}, caList={}, cert={}, privKey={}",
|
|
libhttpCtxId, caCertNum, fmt::ptr(caList), fmt::ptr(cert), fmt::ptr(privKey));
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (!g_state.active_contexts.contains(libhttpCtxId)) {
|
|
LOG_ERROR(Lib_Http, "Invalid libhttpCtxId={}", libhttpCtxId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
// Firmware would hand caList/cert/privKey to libSceSsl, which would parse
|
|
// them into an X509_STORE used by the TLS layer. We don't implement that
|
|
// pipeline. Instead, we record that this context expects custom CA-based
|
|
// verification, and at TLS-handshake time we bypass cpp-httplib's default
|
|
// CA verification so the game's private-CA-signed endpoints aren't blocked
|
|
// by our system CA store not knowing about them.
|
|
g_state.contexts_with_loaded_certs.insert(libhttpCtxId);
|
|
LOG_ERROR(Lib_Http,
|
|
"ctxId={} marked as using custom CAs; subsequent HTTPS requests on this "
|
|
"context will bypass cert verification (libSceSsl integration not implemented)",
|
|
libhttpCtxId);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpsSetMinSslVersion(int id, int version) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called id={}, version={}", id, version);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpsSetSslCallback(int id, OrbisHttpsCallback cbfunc, void* userArg) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called id={}, cbfunc={}, userArg={}", id,
|
|
fmt::ptr(reinterpret_cast<void*>(cbfunc)), fmt::ptr(userArg));
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpsSetSslVersion(int id, int version) {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called id={}, version={}", id, version);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpsUnloadCert(int libhttpCtxId) {
|
|
LOG_INFO(Lib_Http, "called libhttpCtxId={}", libhttpCtxId);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (!g_state.active_contexts.contains(libhttpCtxId)) {
|
|
LOG_ERROR(Lib_Http, "Invalid libhttpCtxId={}", libhttpCtxId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
g_state.contexts_with_loaded_certs.erase(libhttpCtxId);
|
|
LOG_INFO(Lib_Http, "ctxId={} cleared custom-CA marker", libhttpCtxId);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpWaitRequest(OrbisHttpEpollHandle eh, OrbisHttpNBEvent* nbev, int maxevents,
|
|
int timeout) {
|
|
LOG_DEBUG(Lib_Http, "called eh={}, nbev={}, maxevents={}, timeout={}", fmt::ptr(eh),
|
|
fmt::ptr(nbev), maxevents, timeout);
|
|
std::unique_lock<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (maxevents <= 0 || !eh || !nbev) {
|
|
LOG_ERROR(Lib_Http, "InvalidValue (maxevents={}, eh={}, nbev={})", maxevents, fmt::ptr(eh),
|
|
fmt::ptr(nbev));
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
int epoll_id = DecodeEpollHandle(eh);
|
|
auto it = g_state.epolls.find(epoll_id);
|
|
if (it == g_state.epolls.end()) {
|
|
LOG_ERROR(Lib_Http, "Invalid epoll handle (id={})", epoll_id);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
auto epoll_ptr = it->second;
|
|
|
|
// if the epoll's abort flag is
|
|
// already set, return Aborted immediately without draining or waiting.
|
|
if (epoll_ptr->abort_requested) {
|
|
LOG_INFO(Lib_Http, "epoll id={} already aborted, returning ABORTED", epoll_id);
|
|
return ORBIS_HTTP_ERROR_ABORTED;
|
|
}
|
|
|
|
auto drain_into_output = [&]() -> int {
|
|
int count = 0;
|
|
while (count < maxevents && !epoll_ptr->events.empty()) {
|
|
nbev[count] = epoll_ptr->events.front();
|
|
epoll_ptr->events.pop_front();
|
|
++count;
|
|
}
|
|
return count;
|
|
};
|
|
|
|
// Events already queued: drain and return immediately.
|
|
int already = drain_into_output();
|
|
if (already > 0) {
|
|
LOG_INFO(Lib_Http, "epoll id={} returned {} events (no wait)", epoll_id, already);
|
|
return already;
|
|
}
|
|
|
|
// No events queued. Behavior depends on timeout.
|
|
if (timeout == 0) {
|
|
// Poll mode: don't wait, just return 0.
|
|
return 0;
|
|
}
|
|
if (epoll_ptr->destroyed || g_state.shutting_down.load()) {
|
|
// Don't wait if we already know we'd be woken right away.
|
|
return 0;
|
|
}
|
|
|
|
auto predicate = [&]() {
|
|
return !epoll_ptr->events.empty() || epoll_ptr->destroyed || epoll_ptr->abort_requested ||
|
|
g_state.shutting_down.load();
|
|
};
|
|
if (timeout < 0) {
|
|
epoll_ptr->cv.wait(lock, predicate);
|
|
} else {
|
|
epoll_ptr->cv.wait_for(lock, std::chrono::microseconds(timeout), predicate);
|
|
}
|
|
|
|
// If AbortWaitRequest fired during the wait, return ABORTED
|
|
if (epoll_ptr->abort_requested) {
|
|
LOG_INFO(Lib_Http, "epoll id={} woken by abort, returning ABORTED", epoll_id);
|
|
return ORBIS_HTTP_ERROR_ABORTED;
|
|
}
|
|
int count = drain_into_output();
|
|
if (epoll_ptr->destroyed) {
|
|
LOG_INFO(Lib_Http, "epoll id={} woken because destroyed; returning {} events", epoll_id,
|
|
count);
|
|
} else {
|
|
LOG_INFO(Lib_Http, "epoll id={} returned {} events after wait", epoll_id, count);
|
|
}
|
|
return count;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpUriCopy() {
|
|
LOG_ERROR(Lib_Http, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
//***********************************
|
|
// Init/Terminate functions
|
|
//***********************************
|
|
int PS4_SYSV_ABI sceHttpTerm(int libhttpCtxId) {
|
|
LOG_INFO(Lib_Http, "called libhttpCtxId={}", libhttpCtxId);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (g_state.active_contexts.erase(libhttpCtxId) == 0) {
|
|
LOG_ERROR(Lib_Http, "Invalid or already-terminated ctxId={}", libhttpCtxId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
g_state.contexts_with_loaded_certs.erase(libhttpCtxId);
|
|
if (g_state.active_contexts.empty()) {
|
|
// Last context torn down - wipe all dependent objects.
|
|
LOG_INFO(Lib_Http, "last context terminated, clearing state");
|
|
g_state.shutting_down.store(true);
|
|
size_t in_flight = 0;
|
|
for (auto& [id, req_ptr] : g_state.requests) {
|
|
if (req_ptr->state == HttpRequestState::Sending) {
|
|
++in_flight;
|
|
}
|
|
}
|
|
if (in_flight > 0) {
|
|
LOG_INFO(Lib_Http, "Term: {} request(s) still in flight,results will be abandoned",
|
|
in_flight);
|
|
}
|
|
for (auto& [id, req_ptr] : g_state.requests) {
|
|
req_ptr->deleted = true;
|
|
req_ptr->state = HttpRequestState::Aborted;
|
|
req_ptr->cv.notify_all(); // wake blocked waiters before wiping the map
|
|
}
|
|
for (auto& [id, epoll_ptr] : g_state.epolls) {
|
|
epoll_ptr->destroyed = true;
|
|
epoll_ptr->cv.notify_all(); // wake any sceHttpWaitRequest blocker
|
|
}
|
|
g_state.requests.clear();
|
|
g_state.connections.clear();
|
|
g_state.templates.clear();
|
|
g_state.epolls.clear();
|
|
g_state.contexts_with_loaded_certs.clear();
|
|
g_state.inited = false;
|
|
} else {
|
|
LOG_INFO(Lib_Http, "ctxId={} terminated, {} contexts still active", libhttpCtxId,
|
|
g_state.active_contexts.size());
|
|
}
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
//***********************************
|
|
// Misc functions
|
|
//***********************************
|
|
int PS4_SYSV_ABI sceHttpSetRecvBlockSize(int id, u32 blockSize) {
|
|
LOG_INFO(Lib_Http, "called id={}, blockSize={}", id, blockSize);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
const char* level = "";
|
|
HttpSettings* s = ResolveSettings(id, level);
|
|
if (!s) {
|
|
LOG_ERROR(Lib_Http, "Invalid id={}", id);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
s->recv_block_size = blockSize;
|
|
LOG_INFO(Lib_Http, "set {} id={} recv_block_size={}", level, id, blockSize);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetProxy(int id, int httpProxyConf, int wlanProxyConf, const char* host,
|
|
u16 port) {
|
|
LOG_INFO(Lib_Http, "called id={}, httpProxyConf={}, wlanProxyConf={}, host={}, port={}", id,
|
|
httpProxyConf, wlanProxyConf, host ? host : "(null)", port);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (!host) {
|
|
LOG_ERROR(Lib_Http, "host is null");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
const char* level = "";
|
|
HttpSettings* s = ResolveSettings(id, level);
|
|
if (!s) {
|
|
LOG_ERROR(Lib_Http, "Invalid id={}", id);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
s->proxy_http_conf = httpProxyConf;
|
|
s->proxy_wlan_conf = wlanProxyConf;
|
|
s->proxy_host = host;
|
|
s->proxy_port = port;
|
|
LOG_INFO(Lib_Http, "set {} id={} proxy={}:{} (httpConf={}, wlanConf={})", level, id, host, port,
|
|
httpProxyConf, wlanProxyConf);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpGetAcceptEncodingGZIPEnabled(int id, int* isEnable) {
|
|
LOG_INFO(Lib_Http, "called id={}", id);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (!isEnable) {
|
|
LOG_ERROR(Lib_Http, "isEnable output pointer is null");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
const char* level = "";
|
|
HttpSettings* s = ResolveSettings(id, level);
|
|
if (!s) {
|
|
LOG_ERROR(Lib_Http, "Invalid id={}", id);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
*isEnable = s->accept_encoding_gzip ? 1 : 0;
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetDefaultAcceptEncodingGZIPEnabled(int libhttpCtxId, int isEnable) {
|
|
LOG_INFO(Lib_Http, "called libhttpCtxId={}, isEnable={}", libhttpCtxId, isEnable);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
g_state.default_accept_encoding_gzip = (isEnable != 0);
|
|
LOG_INFO(Lib_Http, "set library default accept_encoding_gzip={}",
|
|
g_state.default_accept_encoding_gzip);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetAcceptEncodingGZIPEnabled(int id, int isEnable) {
|
|
LOG_INFO(Lib_Http, "called id={}, isEnable={}", id, isEnable);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
const char* level = "";
|
|
HttpSettings* s = ResolveSettings(id, level);
|
|
if (!s) {
|
|
LOG_ERROR(Lib_Http, "Invalid id={}", id);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
s->accept_encoding_gzip = (isEnable != 0);
|
|
LOG_INFO(Lib_Http, "set {} id={} accept_encoding_gzip={}", level, id, s->accept_encoding_gzip);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
//***********************************
|
|
// Non-blocking processing functions
|
|
//***********************************
|
|
int PS4_SYSV_ABI sceHttpCreateEpoll(int libhttpCtxId, OrbisHttpEpollHandle* eh) {
|
|
LOG_INFO(Lib_Http, "called libhttpCtxId={}, eh={}", libhttpCtxId, fmt::ptr(eh));
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (!g_state.active_contexts.contains(libhttpCtxId)) {
|
|
LOG_ERROR(Lib_Http, "Invalid libhttpCtxId={}", libhttpCtxId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
if (!eh) {
|
|
LOG_ERROR(Lib_Http, "eh output pointer is null");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
int epoll_id = ++g_state.next_obj_id;
|
|
auto epoll = std::make_shared<Epoll>();
|
|
epoll->ctx_id = libhttpCtxId;
|
|
g_state.epolls.emplace(epoll_id, std::move(epoll));
|
|
*eh = EncodeEpollHandle(epoll_id);
|
|
LOG_INFO(Lib_Http, "created epoll id={} (handle={})", epoll_id, fmt::ptr(*eh));
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpDestroyEpoll(int libhttpCtxId, OrbisHttpEpollHandle eh) {
|
|
LOG_INFO(Lib_Http, "called libhttpCtxId={}, eh={}", libhttpCtxId, fmt::ptr(eh));
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (!g_state.active_contexts.contains(libhttpCtxId)) {
|
|
LOG_ERROR(Lib_Http, "Invalid libhttpCtxId={}", libhttpCtxId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
if (!eh) {
|
|
LOG_ERROR(Lib_Http, "eh is null");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
int epoll_id = DecodeEpollHandle(eh);
|
|
auto it = g_state.epolls.find(epoll_id);
|
|
if (it == g_state.epolls.end()) {
|
|
LOG_ERROR(Lib_Http, "Invalid epoll handle (id={})", epoll_id);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
if (it->second->ctx_id != libhttpCtxId) {
|
|
LOG_ERROR(Lib_Http, "ctxId mismatch: epoll ctx_id={} but caller passed {}",
|
|
it->second->ctx_id, libhttpCtxId);
|
|
}
|
|
auto epoll_ptr = it->second;
|
|
epoll_ptr->destroyed = true;
|
|
epoll_ptr->cv.notify_all();
|
|
g_state.epolls.erase(it);
|
|
LOG_INFO(Lib_Http, "destroyed epoll id={}", epoll_id);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpGetEpoll(int id, OrbisHttpEpollHandle* eh, void** userArg) {
|
|
LOG_INFO(Lib_Http, "called id={}, eh={}, userArg={}", id, fmt::ptr(eh), fmt::ptr(userArg));
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (!eh) {
|
|
LOG_ERROR(Lib_Http, "eh output pointer is null");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
int* src_epoll_id = nullptr;
|
|
void** src_user_arg = nullptr;
|
|
const char* level = "";
|
|
if (!ResolveEpollBinding(id, src_epoll_id, src_user_arg, level)) {
|
|
LOG_ERROR(Lib_Http, "Invalid id={} (not a template, connection, or request)", id);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
*eh = EncodeEpollHandle(*src_epoll_id);
|
|
if (userArg) {
|
|
*userArg = *src_user_arg;
|
|
}
|
|
LOG_INFO(Lib_Http, "got epoll id={} userArg={} from {} id={}", *src_epoll_id,
|
|
fmt::ptr(*src_user_arg), level, id);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetEpoll(int id, OrbisHttpEpollHandle eh, void* userArg) {
|
|
LOG_INFO(Lib_Http, "called id={}, eh={}, userArg={}", id, fmt::ptr(eh), fmt::ptr(userArg));
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
int epoll_id = DecodeEpollHandle(eh);
|
|
if (!g_state.epolls.contains(epoll_id)) {
|
|
LOG_ERROR(Lib_Http, "Invalid epoll handle (id={})", epoll_id);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
int* target_epoll_id = nullptr;
|
|
void** target_user_arg = nullptr;
|
|
const char* level = "";
|
|
if (!ResolveEpollBinding(id, target_epoll_id, target_user_arg, level)) {
|
|
LOG_ERROR(Lib_Http, "Invalid id={} (not a template, connection, or request)", id);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
*target_epoll_id = epoll_id;
|
|
*target_user_arg = userArg;
|
|
LOG_INFO(Lib_Http, "set epoll={} userArg={} at {} level (id={})", epoll_id, fmt::ptr(userArg),
|
|
level, id);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpUnsetEpoll(int id) {
|
|
LOG_INFO(Lib_Http, "called id={}", id);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
auto it = g_state.requests.find(id);
|
|
if (it == g_state.requests.end()) {
|
|
LOG_ERROR(Lib_Http, "Invalid reqId={}", id);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
it->second->epoll_id = 0;
|
|
it->second->epoll_user_arg = nullptr;
|
|
LOG_INFO(Lib_Http, "cleared epoll binding from reqId={}", id);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpAbortWaitRequest(OrbisHttpEpollHandle eh) {
|
|
LOG_INFO(Lib_Http, "called eh={}", fmt::ptr(eh));
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (!eh) {
|
|
LOG_ERROR(Lib_Http, "eh is null");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
int epoll_id = DecodeEpollHandle(eh);
|
|
auto it = g_state.epolls.find(epoll_id);
|
|
if (it == g_state.epolls.end()) {
|
|
LOG_ERROR(Lib_Http, "Invalid epoll handle (id={})", epoll_id);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
it->second->abort_requested = true;
|
|
it->second->cv.notify_all();
|
|
LOG_INFO(Lib_Http, "epoll id={} abort requested", epoll_id);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpGetNonblock(int id, int* isEnable) {
|
|
LOG_INFO(Lib_Http, "called id={}, isEnable={}", id, fmt::ptr(isEnable));
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (!isEnable) {
|
|
LOG_ERROR(Lib_Http, "isEnable output pointer is null");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
const char* level = "";
|
|
HttpSettings* s = ResolveSettings(id, level);
|
|
if (!s) {
|
|
LOG_ERROR(Lib_Http, "Invalid id={}", id);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
*isEnable = s->nonblock ? 1 : 0;
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetNonblock(int id, int isEnable) {
|
|
LOG_INFO(Lib_Http, "called id={}, isEnable={}", id, isEnable);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
const char* level = "";
|
|
HttpSettings* s = ResolveSettings(id, level);
|
|
if (!s) {
|
|
LOG_ERROR(Lib_Http, "Invalid id={}", id);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
s->nonblock = (isEnable != 0);
|
|
LOG_INFO(Lib_Http, "set {} id={} nonblock={}", level, id, s->nonblock);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpTryGetNonblock(int id, int* isEnable) {
|
|
LOG_INFO(Lib_Http, "called id={}, isEnable={}", id, fmt::ptr(isEnable));
|
|
return sceHttpGetNonblock(id, isEnable);
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpTrySetNonblock(int id, int isEnable) {
|
|
LOG_INFO(Lib_Http, "called id={}, isEnable={}", id, isEnable);
|
|
return sceHttpSetNonblock(id, isEnable);
|
|
}
|
|
|
|
//***********************************
|
|
// Http Communication functions
|
|
//***********************************
|
|
int PS4_SYSV_ABI sceHttpReadData(s32 reqId, void* data, u64 size) {
|
|
LOG_INFO(Lib_Http, "called reqId={}, data={}, size={}", reqId, fmt::ptr(data), size);
|
|
std::unique_lock<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (!data) {
|
|
LOG_ERROR(Lib_Http, "data output pointer is null");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
auto it = g_state.requests.find(reqId);
|
|
if (it == g_state.requests.end()) {
|
|
LOG_DEBUG(Lib_Http, "Invalid reqId={}", reqId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
auto& req = *it->second;
|
|
int wr = WaitForResponseReady(req, lock);
|
|
if (wr != ORBIS_OK) {
|
|
if (wr == ORBIS_HTTP_ERROR_EAGAIN) {
|
|
LOG_DEBUG(Lib_Http, "reqId={}: EAGAIN (response not yet ready)", reqId);
|
|
} else {
|
|
LOG_ERROR(Lib_Http, "Wait failed for reqId={}: {:#x}", reqId, static_cast<u32>(wr));
|
|
}
|
|
return wr;
|
|
}
|
|
u64 remaining = req.res.body.size() - req.res.read_cursor;
|
|
u64 to_copy = std::min(size, remaining);
|
|
if (to_copy > 0) {
|
|
std::memcpy(data, req.res.body.data() + req.res.read_cursor, to_copy);
|
|
req.res.read_cursor += to_copy;
|
|
}
|
|
LOG_INFO(Lib_Http, "reqId={} copied {} bytes (cursor {}/{}) ", reqId, to_copy,
|
|
req.res.read_cursor, req.res.body.size());
|
|
return static_cast<int>(to_copy);
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpAbortRequest(int reqId) {
|
|
LOG_INFO(Lib_Http, "called reqId={}", reqId);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
auto it = g_state.requests.find(reqId);
|
|
if (it == g_state.requests.end()) {
|
|
LOG_ERROR(Lib_Http, "Invalid reqId={}", reqId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
auto& req = *it->second;
|
|
|
|
if (req.state == HttpRequestState::Created || req.state == HttpRequestState::Sending) {
|
|
req.state = HttpRequestState::Aborted;
|
|
req.cv.notify_all();
|
|
LOG_INFO(Lib_Http, "reqId={} marked Aborted", reqId);
|
|
} else {
|
|
LOG_INFO(Lib_Http, "reqId={} already Sent/Aborted, no-op", reqId);
|
|
}
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpAbortRequestForce(int reqId) {
|
|
LOG_INFO(Lib_Http, "called reqId={}", reqId);
|
|
return sceHttpAbortRequest(reqId);
|
|
}
|
|
|
|
//***********************************
|
|
// Https Option setting functions
|
|
//***********************************
|
|
int PS4_SYSV_ABI sceHttpsDisableOption(int id, u32 sslFlags) {
|
|
LOG_INFO(Lib_Http, "called id={}, sslFlags={:#x}", id, sslFlags);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if ((sslFlags & ~ORBIS_HTTPS_FLAG_PUBLIC_VALID) != 0) {
|
|
LOG_ERROR(Lib_Http, "sslFlags={:#x} contains unknown bits {:#x}", sslFlags,
|
|
sslFlags & ~ORBIS_HTTPS_FLAG_PUBLIC_VALID);
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
const char* level = "";
|
|
HttpSettings* s = ResolveSettings(id, level);
|
|
if (!s) {
|
|
LOG_ERROR(Lib_Http, "Invalid id={} (not a template, connection, or request)", id);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
s->ssl_flags &= ~sslFlags;
|
|
LOG_INFO(Lib_Http, "ssl_flags now {:#x} at {} level (id={})", s->ssl_flags, level, id);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpsDisableOptionPrivate(int id, u32 sslFlags) {
|
|
LOG_INFO(Lib_Http, "called id={}, sslFlags={:#x}", id, sslFlags);
|
|
// Same as sceHttpsDisableOption but accepts a wider bit-mask
|
|
// ORBIS_HTTPS_FLAG_PRIVATE_VALID
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if ((sslFlags & ~ORBIS_HTTPS_FLAG_PRIVATE_VALID) != 0) {
|
|
LOG_ERROR(Lib_Http, "sslFlags={:#x} contains unknown bits {:#x}", sslFlags,
|
|
sslFlags & ~ORBIS_HTTPS_FLAG_PRIVATE_VALID);
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
const char* level = "";
|
|
HttpSettings* s = ResolveSettings(id, level);
|
|
if (!s) {
|
|
LOG_ERROR(Lib_Http, "Invalid id={} (not a template, connection, or request)", id);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
s->ssl_flags &= ~sslFlags;
|
|
LOG_INFO(Lib_Http, "ssl_flags now {:#x} at {} level (id={})", s->ssl_flags, level, id);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpsEnableOption(int id, u32 sslFlags) {
|
|
LOG_INFO(Lib_Http, "called id={}, sslFlags={:#x}", id, sslFlags);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if ((sslFlags & ~ORBIS_HTTPS_FLAG_PUBLIC_VALID) != 0) {
|
|
LOG_ERROR(Lib_Http, "sslFlags={:#x} contains unknown bits {:#x}", sslFlags,
|
|
sslFlags & ~ORBIS_HTTPS_FLAG_PUBLIC_VALID);
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
const char* level = "";
|
|
HttpSettings* s = ResolveSettings(id, level);
|
|
if (!s) {
|
|
LOG_ERROR(Lib_Http, "Invalid id={} (not a template, connection, or request)", id);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
s->ssl_flags |= sslFlags;
|
|
LOG_INFO(Lib_Http, "ssl_flags now {:#x} at {} level (id={})", s->ssl_flags, level, id);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpsEnableOptionPrivate(int id, u32 sslFlags) {
|
|
LOG_INFO(Lib_Http, "called id={}, sslFlags={:#x}", id, sslFlags);
|
|
// Same as sceHttpsEnableOption but accepts the wider Private
|
|
// bit-mask (ORBIS_HTTPS_FLAG_PRIVATE_VALID).
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if ((sslFlags & ~ORBIS_HTTPS_FLAG_PRIVATE_VALID) != 0) {
|
|
LOG_ERROR(Lib_Http, "sslFlags={:#x} contains unknown bits {:#x}", sslFlags,
|
|
sslFlags & ~ORBIS_HTTPS_FLAG_PRIVATE_VALID);
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
const char* level = "";
|
|
HttpSettings* s = ResolveSettings(id, level);
|
|
if (!s) {
|
|
LOG_ERROR(Lib_Http, "Invalid id={} (not a template, connection, or request)", id);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
s->ssl_flags |= sslFlags;
|
|
LOG_INFO(Lib_Http, "ssl_flags now {:#x} at {} level (id={})", s->ssl_flags, level, id);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
//***********************************
|
|
// Response Information functions
|
|
//***********************************
|
|
int PS4_SYSV_ABI sceHttpSetResolveTimeOut(int id, u32 usec) {
|
|
LOG_INFO(Lib_Http, "called id={}, usec={}", id, usec);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
s32 sdk_ver = Common::ElfInfo::FW_100;
|
|
::Libraries::Kernel::sceKernelGetCompiledSdkVersion(&sdk_ver);
|
|
if (sdk_ver >= Common::ElfInfo::FW_170 && usec <= 999999u) {
|
|
LOG_ERROR(Lib_Http, "Invalid usec={} (sdk_ver={:#x})", usec, sdk_ver);
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
const char* level = "";
|
|
HttpSettings* s = ResolveSettings(id, level);
|
|
if (!s) {
|
|
LOG_ERROR(Lib_Http, "Invalid id={}", id);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
s->resolve_timeout_us = usec;
|
|
LOG_INFO(Lib_Http, "set {} id={} resolve_timeout_us={}", level, id, usec);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetResponseHeaderMaxSize(int id, u64 headerSize) {
|
|
LOG_INFO(Lib_Http, "called id={}, headerSize={}", id, headerSize);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
const char* level = "";
|
|
HttpSettings* s = ResolveSettings(id, level);
|
|
if (!s) {
|
|
LOG_ERROR(Lib_Http, "Invalid id={}", id);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
s->response_header_max = headerSize;
|
|
LOG_INFO(Lib_Http, "set {} id={} response_header_max={}", level, id, headerSize);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpGetAllResponseHeaders(int reqId, char** header, u64* headerSize) {
|
|
LOG_INFO(Lib_Http, "called reqId={}, header={}, headerSize={}", reqId, fmt::ptr(header),
|
|
fmt::ptr(headerSize));
|
|
std::unique_lock<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (!header || !headerSize) {
|
|
LOG_ERROR(Lib_Http, "header or headerSize output pointer is null");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
auto it = g_state.requests.find(reqId);
|
|
if (it == g_state.requests.end()) {
|
|
LOG_DEBUG(Lib_Http, "Invalid reqId={}", reqId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
auto& req = *it->second;
|
|
int wr = WaitForResponseReady(req, lock);
|
|
if (wr != ORBIS_OK) {
|
|
if (wr == ORBIS_HTTP_ERROR_EAGAIN) {
|
|
LOG_DEBUG(Lib_Http, "reqId={}: EAGAIN (response not yet ready)", reqId);
|
|
} else {
|
|
LOG_ERROR(Lib_Http, "Wait failed for reqId={}: {:#x}", reqId, static_cast<u32>(wr));
|
|
}
|
|
return wr;
|
|
}
|
|
if (req.res.all_headers_blob.empty()) {
|
|
*header = nullptr;
|
|
*headerSize = 0;
|
|
LOG_INFO(Lib_Http, "reqId={} returning empty headers blob", reqId);
|
|
} else {
|
|
*header = const_cast<char*>(req.res.all_headers_blob.c_str());
|
|
*headerSize = req.res.all_headers_blob.size();
|
|
LOG_INFO(Lib_Http, "reqId={} returning {} bytes of headers", reqId, *headerSize);
|
|
}
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpGetResponseContentLength(int reqId, int* result, u64* contentLength) {
|
|
LOG_INFO(Lib_Http, "called reqId={}, result={}, contentLength={}", reqId, fmt::ptr(result),
|
|
fmt::ptr(contentLength));
|
|
std::unique_lock<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (!result || !contentLength) {
|
|
LOG_ERROR(Lib_Http, "result or contentLength output pointer is null");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
auto it = g_state.requests.find(reqId);
|
|
if (it == g_state.requests.end()) {
|
|
LOG_DEBUG(Lib_Http, "Invalid reqId={}", reqId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
auto& req = *it->second;
|
|
int wr = WaitForResponseReady(req, lock);
|
|
if (wr == ORBIS_HTTP_ERROR_EAGAIN) {
|
|
LOG_DEBUG(Lib_Http, "reqId={}: response not yet ready, returning BEFORE_SEND", reqId);
|
|
return ORBIS_HTTP_ERROR_BEFORE_SEND;
|
|
}
|
|
if (wr != ORBIS_OK) {
|
|
LOG_ERROR(Lib_Http, "Wait failed for reqId={}: {:#x}", reqId, static_cast<u32>(wr));
|
|
return wr;
|
|
}
|
|
*result = req.res.content_length_result;
|
|
*contentLength = req.res.content_length;
|
|
LOG_INFO(Lib_Http, "reqId={} result={:#x} contentLength={}", reqId, static_cast<u32>(*result),
|
|
*contentLength);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpGetStatusCode(int reqId, int* statusCode) {
|
|
LOG_DEBUG(Lib_Http, "called reqId={}", reqId);
|
|
std::unique_lock<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (!statusCode) {
|
|
LOG_ERROR(Lib_Http, "statusCode output pointer is null");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
auto it = g_state.requests.find(reqId);
|
|
if (it == g_state.requests.end()) {
|
|
LOG_DEBUG(Lib_Http, "Invalid reqId={}", reqId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
auto& req = *it->second;
|
|
int wr = WaitForResponseReady(req, lock);
|
|
if (wr == ORBIS_HTTP_ERROR_EAGAIN) {
|
|
LOG_DEBUG(Lib_Http, "reqId={}: response not yet ready, returning BEFORE_SEND", reqId);
|
|
return ORBIS_HTTP_ERROR_BEFORE_SEND;
|
|
}
|
|
if (wr != ORBIS_OK) {
|
|
LOG_ERROR(Lib_Http, "Wait failed for reqId={}: {:#x}", reqId, static_cast<u32>(wr));
|
|
return wr;
|
|
}
|
|
// Transport failure: no status line was ever received from a server.
|
|
if (req.res.status_code == 0 && req.last_errno != 0) {
|
|
LOG_INFO(Lib_Http, "reqId={} transport failure, errno={:#x}, returning BEFORE_SEND", reqId,
|
|
static_cast<u32>(req.last_errno));
|
|
return ORBIS_HTTP_ERROR_BEFORE_SEND;
|
|
}
|
|
*statusCode = req.res.status_code;
|
|
LOG_INFO(Lib_Http, "reqId={} status={}", reqId, HttpStatusLabel(req.res.status_code));
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetInflateGZIPEnabled(int id, int isEnable) {
|
|
LOG_INFO(Lib_Http, "called id={}, isEnable={}", id, isEnable);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (static_cast<u32>(isEnable) >= 2) {
|
|
LOG_ERROR(Lib_Http, "isEnable={} is not 0 or 1", isEnable);
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
const char* level = "";
|
|
HttpSettings* s = ResolveSettings(id, level);
|
|
if (!s) {
|
|
LOG_ERROR(Lib_Http, "Invalid Id");
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
s->inflate_gzip = (isEnable != 0);
|
|
LOG_INFO(Lib_Http, "inflate_gzip={} at {} level (id={})", s->inflate_gzip, level, id);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
//***********************************
|
|
// Http Header setting functions
|
|
//***********************************
|
|
int PS4_SYSV_ABI sceHttpAddRequestHeader(int id, const char* name, const char* value, s32 mode) {
|
|
LOG_INFO(Lib_Http, "called id={}, name={}, value={}, mode={}", id, name ? name : "(null)",
|
|
value ? value : "(null)", mode);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (mode != ORBIS_HTTP_HEADER_OVERWRITE && mode != ORBIS_HTTP_HEADER_ADD) {
|
|
LOG_ERROR(Lib_Http, "Invalid mode={} (must be OVERWRITE=0 or ADD=1)", mode);
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
if (!name || !value) {
|
|
LOG_ERROR(Lib_Http, "name or value is null");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
const char* level = "";
|
|
auto* headers = ResolveHeaders(id, level);
|
|
if (!headers) {
|
|
LOG_ERROR(Lib_Http, "Invalid id={} (not a template, connection, or request)", id);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
if (mode == ORBIS_HTTP_HEADER_OVERWRITE) {
|
|
headers->erase(
|
|
std::remove_if(headers->begin(), headers->end(),
|
|
[&](const auto& kv) { return HeaderNameMatches(kv.first, name); }),
|
|
headers->end());
|
|
}
|
|
headers->emplace_back(name, value);
|
|
LOG_INFO(Lib_Http, "added header at {} id={}: {}: {} (mode={}, total now {})", level, id, name,
|
|
value, mode, headers->size());
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpRemoveRequestHeader(int id, const char* name) {
|
|
LOG_INFO(Lib_Http, "called id={}, name={}", id, name ? name : "(null)");
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (!name) {
|
|
LOG_ERROR(Lib_Http, "name is null");
|
|
return ORBIS_HTTP_ERROR_NOT_FOUND;
|
|
}
|
|
const char* level = "";
|
|
auto* headers = ResolveHeaders(id, level);
|
|
if (!headers) {
|
|
LOG_ERROR(Lib_Http, "Invalid id={} (not a template, connection, or request)", id);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
// Remove ALL entries with this name (case-insensitive)
|
|
auto new_end = std::remove_if(headers->begin(), headers->end(), [&](const auto& kv) {
|
|
return HeaderNameMatches(kv.first, name);
|
|
});
|
|
if (new_end == headers->end()) {
|
|
LOG_INFO(Lib_Http, "no header '{}' found at {} id={}", name, level, id);
|
|
return ORBIS_HTTP_ERROR_NOT_FOUND;
|
|
}
|
|
size_t removed = std::distance(new_end, headers->end());
|
|
headers->erase(new_end, headers->end());
|
|
LOG_INFO(Lib_Http, "removed {} occurrence(s) of '{}' from {} id={} (total now {})", removed,
|
|
name, level, id, headers->size());
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetRequestContentLength(int id, u64 contentLength) {
|
|
LOG_INFO(Lib_Http, "called id={}, contentLength={}", id, contentLength);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
auto it = g_state.requests.find(id);
|
|
if (it == g_state.requests.end()) {
|
|
LOG_ERROR(Lib_Http, "Invalid reqId={}", id);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
if (it->second->state != HttpRequestState::Created) {
|
|
LOG_ERROR(Lib_Http, "reqId={} already sent or in-flight; cannot set content length", id);
|
|
return ORBIS_HTTP_ERROR_BUSY;
|
|
}
|
|
it->second->content_length = contentLength;
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
//***********************************
|
|
// Redirection setting functions
|
|
//***********************************
|
|
int PS4_SYSV_ABI sceHttpGetAutoRedirect(int id, int* isEnable) {
|
|
LOG_INFO(Lib_Http, "called id={}, isEnable={}", id, fmt::ptr(isEnable));
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (!isEnable) {
|
|
LOG_ERROR(Lib_Http, "Invalid Value");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
const char* level = "";
|
|
HttpSettings* s = ResolveSettings(id, level);
|
|
if (!s) {
|
|
LOG_ERROR(Lib_Http, "Invalid Id");
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
*isEnable = s->auto_redirect ? 1 : 0;
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetAutoRedirect(int id, int isEnable) {
|
|
LOG_INFO(Lib_Http, "called id={}, isEnable={}", id, isEnable);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
const char* level = "";
|
|
HttpSettings* s = ResolveSettings(id, level);
|
|
if (!s) {
|
|
LOG_ERROR(Lib_Http, "Invalid Id");
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
s->auto_redirect = (isEnable != 0);
|
|
LOG_INFO(Lib_Http, "auto_redirect={} at {} level (id={})", s->auto_redirect, level, id);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
//***********************************
|
|
// Timeout setting functions
|
|
//***********************************
|
|
int PS4_SYSV_ABI sceHttpSetResolveRetry(int id, int retry) {
|
|
LOG_INFO(Lib_Http, "called id={}, retry={}", id, retry);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (retry < 0) {
|
|
LOG_ERROR(Lib_Http, "Invalid retry={} (must be >= 0)", retry);
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
const char* level = "";
|
|
HttpSettings* s = ResolveSettings(id, level);
|
|
if (!s) {
|
|
LOG_ERROR(Lib_Http, "Invalid id={}", id);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
s->resolve_retry = retry;
|
|
LOG_INFO(Lib_Http, "set {} id={} resolve_retry={}", level, id, retry);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetConnectTimeOut(int id, u32 usec) {
|
|
LOG_INFO(Lib_Http, "called id={}, usec={}", id, usec);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
const char* level = "";
|
|
HttpSettings* s = ResolveSettings(id, level);
|
|
if (!s) {
|
|
LOG_ERROR(Lib_Http, "Invalid Id");
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
s->connect_timeout_us = usec;
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetSendTimeOut(int id, u32 usec) {
|
|
LOG_INFO(Lib_Http, "called id={}, usec={}", id, usec);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
const char* level = "";
|
|
HttpSettings* s = ResolveSettings(id, level);
|
|
if (!s) {
|
|
LOG_ERROR(Lib_Http, "Invalid Id");
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
s->send_timeout_us = usec;
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpSetRecvTimeOut(int id, u32 usec) {
|
|
LOG_INFO(Lib_Http, "called id={}, usec={}", id, usec);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
const char* level = "";
|
|
HttpSettings* s = ResolveSettings(id, level);
|
|
if (!s) {
|
|
LOG_ERROR(Lib_Http, "Invalid Id");
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
s->recv_timeout_us = usec;
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
//***********************************
|
|
// Connection functions
|
|
//***********************************
|
|
int PS4_SYSV_ABI sceHttpDeleteConnection(int connId) {
|
|
LOG_INFO(Lib_Http, "called connId={}", connId);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (g_state.connections.erase(connId) == 0) {
|
|
LOG_ERROR(Lib_Http, "Invalid connId={}", connId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
//***********************************
|
|
// Template functions
|
|
//***********************************
|
|
int PS4_SYSV_ABI sceHttpDeleteTemplate(int tmplId) {
|
|
LOG_INFO(Lib_Http, "called tmplId={}", tmplId);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (g_state.templates.erase(tmplId) == 0) {
|
|
LOG_ERROR(Lib_Http, "Invalid tmplId={}", tmplId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
//***********************************
|
|
// Request functions
|
|
//***********************************
|
|
int PS4_SYSV_ABI sceHttpDeleteRequest(int reqId) {
|
|
LOG_INFO(Lib_Http, "called reqId={}", reqId);
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
auto it = g_state.requests.find(reqId);
|
|
if (it == g_state.requests.end()) {
|
|
LOG_ERROR(Lib_Http, "Invalid reqId={}", reqId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
auto req_ptr = it->second;
|
|
if (req_ptr->state == HttpRequestState::Created) {
|
|
LOG_INFO(Lib_Http,
|
|
"reqId={} abandoned before sceHttpSendRequest (state=Created); "
|
|
"{} headers, content_length={} were prepared but never transmitted",
|
|
reqId, req_ptr->headers.size(), req_ptr->content_length);
|
|
}
|
|
req_ptr->deleted = true;
|
|
req_ptr->state = HttpRequestState::Aborted;
|
|
req_ptr->cv.notify_all();
|
|
g_state.requests.erase(it);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpCreateRequest2(int connId, const char* method, const char* path,
|
|
u64 contentLength) {
|
|
LOG_INFO(Lib_Http, "called connId={}, method={}, path={}, contentLength={}", connId,
|
|
method ? method : "(null)", path ? path : "(null)", contentLength);
|
|
auto map_method = [](const char* m) -> int {
|
|
if (!m)
|
|
return -1;
|
|
std::string s = m;
|
|
if (s == "GET")
|
|
return ORBIS_HTTP_METHOD_GET;
|
|
if (s == "POST")
|
|
return ORBIS_HTTP_METHOD_POST;
|
|
if (s == "HEAD")
|
|
return ORBIS_HTTP_METHOD_HEAD;
|
|
if (s == "PUT")
|
|
return ORBIS_HTTP_METHOD_PUT;
|
|
if (s == "DELETE")
|
|
return ORBIS_HTTP_METHOD_DELETE;
|
|
if (s == "TRACE")
|
|
return ORBIS_HTTP_METHOD_TRACE;
|
|
return -1;
|
|
};
|
|
// Resolve the connection's URL under the lock, then drop the lock before
|
|
// delegating to sceHttpCreateRequestWithURL
|
|
std::string url;
|
|
int int_method;
|
|
{
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
auto it = g_state.connections.find(connId);
|
|
if (it == g_state.connections.end()) {
|
|
LOG_ERROR(Lib_Http, "Invalid connId={}", connId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
if (!path) {
|
|
LOG_ERROR(Lib_Http, "path is null");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
if (ContainsCrLf(path)) {
|
|
LOG_ERROR(Lib_Http, "path contains CR/LF (CRLF-injection rejected): {}", path);
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
int_method = map_method(method);
|
|
if (int_method < 0) {
|
|
if (!method) {
|
|
LOG_ERROR(Lib_Http, "method is null");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
LOG_INFO(Lib_Http, "method '{}' not in standard table; routing via CUSTOM slot",
|
|
method);
|
|
int_method = ORBIS_HTTP_METHOD_CUSTOM;
|
|
}
|
|
const auto& conn = it->second;
|
|
url = conn.scheme + "://" + conn.hostname + ":" + std::to_string(conn.port);
|
|
if (path[0] != '\0') {
|
|
if (path[0] != '/') {
|
|
url.push_back('/');
|
|
}
|
|
url.append(path);
|
|
}
|
|
}
|
|
int reqId = sceHttpCreateRequestWithURL(connId, int_method, url.c_str(), contentLength);
|
|
if (reqId > 0 && method) {
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
auto it = g_state.requests.find(reqId);
|
|
if (it != g_state.requests.end()) {
|
|
it->second->method_str = method;
|
|
}
|
|
}
|
|
return reqId;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpCreateRequestWithURL2(int connId, const char* method, const char* url,
|
|
u64 contentLength) {
|
|
LOG_INFO(Lib_Http, "called connId={}, method={}, url={}, contentLength={}", connId,
|
|
method ? method : "(null)", url ? url : "(null)", contentLength);
|
|
int int_method;
|
|
{
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (!g_state.connections.contains(connId)) {
|
|
LOG_ERROR(Lib_Http, "Invalid connId={}", connId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
if (!method) {
|
|
LOG_ERROR(Lib_Http, "method is null");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
std::string s = method;
|
|
if (s == "GET")
|
|
int_method = ORBIS_HTTP_METHOD_GET;
|
|
else if (s == "POST")
|
|
int_method = ORBIS_HTTP_METHOD_POST;
|
|
else if (s == "HEAD")
|
|
int_method = ORBIS_HTTP_METHOD_HEAD;
|
|
else if (s == "PUT")
|
|
int_method = ORBIS_HTTP_METHOD_PUT;
|
|
else if (s == "DELETE")
|
|
int_method = ORBIS_HTTP_METHOD_DELETE;
|
|
else if (s == "TRACE")
|
|
int_method = ORBIS_HTTP_METHOD_TRACE;
|
|
else {
|
|
LOG_INFO(Lib_Http, "method '{}' not in standard table; routing via CUSTOM slot",
|
|
method);
|
|
int_method = ORBIS_HTTP_METHOD_CUSTOM;
|
|
}
|
|
}
|
|
int reqId = sceHttpCreateRequestWithURL(connId, int_method, url, contentLength);
|
|
if (reqId > 0) {
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
auto it = g_state.requests.find(reqId);
|
|
if (it != g_state.requests.end()) {
|
|
it->second->method_str = method;
|
|
}
|
|
}
|
|
return reqId;
|
|
}
|
|
|
|
//***********************************
|
|
// Error Obtainment functions
|
|
//***********************************
|
|
int PS4_SYSV_ABI sceHttpGetLastErrno(int reqId, int* errNum) {
|
|
LOG_INFO(Lib_Http, "called reqId={}, errNum={}", reqId, fmt::ptr(errNum));
|
|
std::lock_guard<std::mutex> lock(g_state.m_mutex);
|
|
if (!g_state.inited) {
|
|
LOG_ERROR(Lib_Http, "Not initialized");
|
|
return ORBIS_HTTP_ERROR_BEFORE_INIT;
|
|
}
|
|
if (!errNum) {
|
|
LOG_ERROR(Lib_Http, "errNum output pointer is null");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
auto it = g_state.requests.find(reqId);
|
|
if (it == g_state.requests.end()) {
|
|
LOG_DEBUG(Lib_Http, "Invalid reqId={}", reqId);
|
|
return ORBIS_HTTP_ERROR_INVALID_ID;
|
|
}
|
|
*errNum = it->second->last_errno;
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
//***********************************
|
|
// HTTP Header Parsing functions
|
|
//***********************************
|
|
int PS4_SYSV_ABI sceHttpParseStatusLine(const char* statusLine, u64 lineLen, int32_t* httpMajorVer,
|
|
int32_t* httpMinorVer, int32_t* responseCode,
|
|
const char** reasonPhrase, u64* phraseLen) {
|
|
LOG_INFO(Lib_Http,
|
|
"called statusLine={}, lineLen={}, httpMajorVer={}, httpMinorVer={}, responseCode={}, "
|
|
"reasonPhrase={}, phraseLen={}",
|
|
fmt::ptr(statusLine), lineLen, fmt::ptr(httpMajorVer), fmt::ptr(httpMinorVer),
|
|
fmt::ptr(responseCode), fmt::ptr(reasonPhrase), fmt::ptr(phraseLen));
|
|
|
|
if (!statusLine) {
|
|
LOG_ERROR(Lib_Http, "Invalid Response");
|
|
return ORBIS_HTTP_ERROR_PARSE_HTTP_INVALID_RESPONSE;
|
|
}
|
|
if (!httpMajorVer || !httpMinorVer || !responseCode || !reasonPhrase || !phraseLen) {
|
|
LOG_ERROR(Lib_Http, "Invalid value");
|
|
return ORBIS_HTTP_ERROR_PARSE_HTTP_INVALID_VALUE;
|
|
}
|
|
|
|
*httpMajorVer = 0;
|
|
*httpMinorVer = 0;
|
|
|
|
if (lineLen < 8) {
|
|
return ORBIS_HTTP_ERROR_PARSE_HTTP_INVALID_RESPONSE;
|
|
}
|
|
if (memcmp(statusLine, "HTTP/", 5) != 0) {
|
|
return ORBIS_HTTP_ERROR_PARSE_HTTP_INVALID_RESPONSE;
|
|
}
|
|
|
|
auto isAsciiDigit = [](char c) -> bool {
|
|
const unsigned char uc = static_cast<unsigned char>(c);
|
|
return uc < 0x80 && std::isdigit(uc);
|
|
};
|
|
|
|
// First byte of major version
|
|
if (!isAsciiDigit(statusLine[5])) {
|
|
return ORBIS_HTTP_ERROR_PARSE_HTTP_INVALID_RESPONSE;
|
|
}
|
|
|
|
// Major version digit loop
|
|
u64 index = 7;
|
|
{
|
|
unsigned char ch = static_cast<unsigned char>(statusLine[5]);
|
|
while (ch < 0x80 && std::isdigit(ch)) {
|
|
*httpMajorVer = *httpMajorVer * 10 + (statusLine[index - 2] - '0');
|
|
const char next = statusLine[index - 1];
|
|
index++;
|
|
if (static_cast<unsigned char>(next) >= 0x80) {
|
|
return ORBIS_HTTP_ERROR_PARSE_HTTP_INVALID_RESPONSE;
|
|
}
|
|
ch = static_cast<unsigned char>(next);
|
|
}
|
|
}
|
|
|
|
// After major loop, the previously-loaded byte must be '.'.
|
|
if (statusLine[index - 2] != '.') {
|
|
return ORBIS_HTTP_ERROR_PARSE_HTTP_INVALID_RESPONSE;
|
|
}
|
|
|
|
// First byte of minor version
|
|
if (!isAsciiDigit(statusLine[index - 1])) {
|
|
return ORBIS_HTTP_ERROR_PARSE_HTTP_INVALID_RESPONSE;
|
|
}
|
|
|
|
// Minor version digit loop
|
|
{
|
|
unsigned char ch = static_cast<unsigned char>(statusLine[index - 1]);
|
|
while (ch < 0x80 && std::isdigit(ch)) {
|
|
*httpMinorVer = *httpMinorVer * 10 + (statusLine[index - 1] - '0');
|
|
const char next = statusLine[index];
|
|
index++;
|
|
if (static_cast<unsigned char>(next) >= 0x80) {
|
|
return ORBIS_HTTP_ERROR_PARSE_HTTP_INVALID_RESPONSE;
|
|
}
|
|
ch = static_cast<unsigned char>(next);
|
|
}
|
|
}
|
|
|
|
// After minor loop, statusLine[index - 1] must be ' '.
|
|
if (statusLine[index - 1] != ' ') {
|
|
return ORBIS_HTTP_ERROR_PARSE_HTTP_INVALID_RESPONSE;
|
|
}
|
|
|
|
// Need >=3 bytes for the response code
|
|
const u64 remaining = lineLen - index;
|
|
if (remaining < 3) {
|
|
return ORBIS_HTTP_ERROR_PARSE_HTTP_INVALID_RESPONSE;
|
|
}
|
|
|
|
// Validate and parse the 3-digit response code
|
|
for (int i = 0; i < 3; ++i) {
|
|
if (!isAsciiDigit(statusLine[index + i])) {
|
|
return ORBIS_HTTP_ERROR_PARSE_HTTP_INVALID_RESPONSE;
|
|
}
|
|
}
|
|
*responseCode = (statusLine[index] - '0') * 100 + (statusLine[index + 1] - '0') * 10 +
|
|
(statusLine[index + 2] - '0');
|
|
|
|
const char* phraseStart = statusLine + index + 3;
|
|
const u64 maxScan = remaining - 3;
|
|
for (u64 scanLen = 0; scanLen <= maxScan; ++scanLen) {
|
|
if (phraseStart[scanLen] != '\n') {
|
|
continue;
|
|
}
|
|
*reasonPhrase = phraseStart;
|
|
if (scanLen == 0) {
|
|
*phraseLen = 0;
|
|
} else {
|
|
*phraseLen = scanLen - (phraseStart[scanLen - 1] == '\r' ? 1 : 0);
|
|
}
|
|
const u64 bytesConsumed = (phraseStart - statusLine) + scanLen + 1;
|
|
LOG_INFO(Lib_Http, "parsed HTTP/{}.{} {}, phraseLen={}, bytes consumed={}", *httpMajorVer,
|
|
*httpMinorVer, *responseCode, *phraseLen, bytesConsumed);
|
|
return static_cast<int>(bytesConsumed);
|
|
}
|
|
|
|
LOG_ERROR(Lib_Http, "no '\\n' found in status line");
|
|
return ORBIS_HTTP_ERROR_PARSE_HTTP_INVALID_RESPONSE;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpParseResponseHeader(const char* header, u64 headerLen, const char* fieldStr,
|
|
const char** fieldValue, u64* valueLen) {
|
|
LOG_TRACE(Lib_Http, "called header={}, headerLen={}, fieldStr={}, fieldValue={}, valueLen={}",
|
|
fmt::ptr(header), headerLen, fieldStr ? fieldStr : "(null)", fmt::ptr(fieldValue),
|
|
fmt::ptr(valueLen));
|
|
|
|
if (!header) {
|
|
LOG_ERROR(Lib_Http, "Invalid response");
|
|
return ORBIS_HTTP_ERROR_PARSE_HTTP_INVALID_RESPONSE;
|
|
}
|
|
if (!fieldStr || !fieldValue || !valueLen) {
|
|
LOG_ERROR(Lib_Http, "Invalid value");
|
|
return ORBIS_HTTP_ERROR_PARSE_HTTP_INVALID_VALUE;
|
|
}
|
|
|
|
const u64 fieldStrLen = strnlen(fieldStr, 0xfff);
|
|
|
|
auto isAsciiSpace = [](unsigned char c) -> bool { return c < 0x80 && std::isspace(c) != 0; };
|
|
auto caseInsensitiveEq = [](const char* a, const char* b, u64 n) -> bool {
|
|
for (u64 i = 0; i < n; ++i) {
|
|
if (std::tolower(static_cast<unsigned char>(a[i])) !=
|
|
std::tolower(static_cast<unsigned char>(b[i])))
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
|
|
bool atLineStart = true;
|
|
u64 valueOffset = 0;
|
|
bool found = false;
|
|
|
|
if (headerLen != 0) {
|
|
u64 cur = 0;
|
|
u64 next = 1;
|
|
while (true) {
|
|
if (atLineStart) {
|
|
const unsigned char first = static_cast<unsigned char>(header[cur]);
|
|
if (!isAsciiSpace(first)) {
|
|
if (fieldStrLen < headerLen - cur &&
|
|
caseInsensitiveEq(fieldStr, header + cur, fieldStrLen) &&
|
|
header[cur + fieldStrLen] == ':') {
|
|
// Found.
|
|
valueOffset = cur + fieldStrLen + 1;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
atLineStart = (header[cur] == '\n');
|
|
cur = next;
|
|
next += 1;
|
|
if (cur >= headerLen)
|
|
break;
|
|
}
|
|
}
|
|
if (!found) {
|
|
return ORBIS_HTTP_ERROR_PARSE_HTTP_NOT_FOUND;
|
|
}
|
|
|
|
while (valueOffset < headerLen) {
|
|
const unsigned char c = static_cast<unsigned char>(header[valueOffset]);
|
|
if (!isAsciiSpace(c))
|
|
break;
|
|
if (c == '\n') {
|
|
// Past EOL with only whitespace seen. Firmware advances one more
|
|
// and exits the loop so the value scan starts past the '\n'.
|
|
valueOffset++;
|
|
break;
|
|
}
|
|
valueOffset++;
|
|
}
|
|
|
|
u64 valueStart = valueOffset;
|
|
u64 scan = valueOffset;
|
|
u64 lineEnd = valueOffset; // points one past the '\n' of the final line
|
|
u64 lengthEnd = valueOffset; // where the trimmed value ends (strips trailing \r)
|
|
|
|
if (valueOffset < headerLen) {
|
|
bool sawCR = false;
|
|
while (scan < headerLen) {
|
|
// Walk to next '\n'.
|
|
while (scan < headerLen && header[scan] != '\n') {
|
|
scan++;
|
|
}
|
|
if (scan >= headerLen) {
|
|
// No '\n' before end of buffer: value runs to headerLen.
|
|
lengthEnd = headerLen;
|
|
lineEnd = headerLen;
|
|
break;
|
|
}
|
|
// scan points at '\n'. Note trailing '\r'.
|
|
sawCR = (scan > valueStart && header[scan - 1] == '\r');
|
|
const u64 afterLF = scan + 1;
|
|
// Check for line folding: next byte is SP or HT.
|
|
if (afterLF < headerLen && (header[afterLF] == ' ' || header[afterLF] == '\t')) {
|
|
// Continuation - keep scanning.
|
|
scan = afterLF;
|
|
continue;
|
|
}
|
|
// End of value.
|
|
lineEnd = afterLF;
|
|
lengthEnd = sawCR ? (scan - 1) : scan;
|
|
break;
|
|
}
|
|
} else {
|
|
lineEnd = headerLen;
|
|
lengthEnd = headerLen;
|
|
}
|
|
|
|
const u64 finalLen = (lengthEnd > valueStart) ? (lengthEnd - valueStart) : 0;
|
|
if (finalLen == 0) {
|
|
*fieldValue = nullptr;
|
|
*valueLen = 0;
|
|
return 0;
|
|
}
|
|
|
|
*fieldValue = header + valueStart;
|
|
*valueLen = finalLen;
|
|
return static_cast<int>(lineEnd);
|
|
}
|
|
|
|
//***********************************
|
|
// URI functions
|
|
//***********************************
|
|
int PS4_SYSV_ABI sceHttpUriBuild(char* out, u64* require, u64 prepare,
|
|
const OrbisHttpUriElement* srcElement, u32 option) {
|
|
LOG_INFO(Lib_Http, "called out={}, require={}, prepare={}, srcElement={}, option={:#x}",
|
|
fmt::ptr(out), fmt::ptr(require), prepare, fmt::ptr(srcElement), option);
|
|
|
|
if (srcElement == nullptr) {
|
|
LOG_ERROR(Lib_Http, "Invalid url");
|
|
return ORBIS_HTTP_ERROR_INVALID_URL;
|
|
}
|
|
if (out == nullptr && require == nullptr) {
|
|
LOG_ERROR(Lib_Http, "Invalid value");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
|
|
auto field = [](const char* p) -> std::string_view {
|
|
return p ? std::string_view(p) : std::string_view{};
|
|
};
|
|
|
|
const std::string_view scheme = field(srcElement->scheme);
|
|
const std::string_view username = field(srcElement->username);
|
|
const std::string_view password = field(srcElement->password);
|
|
const std::string_view hostname = field(srcElement->hostname);
|
|
const std::string_view path = field(srcElement->path);
|
|
const std::string_view query = field(srcElement->query);
|
|
const std::string_view fragment = field(srcElement->fragment);
|
|
|
|
auto schemeDefaultPort = [&]() -> uint16_t {
|
|
if (scheme.size() > 0x20)
|
|
return 0;
|
|
auto prefixCaseEq = [&](const char* target) {
|
|
const size_t tlen = std::strlen(target);
|
|
if (scheme.size() < tlen)
|
|
return false;
|
|
for (size_t i = 0; i < tlen; ++i) {
|
|
if (std::tolower(static_cast<unsigned char>(scheme[i])) !=
|
|
std::tolower(static_cast<unsigned char>(target[i])))
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
if (prefixCaseEq("HTTPS"))
|
|
return 443;
|
|
if (prefixCaseEq("HTTP"))
|
|
return 80;
|
|
if (prefixCaseEq("TTP"))
|
|
return 80;
|
|
return 0;
|
|
};
|
|
|
|
const bool isMailto = (scheme.size() == 6) && std::memcmp(scheme.data(), "mailto", 6) == 0;
|
|
|
|
std::string built;
|
|
built.reserve(256);
|
|
|
|
// Scheme: write "<scheme>:"
|
|
if ((option & ORBIS_HTTP_URI_BUILD_WITH_SCHEME) && !scheme.empty()) {
|
|
built.append(scheme);
|
|
built.push_back(':');
|
|
}
|
|
if (!srcElement->opaque) {
|
|
built.append("//");
|
|
}
|
|
|
|
// Userinfo (username[:password]@)
|
|
const bool hasUser = (option & ORBIS_HTTP_URI_BUILD_WITH_USERNAME) && !username.empty();
|
|
const bool hasPass = (option & ORBIS_HTTP_URI_BUILD_WITH_PASSWORD) && !password.empty();
|
|
if (hasUser) {
|
|
built.append(username);
|
|
}
|
|
if (hasPass) {
|
|
built.push_back(':');
|
|
built.append(password);
|
|
}
|
|
if (hasUser || hasPass) {
|
|
built.push_back('@');
|
|
}
|
|
|
|
// Host
|
|
if ((option & ORBIS_HTTP_URI_BUILD_WITH_HOSTNAME) && !hostname.empty()) {
|
|
built.append(hostname);
|
|
}
|
|
|
|
// Port: only if (a) we have one, (b) it isn't the scheme's default, and (c) scheme isn't
|
|
// mailto.
|
|
if ((option & ORBIS_HTTP_URI_BUILD_WITH_PORT) && srcElement->port != 0) {
|
|
const uint16_t def = schemeDefaultPort();
|
|
const bool skip = (def != 0 || isMailto) && (def == srcElement->port);
|
|
if (!skip) {
|
|
built.push_back(':');
|
|
built.append(std::to_string(srcElement->port));
|
|
}
|
|
}
|
|
|
|
// Path / Query / Fragment
|
|
if ((option & ORBIS_HTTP_URI_BUILD_WITH_PATH) && !path.empty()) {
|
|
built.append(path);
|
|
}
|
|
if ((option & ORBIS_HTTP_URI_BUILD_WITH_QUERY) && !query.empty()) {
|
|
built.append(query);
|
|
}
|
|
if ((option & ORBIS_HTTP_URI_BUILD_WITH_FRAGMENT) && !fragment.empty()) {
|
|
built.append(fragment);
|
|
}
|
|
|
|
// include null terminator in the required size.
|
|
const size_t need = built.size() + 1;
|
|
if (require) {
|
|
*require = need;
|
|
}
|
|
|
|
if (out == nullptr) {
|
|
// Size query mode (no buffer provided).
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
if (prepare < need) {
|
|
return ORBIS_HTTP_ERROR_OUT_OF_MEMORY; // buffer too small
|
|
}
|
|
|
|
std::memcpy(out, built.c_str(), need);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpUriEscape(char* out, u64* require, u64 prepare, const char* in) {
|
|
LOG_TRACE(Lib_Http, "called out={}, require={}, prepare={}, in={}", fmt::ptr(out),
|
|
fmt::ptr(require), prepare, in ? in : "(null)");
|
|
|
|
if (!in) {
|
|
LOG_ERROR(Lib_Http, "Invalid input string");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
|
|
auto IsUnreserved = [](unsigned char c) -> bool {
|
|
return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') ||
|
|
c == '-' || c == '_' || c == '.' || c == '~';
|
|
};
|
|
|
|
u64 needed = 0;
|
|
const char* src = in;
|
|
while (*src) {
|
|
unsigned char c = static_cast<unsigned char>(*src);
|
|
if (IsUnreserved(c)) {
|
|
needed++;
|
|
} else {
|
|
needed += 3; // %XX format
|
|
}
|
|
src++;
|
|
}
|
|
needed++; // null terminator
|
|
|
|
if (require) {
|
|
*require = needed;
|
|
}
|
|
|
|
if (!out) {
|
|
LOG_INFO(Lib_Http, "out is null, only computing required size: {}", needed);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
if (prepare < needed) {
|
|
LOG_ERROR(Lib_Http, "Buffer too small: need {} but only {} available", needed, prepare);
|
|
return ORBIS_HTTP_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
static const char hex_chars[] = "0123456789ABCDEF";
|
|
src = in;
|
|
char* dst = out;
|
|
while (*src) {
|
|
unsigned char c = static_cast<unsigned char>(*src);
|
|
if (IsUnreserved(c)) {
|
|
*dst++ = *src;
|
|
} else {
|
|
*dst++ = '%';
|
|
*dst++ = hex_chars[(c >> 4) & 0x0F];
|
|
*dst++ = hex_chars[c & 0x0F];
|
|
}
|
|
src++;
|
|
}
|
|
*dst = '\0';
|
|
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpUriMerge(char* mergedUrl, char* url, char* relativeUri, u64* require,
|
|
u64 prepare, u32 option) {
|
|
LOG_TRACE(Lib_Http,
|
|
"called mergedUrl={}, url={}, relativeUri={}, require={}, prepare={}, option={:#x}",
|
|
fmt::ptr(mergedUrl), url ? url : "(null)", relativeUri ? relativeUri : "(null)",
|
|
fmt::ptr(require), prepare, option);
|
|
|
|
u64 requiredLength;
|
|
int returnValue;
|
|
u64 baseUrlLength;
|
|
u64 relativeUriLength;
|
|
u64 totalLength;
|
|
u64 combinedLength;
|
|
int parseResult;
|
|
u64 localSizeRelativeUri;
|
|
u64 localSizeBaseUrl;
|
|
OrbisHttpUriElement parsedUriElement;
|
|
|
|
if (option != 0 || url == NULL || relativeUri == NULL) {
|
|
LOG_ERROR(Lib_Http, "Invalid value: option={:#x}, url={}, relativeUri={}", option,
|
|
fmt::ptr(url), fmt::ptr(relativeUri));
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
|
|
returnValue = sceHttpUriParse(NULL, url, NULL, &localSizeBaseUrl, 0);
|
|
if (returnValue < 0) {
|
|
LOG_ERROR(Lib_Http, "sceHttpUriParse(url) returned {:#x}", returnValue);
|
|
return returnValue;
|
|
}
|
|
|
|
returnValue = sceHttpUriParse(NULL, relativeUri, NULL, &localSizeRelativeUri, 0);
|
|
if (returnValue < 0) {
|
|
LOG_ERROR(Lib_Http, "sceHttpUriParse(relativeUri) returned {:#x}", returnValue);
|
|
return returnValue;
|
|
}
|
|
|
|
baseUrlLength = strnlen(url, 0x3fff);
|
|
relativeUriLength = strnlen(relativeUri, 0x3fff);
|
|
requiredLength = localSizeBaseUrl + 2 + (relativeUriLength + baseUrlLength) * 2;
|
|
|
|
if (require) {
|
|
*require = requiredLength;
|
|
}
|
|
|
|
if (mergedUrl == NULL) {
|
|
LOG_INFO(Lib_Http, "mergedUrl is null, only returning required size: {}", requiredLength);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
if (prepare < requiredLength) {
|
|
LOG_ERROR(Lib_Http, "Out of memory: need {} but only {} available", requiredLength,
|
|
prepare);
|
|
return ORBIS_HTTP_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
totalLength = strnlen(url, 0x3fff);
|
|
baseUrlLength = strnlen(relativeUri, 0x3fff);
|
|
combinedLength = totalLength + 1 + baseUrlLength;
|
|
relativeUriLength = prepare - combinedLength;
|
|
|
|
returnValue =
|
|
sceHttpUriParse(&parsedUriElement, relativeUri, mergedUrl + totalLength + baseUrlLength + 1,
|
|
&localSizeRelativeUri, relativeUriLength);
|
|
if (returnValue < 0) {
|
|
LOG_ERROR(Lib_Http, "second sceHttpUriParse(relativeUri) returned {:#x}", returnValue);
|
|
return returnValue;
|
|
}
|
|
|
|
if (!parsedUriElement.opaque) {
|
|
strncpy(mergedUrl, relativeUri, requiredLength);
|
|
if (require) {
|
|
*require = strnlen(relativeUri, 0x3fff) + 1;
|
|
}
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
returnValue =
|
|
sceHttpUriParse(&parsedUriElement, url, mergedUrl + totalLength + baseUrlLength + 1,
|
|
&localSizeBaseUrl, relativeUriLength);
|
|
if (returnValue < 0) {
|
|
LOG_ERROR(Lib_Http, "second sceHttpUriParse(url) returned {:#x}", returnValue);
|
|
return returnValue;
|
|
}
|
|
|
|
combinedLength += localSizeBaseUrl;
|
|
strncpy(mergedUrl + combinedLength, parsedUriElement.path, prepare - combinedLength);
|
|
NormalizeAndAppendPath(mergedUrl + combinedLength, relativeUri);
|
|
|
|
parsedUriElement.path = mergedUrl + combinedLength;
|
|
|
|
returnValue = sceHttpUriBuild(mergedUrl, 0, ~(baseUrlLength + totalLength) + prepare,
|
|
&parsedUriElement, 0x3f);
|
|
if (returnValue >= 0) {
|
|
return ORBIS_OK;
|
|
} else {
|
|
LOG_ERROR(Lib_Http, "sceHttpUriBuild returned {:#x}", returnValue);
|
|
return returnValue;
|
|
}
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpUriParse(OrbisHttpUriElement* out, const char* srcUri, void* pool,
|
|
u64* require, u64 prepare) {
|
|
LOG_TRACE(Lib_Http, "called out={}, srcUri={}, pool={}, require={}, prepare={}", fmt::ptr(out),
|
|
srcUri ? srcUri : "(null)", fmt::ptr(pool), fmt::ptr(require), prepare);
|
|
if (!srcUri) {
|
|
LOG_ERROR(Lib_Http, "invalid url: srcUri is null");
|
|
return ORBIS_HTTP_ERROR_INVALID_URL;
|
|
}
|
|
const bool writeOutput = (out != nullptr) && (pool != nullptr);
|
|
if (!writeOutput && !require) {
|
|
LOG_ERROR(Lib_Http, "Invalid value");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
|
|
if (writeOutput) {
|
|
memset(out, 0, sizeof(OrbisHttpUriElement));
|
|
}
|
|
|
|
char* poolBytes = (char*)pool;
|
|
|
|
bool hasScheme = false;
|
|
u64 schemeLen = 0;
|
|
{
|
|
u64 i = 0;
|
|
while (i < 0x20 && srcUri[i]) {
|
|
if (srcUri[i] == ':')
|
|
break;
|
|
const unsigned char c = static_cast<unsigned char>(srcUri[i]);
|
|
if (!isalnum(c) && c != '+' && c != '-' && c != '.')
|
|
break;
|
|
i++;
|
|
}
|
|
if (i > 0 && srcUri[i] == ':' && isalpha(static_cast<unsigned char>(srcUri[0]))) {
|
|
hasScheme = true;
|
|
schemeLen = i;
|
|
}
|
|
}
|
|
|
|
u64 poolUsed; // bytes used in pool
|
|
u64 inputOffset; // current position in input string
|
|
|
|
if (hasScheme) {
|
|
if (writeOutput) {
|
|
if (prepare < schemeLen + 1) {
|
|
LOG_ERROR(Lib_Http, "Out of memory");
|
|
return ORBIS_HTTP_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
memcpy(poolBytes, srcUri, schemeLen);
|
|
poolBytes[schemeLen] = '\0';
|
|
out->scheme = poolBytes;
|
|
}
|
|
poolUsed = schemeLen + 1;
|
|
inputOffset = schemeLen + 1;
|
|
} else {
|
|
if (writeOutput) {
|
|
if (prepare < 2) {
|
|
LOG_ERROR(Lib_Http, "Out of memory");
|
|
return ORBIS_HTTP_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
poolBytes[0] = '\0';
|
|
out->scheme = poolBytes;
|
|
}
|
|
poolUsed = 1;
|
|
inputOffset = 0;
|
|
}
|
|
|
|
int slashCount = 0;
|
|
{
|
|
const char* p = srcUri + inputOffset;
|
|
while (*p == '/') {
|
|
slashCount++;
|
|
p++;
|
|
}
|
|
}
|
|
if (slashCount >= 2) {
|
|
inputOffset += 2;
|
|
// opaque stays at 0 from memset
|
|
} else {
|
|
if (writeOutput) {
|
|
out->opaque = true;
|
|
}
|
|
}
|
|
|
|
const char* authStart = srcUri + inputOffset;
|
|
u64 scanPos = 0; // current byte offset within the authority area
|
|
u64 colonPos = 0; // offset of the first ':' (only valid when seenColon)
|
|
bool seenColon = false;
|
|
bool seenAt = false;
|
|
u64 atPos = 0;
|
|
|
|
auto isUserinfoPunct = [](unsigned char c) -> bool {
|
|
switch (c) {
|
|
case 0x21:
|
|
case 0x24:
|
|
case 0x25:
|
|
case 0x26:
|
|
case 0x27:
|
|
case 0x28:
|
|
case 0x29:
|
|
case 0x2a:
|
|
case 0x2b:
|
|
case 0x2c:
|
|
case 0x2d:
|
|
case 0x2e:
|
|
case 0x3a:
|
|
case 0x3b:
|
|
case 0x3d:
|
|
case 0x5f:
|
|
case 0x7e:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
};
|
|
|
|
while (true) {
|
|
const unsigned char c = static_cast<unsigned char>(authStart[scanPos]);
|
|
if (c == 0)
|
|
break;
|
|
if (c == '@') {
|
|
seenAt = true;
|
|
atPos = scanPos;
|
|
break;
|
|
}
|
|
if (!seenColon && c == ':') {
|
|
seenColon = true;
|
|
colonPos = scanPos;
|
|
} else {
|
|
if ((signed char)c < 0)
|
|
break;
|
|
if (!isalnum(c) && !isUserinfoPunct(c))
|
|
break;
|
|
}
|
|
scanPos++;
|
|
}
|
|
|
|
// Write user/password to pool.
|
|
char* userDest = poolBytes + poolUsed;
|
|
u64 inputAdvance = 0;
|
|
|
|
if (seenAt) {
|
|
u64 passOffset;
|
|
u64 passLen;
|
|
u64 userLen;
|
|
if (seenColon) {
|
|
userLen = colonPos;
|
|
passOffset = colonPos + 1;
|
|
passLen = atPos - passOffset;
|
|
} else {
|
|
userLen = atPos;
|
|
passOffset = atPos + 1;
|
|
passLen = 0;
|
|
}
|
|
|
|
if (writeOutput) {
|
|
const u64 needed = passOffset + passLen + 1;
|
|
if (prepare - poolUsed < needed) {
|
|
return ORBIS_HTTP_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
memcpy(userDest, authStart, userLen);
|
|
userDest[userLen] = '\0';
|
|
memcpy(userDest + passOffset, authStart + passOffset, passLen);
|
|
userDest[passOffset + passLen] = '\0';
|
|
out->username = userDest;
|
|
out->password = userDest + passOffset;
|
|
}
|
|
poolUsed += passOffset + passLen + 1;
|
|
inputAdvance = atPos + 1;
|
|
} else {
|
|
if (writeOutput) {
|
|
if (prepare - poolUsed < 2) {
|
|
return ORBIS_HTTP_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
userDest[0] = '\0';
|
|
userDest[1] = '\0';
|
|
out->username = userDest;
|
|
out->password = userDest + 1;
|
|
}
|
|
poolUsed += 2;
|
|
}
|
|
|
|
inputOffset += inputAdvance;
|
|
|
|
char* hostDest = poolBytes + poolUsed;
|
|
const char* hostStart = srcUri + inputOffset;
|
|
const char firstHostChar = hostStart[0];
|
|
u64 hostScanLen = 0; // bytes scanned in input (including brackets)
|
|
u64 storedHostLen = 0; // bytes stored to pool
|
|
|
|
if (firstHostChar == '.') {
|
|
hostScanLen = 0;
|
|
storedHostLen = 0;
|
|
} else if (firstHostChar == '[') {
|
|
hostScanLen = 1;
|
|
while (true) {
|
|
if (hostScanLen == 0xff) {
|
|
return ORBIS_HTTP_ERROR_INVALID_URL;
|
|
}
|
|
const unsigned char c = static_cast<unsigned char>(hostStart[hostScanLen]);
|
|
if (c == 0)
|
|
break;
|
|
if ((signed char)c < 0)
|
|
break;
|
|
if (c == ']')
|
|
break;
|
|
// IPv6 mode allows ':' in addition to host chars
|
|
if (!isalnum(c) && c != '-' && c != '.' && c != '_' && c != ':')
|
|
break;
|
|
hostScanLen++;
|
|
}
|
|
if (hostStart[hostScanLen] != ']') {
|
|
return ORBIS_HTTP_ERROR_INVALID_URL;
|
|
}
|
|
storedHostLen = hostScanLen - 1;
|
|
hostScanLen++; // consume ']' for input advance
|
|
} else {
|
|
// Normal host scan: alphanumeric + '-' '.' '_'
|
|
while (true) {
|
|
if (hostScanLen == 0xff) {
|
|
return ORBIS_HTTP_ERROR_INVALID_URL;
|
|
}
|
|
const unsigned char c = static_cast<unsigned char>(hostStart[hostScanLen]);
|
|
if (c == 0)
|
|
break;
|
|
if ((signed char)c < 0)
|
|
break;
|
|
if (!isalnum(c) && c != '-' && c != '.' && c != '_')
|
|
break;
|
|
hostScanLen++;
|
|
}
|
|
storedHostLen = hostScanLen;
|
|
}
|
|
|
|
if (writeOutput) {
|
|
if (prepare - poolUsed < storedHostLen + 1) {
|
|
return ORBIS_HTTP_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
const char* hostCopySrc = (firstHostChar == '[') ? hostStart + 1 : hostStart;
|
|
memcpy(hostDest, hostCopySrc, storedHostLen);
|
|
hostDest[storedHostLen] = '\0';
|
|
out->hostname = hostDest;
|
|
}
|
|
poolUsed += storedHostLen + 1;
|
|
inputOffset += hostScanLen;
|
|
|
|
bool hasExplicitPort = false;
|
|
uint16_t portValue = 0;
|
|
|
|
if (srcUri[inputOffset] == ':') {
|
|
inputOffset++;
|
|
const char* digits = srcUri + inputOffset;
|
|
u64 digitsLen = 0;
|
|
u32 port32 = 0;
|
|
while (digitsLen < 5 && isdigit(static_cast<unsigned char>(digits[digitsLen]))) {
|
|
port32 = port32 * 10 + (digits[digitsLen] - '0');
|
|
digitsLen++;
|
|
}
|
|
if (port32 > 0x10000) {
|
|
LOG_ERROR(Lib_Http, "Invalid URL");
|
|
return ORBIS_HTTP_ERROR_INVALID_URL;
|
|
}
|
|
const char afterPort = digits[digitsLen];
|
|
if (afterPort != '\0' && afterPort != '/') {
|
|
return ORBIS_HTTP_ERROR_INVALID_URL;
|
|
}
|
|
if (digitsLen > 0) {
|
|
hasExplicitPort = true;
|
|
portValue = static_cast<uint16_t>(port32);
|
|
}
|
|
inputOffset += digitsLen;
|
|
}
|
|
|
|
if (writeOutput) {
|
|
if (hasExplicitPort) {
|
|
out->port = portValue;
|
|
} else if (out->scheme) {
|
|
const size_t schSize = std::strlen(out->scheme);
|
|
if (schSize <= 0x20) {
|
|
auto prefixCaseEq = [&](const char* target) {
|
|
const size_t tlen = std::strlen(target);
|
|
if (schSize < tlen)
|
|
return false;
|
|
for (size_t i = 0; i < tlen; ++i) {
|
|
if (std::tolower(static_cast<unsigned char>(out->scheme[i])) !=
|
|
std::tolower(static_cast<unsigned char>(target[i])))
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
if (prefixCaseEq("HTTPS"))
|
|
out->port = 443;
|
|
else if (prefixCaseEq("HTTP"))
|
|
out->port = 80;
|
|
else if (prefixCaseEq("TTP"))
|
|
out->port = 80;
|
|
}
|
|
}
|
|
}
|
|
|
|
char* pathDest = poolBytes + poolUsed;
|
|
const char* pathStart = srcUri + inputOffset;
|
|
u64 pathLen = 0;
|
|
while (pathStart[pathLen] && pathStart[pathLen] != '?' && pathStart[pathLen] != '#') {
|
|
if (pathLen >= 0x3fff) {
|
|
return ORBIS_HTTP_ERROR_INVALID_URL;
|
|
}
|
|
pathLen++;
|
|
}
|
|
|
|
if (writeOutput) {
|
|
if (prepare - poolUsed < pathLen + 1) {
|
|
LOG_ERROR(Lib_Http, "Out of memory");
|
|
return ORBIS_HTTP_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
memcpy(pathDest, pathStart, pathLen);
|
|
pathDest[pathLen] = '\0';
|
|
std::vector<char> tmp(pathLen + 1);
|
|
memcpy(tmp.data(), pathStart, pathLen);
|
|
tmp[pathLen] = '\0';
|
|
sceHttpUriSweepPath(pathDest, tmp.data(), pathLen + 1);
|
|
out->path = pathDest;
|
|
}
|
|
poolUsed += pathLen + 1;
|
|
inputOffset += pathLen;
|
|
|
|
char* queryDest = poolBytes + poolUsed;
|
|
u64 queryLen = 0;
|
|
if (srcUri[inputOffset] == '?') {
|
|
queryLen = 1; // include leading '?'
|
|
while (srcUri[inputOffset + queryLen] && srcUri[inputOffset + queryLen] != '#') {
|
|
if (queryLen >= 0x3fff) {
|
|
return ORBIS_HTTP_ERROR_INVALID_URL;
|
|
}
|
|
queryLen++;
|
|
}
|
|
}
|
|
|
|
if (writeOutput) {
|
|
if (prepare - poolUsed < queryLen + 1) {
|
|
return ORBIS_HTTP_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
memcpy(queryDest, srcUri + inputOffset, queryLen);
|
|
queryDest[queryLen] = '\0';
|
|
out->query = queryDest;
|
|
}
|
|
poolUsed += queryLen + 1;
|
|
inputOffset += queryLen;
|
|
|
|
char* fragDest = poolBytes + poolUsed;
|
|
u64 fragLen = 0;
|
|
if (srcUri[inputOffset] == '#') {
|
|
u64 i = 1; // include leading '#'
|
|
while (srcUri[inputOffset + i]) {
|
|
if (i >= 0x3fff) {
|
|
return ORBIS_HTTP_ERROR_INVALID_URL;
|
|
}
|
|
i++;
|
|
}
|
|
fragLen = i;
|
|
}
|
|
|
|
if (writeOutput) {
|
|
if (prepare - poolUsed < fragLen + 1) {
|
|
return ORBIS_HTTP_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
memcpy(fragDest, srcUri + inputOffset, fragLen);
|
|
fragDest[fragLen] = '\0';
|
|
out->fragment = fragDest;
|
|
}
|
|
poolUsed += fragLen + 1;
|
|
|
|
if (require) {
|
|
*require = poolUsed;
|
|
}
|
|
|
|
LOG_TRACE(Lib_Http, "parsed successfully, poolUsed={}", poolUsed);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpUriSweepPath(char* dst, const char* src, u64 srcSize) {
|
|
LOG_TRACE(Lib_Http, "called dst={}, src={}, srcSize={}", fmt::ptr(dst), src ? src : "(null)",
|
|
srcSize);
|
|
|
|
if (srcSize == 0) {
|
|
return ORBIS_OK;
|
|
}
|
|
if (!dst || !src) {
|
|
LOG_ERROR(Lib_Http, "Invalid parameters: dst={}, src={}", fmt::ptr(dst), fmt::ptr(src));
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
|
|
// Non-absolute
|
|
if (src[0] != '/') {
|
|
const u64 copyLen = srcSize - 1;
|
|
memcpy(dst, src, copyLen);
|
|
dst[copyLen] = '\0';
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
// Absolute path: dst[0]='/', dst[1]='\0'
|
|
dst[0] = '/';
|
|
dst[1] = '\0';
|
|
if (srcSize - 1U <= 1) {
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
u64 srcPos = 1;
|
|
char* segmentEnd = dst;
|
|
while (srcPos < srcSize - 1U) {
|
|
if (src[srcPos] == '.') {
|
|
if (src[srcPos + 1] == '/') {
|
|
// "./" - skip
|
|
srcPos += 2;
|
|
continue;
|
|
}
|
|
if (src[srcPos + 1] == '.' && src[srcPos + 2] == '/') {
|
|
char* newSegmentEnd = dst;
|
|
if (segmentEnd != dst) {
|
|
*segmentEnd = '\0';
|
|
char* prevSlash = std::strrchr(dst, '/');
|
|
if (prevSlash == nullptr) {
|
|
newSegmentEnd = nullptr;
|
|
} else {
|
|
prevSlash[1] = '\0';
|
|
newSegmentEnd = prevSlash;
|
|
}
|
|
}
|
|
srcPos += 3;
|
|
segmentEnd = newSegmentEnd;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
const char* segmentStart = src + srcPos;
|
|
const char* nextSlash = std::strchr(segmentStart, '/');
|
|
const u64 remaining = srcSize - srcPos - 1U;
|
|
u64 copyLen;
|
|
if (nextSlash == nullptr) {
|
|
copyLen = remaining;
|
|
} else {
|
|
const u64 segLen = static_cast<u64>(nextSlash + 1 - segmentStart);
|
|
copyLen = (segLen <= remaining) ? segLen : remaining;
|
|
}
|
|
memcpy(segmentEnd + 1, segmentStart, copyLen);
|
|
segmentEnd[copyLen + 1] = '\0';
|
|
segmentEnd += copyLen;
|
|
srcPos += copyLen;
|
|
}
|
|
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceHttpUriUnescape(char* out, u64* require, u64 prepare, const char* in) {
|
|
LOG_TRACE(Lib_Http, "called out={}, require={}, prepare={}, in={}", fmt::ptr(out),
|
|
fmt::ptr(require), prepare, in ? in : "(null)");
|
|
|
|
if (!in) {
|
|
LOG_ERROR(Lib_Http, "Invalid input string");
|
|
return ORBIS_HTTP_ERROR_INVALID_VALUE;
|
|
}
|
|
|
|
// Locale-independent hex digit check
|
|
auto IsHex = [](char c) -> bool {
|
|
return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f');
|
|
};
|
|
|
|
// Convert hex char to int value
|
|
auto HexToInt = [](char c) -> int {
|
|
if (c >= '0' && c <= '9')
|
|
return c - '0';
|
|
if (c >= 'A' && c <= 'F')
|
|
return c - 'A' + 10;
|
|
if (c >= 'a' && c <= 'f')
|
|
return c - 'a' + 10;
|
|
return 0;
|
|
};
|
|
|
|
// Check for valid percent-encoded sequence (%XX)
|
|
auto IsValidPercentSequence = [&](const char* s) -> bool {
|
|
return s[0] == '%' && s[1] != '\0' && s[2] != '\0' && IsHex(s[1]) && IsHex(s[2]);
|
|
};
|
|
|
|
u64 needed = 0;
|
|
const char* src = in;
|
|
while (*src) {
|
|
if (IsValidPercentSequence(src)) {
|
|
src += 3;
|
|
} else {
|
|
src++;
|
|
}
|
|
needed++;
|
|
}
|
|
needed++; // null terminator
|
|
|
|
if (require) {
|
|
*require = needed;
|
|
}
|
|
|
|
if (!out) {
|
|
LOG_INFO(Lib_Http, "out is null, only computing required size: {}", needed);
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
if (prepare < needed) {
|
|
LOG_ERROR(Lib_Http, "Buffer too small: need {} but only {} available", needed, prepare);
|
|
return ORBIS_HTTP_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
src = in;
|
|
char* dst = out;
|
|
while (*src) {
|
|
if (IsValidPercentSequence(src)) {
|
|
*dst++ = static_cast<char>((HexToInt(src[1]) << 4) | HexToInt(src[2]));
|
|
src += 3;
|
|
} else {
|
|
*dst++ = *src++;
|
|
}
|
|
}
|
|
*dst = '\0';
|
|
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
void RegisterLib(Core::Loader::SymbolsResolver* sym) {
|
|
LIB_FUNCTION("hvG6GfBMXg8", "libSceHttp", 1, "libSceHttp", sceHttpAbortRequest);
|
|
LIB_FUNCTION("JKl06ZIAl6A", "libSceHttp", 1, "libSceHttp", sceHttpAbortRequestForce);
|
|
LIB_FUNCTION("sWQiqKvYTVA", "libSceHttp", 1, "libSceHttp", sceHttpAbortWaitRequest);
|
|
LIB_FUNCTION("mNan6QSnpeY", "libSceHttp", 1, "libSceHttp", sceHttpAddCookie);
|
|
LIB_FUNCTION("JM58a21mtrQ", "libSceHttp", 1, "libSceHttp", sceHttpAddQuery);
|
|
LIB_FUNCTION("EY28T2bkN7k", "libSceHttp", 1, "libSceHttp", sceHttpAddRequestHeader);
|
|
LIB_FUNCTION("lGAjftanhFs", "libSceHttp", 1, "libSceHttp", sceHttpAddRequestHeaderRaw);
|
|
LIB_FUNCTION("Y1DCjN-s2BA", "libSceHttp", 1, "libSceHttp", sceHttpAuthCacheExport);
|
|
LIB_FUNCTION("zzB0StvRab4", "libSceHttp", 1, "libSceHttp", sceHttpAuthCacheFlush);
|
|
LIB_FUNCTION("wF0KcxK20BE", "libSceHttp", 1, "libSceHttp", sceHttpAuthCacheImport);
|
|
LIB_FUNCTION("A7n9nNg7NBg", "libSceHttp", 1, "libSceHttp",
|
|
sceHttpCacheRedirectedConnectionEnabled);
|
|
LIB_FUNCTION("nOkViL17ZOo", "libSceHttp", 1, "libSceHttp", sceHttpCookieExport);
|
|
LIB_FUNCTION("seCvUt91WHY", "libSceHttp", 1, "libSceHttp", sceHttpCookieFlush);
|
|
LIB_FUNCTION("pFnXDxo3aog", "libSceHttp", 1, "libSceHttp", sceHttpCookieImport);
|
|
LIB_FUNCTION("Kiwv9r4IZCc", "libSceHttp", 1, "libSceHttp", sceHttpCreateConnection);
|
|
LIB_FUNCTION("qgxDBjorUxs", "libSceHttp", 1, "libSceHttp", sceHttpCreateConnectionWithURL);
|
|
LIB_FUNCTION("6381dWF+xsQ", "libSceHttp", 1, "libSceHttp", sceHttpCreateEpoll);
|
|
LIB_FUNCTION("tsGVru3hCe8", "libSceHttp", 1, "libSceHttp", sceHttpCreateRequest);
|
|
LIB_FUNCTION("rGNm+FjIXKk", "libSceHttp", 1, "libSceHttp", sceHttpCreateRequest2);
|
|
LIB_FUNCTION("Aeu5wVKkF9w", "libSceHttp", 1, "libSceHttp", sceHttpCreateRequestWithURL);
|
|
LIB_FUNCTION("Cnp77podkCU", "libSceHttp", 1, "libSceHttp", sceHttpCreateRequestWithURL2);
|
|
LIB_FUNCTION("0gYjPTR-6cY", "libSceHttp", 1, "libSceHttp", sceHttpCreateTemplate);
|
|
LIB_FUNCTION("Lffcxao-QMM", "libSceHttp", 1, "libSceHttp", sceHttpDbgEnableProfile);
|
|
LIB_FUNCTION("6gyx-I0Oob4", "libSceHttp", 1, "libSceHttp", sceHttpDbgGetConnectionStat);
|
|
LIB_FUNCTION("fzzBpJjm9Kw", "libSceHttp", 1, "libSceHttp", sceHttpDbgGetRequestStat);
|
|
LIB_FUNCTION("VmqSnjZ5mE4", "libSceHttp", 1, "libSceHttp", sceHttpDbgSetPrintf);
|
|
LIB_FUNCTION("KJtUHtp6y0U", "libSceHttp", 1, "libSceHttp", sceHttpDbgShowConnectionStat);
|
|
LIB_FUNCTION("oEuPssSYskA", "libSceHttp", 1, "libSceHttp", sceHttpDbgShowMemoryPoolStat);
|
|
LIB_FUNCTION("L2gM3qptqHs", "libSceHttp", 1, "libSceHttp", sceHttpDbgShowRequestStat);
|
|
LIB_FUNCTION("pxBsD-X9eH0", "libSceHttp", 1, "libSceHttp", sceHttpDbgShowStat);
|
|
LIB_FUNCTION("P6A3ytpsiYc", "libSceHttp", 1, "libSceHttp", sceHttpDeleteConnection);
|
|
LIB_FUNCTION("qe7oZ+v4PWA", "libSceHttp", 1, "libSceHttp", sceHttpDeleteRequest);
|
|
LIB_FUNCTION("4I8vEpuEhZ8", "libSceHttp", 1, "libSceHttp", sceHttpDeleteTemplate);
|
|
LIB_FUNCTION("wYhXVfS2Et4", "libSceHttp", 1, "libSceHttp", sceHttpDestroyEpoll);
|
|
LIB_FUNCTION("1rpZqxdMRwQ", "libSceHttp", 1, "libSceHttp", sceHttpGetAcceptEncodingGZIPEnabled);
|
|
LIB_FUNCTION("aCYPMSUIaP8", "libSceHttp", 1, "libSceHttp", sceHttpGetAllResponseHeaders);
|
|
LIB_FUNCTION("9m8EcOGzcIQ", "libSceHttp", 1, "libSceHttp", sceHttpGetAuthEnabled);
|
|
LIB_FUNCTION("mmLexUbtnfY", "libSceHttp", 1, "libSceHttp", sceHttpGetAutoRedirect);
|
|
LIB_FUNCTION("L-DwVoHXLtU", "libSceHttp", 1, "libSceHttp", sceHttpGetConnectionStat);
|
|
LIB_FUNCTION("+G+UsJpeXPc", "libSceHttp", 1, "libSceHttp", sceHttpGetCookie);
|
|
LIB_FUNCTION("iSZjWw1TGiA", "libSceHttp", 1, "libSceHttp", sceHttpGetCookieEnabled);
|
|
LIB_FUNCTION("xkymWiGdMiI", "libSceHttp", 1, "libSceHttp", sceHttpGetCookieStats);
|
|
LIB_FUNCTION("7j9VcwnrZo4", "libSceHttp", 1, "libSceHttp", sceHttpGetEpoll);
|
|
LIB_FUNCTION("IQOP6McWJcY", "libSceHttp", 1, "libSceHttp", sceHttpGetEpollId);
|
|
LIB_FUNCTION("0onIrKx9NIE", "libSceHttp", 1, "libSceHttp", sceHttpGetLastErrno);
|
|
LIB_FUNCTION("16sMmVuOvgU", "libSceHttp", 1, "libSceHttp", sceHttpGetMemoryPoolStats);
|
|
LIB_FUNCTION("Wq4RNB3snSQ", "libSceHttp", 1, "libSceHttp", sceHttpGetNonblock);
|
|
LIB_FUNCTION("hkcfqAl+82w", "libSceHttp", 1, "libSceHttp", sceHttpGetRegisteredCtxIds);
|
|
LIB_FUNCTION("yuO2H2Uvnos", "libSceHttp", 1, "libSceHttp", sceHttpGetResponseContentLength);
|
|
LIB_FUNCTION("0a2TBNfE3BU", "libSceHttp", 1, "libSceHttp", sceHttpGetStatusCode);
|
|
LIB_FUNCTION("A9cVMUtEp4Y", "libSceHttp", 1, "libSceHttp", sceHttpInit);
|
|
LIB_FUNCTION("hPTXo3bICzI", "libSceHttp", 1, "libSceHttp", sceHttpParseResponseHeader);
|
|
LIB_FUNCTION("Qq8SfuJJJqE", "libSceHttp", 1, "libSceHttp", sceHttpParseStatusLine);
|
|
LIB_FUNCTION("P5pdoykPYTk", "libSceHttp", 1, "libSceHttp", sceHttpReadData);
|
|
LIB_FUNCTION("u05NnI+P+KY", "libSceHttp", 1, "libSceHttp", sceHttpRedirectCacheFlush);
|
|
LIB_FUNCTION("zNGh-zoQTD0", "libSceHttp", 1, "libSceHttp", sceHttpRemoveRequestHeader);
|
|
LIB_FUNCTION("4fgkfVeVsGU", "libSceHttp", 1, "libSceHttp", sceHttpRequestGetAllHeaders);
|
|
LIB_FUNCTION("mSQCxzWTwVI", "libSceHttp", 1, "libSceHttp", sceHttpsDisableOption);
|
|
LIB_FUNCTION("zJYi5br6ZiQ", "libSceHttp", 1, "libSceHttp", sceHttpsDisableOptionPrivate);
|
|
LIB_FUNCTION("f42K37mm5RM", "libSceHttp", 1, "libSceHttp", sceHttpsEnableOption);
|
|
LIB_FUNCTION("I4+4hKttt1w", "libSceHttp", 1, "libSceHttp", sceHttpsEnableOptionPrivate);
|
|
LIB_FUNCTION("1e2BNwI-XzE", "libSceHttp", 1, "libSceHttp", sceHttpSendRequest);
|
|
LIB_FUNCTION("HRX1iyDoKR8", "libSceHttp", 1, "libSceHttp", sceHttpSetAcceptEncodingGZIPEnabled);
|
|
LIB_FUNCTION("qFg2SuyTJJY", "libSceHttp", 1, "libSceHttp", sceHttpSetAuthEnabled);
|
|
LIB_FUNCTION("jf4TB2nUO40", "libSceHttp", 1, "libSceHttp", sceHttpSetAuthInfoCallback);
|
|
LIB_FUNCTION("T-mGo9f3Pu4", "libSceHttp", 1, "libSceHttp", sceHttpSetAutoRedirect);
|
|
LIB_FUNCTION("PDxS48xGQLs", "libSceHttp", 1, "libSceHttp", sceHttpSetChunkedTransferEnabled);
|
|
LIB_FUNCTION("0S9tTH0uqTU", "libSceHttp", 1, "libSceHttp", sceHttpSetConnectTimeOut);
|
|
LIB_FUNCTION("XNUoD2B9a6A", "libSceHttp", 1, "libSceHttp", sceHttpSetCookieEnabled);
|
|
LIB_FUNCTION("pM--+kIeW-8", "libSceHttp", 1, "libSceHttp", sceHttpSetCookieMaxNum);
|
|
LIB_FUNCTION("Kp6juCJUJGQ", "libSceHttp", 1, "libSceHttp", sceHttpSetCookieMaxNumPerDomain);
|
|
LIB_FUNCTION("7Y4364GBras", "libSceHttp", 1, "libSceHttp", sceHttpSetCookieMaxSize);
|
|
LIB_FUNCTION("Kh6bS2HQKbo", "libSceHttp", 1, "libSceHttp", sceHttpSetCookieRecvCallback);
|
|
LIB_FUNCTION("GnVDzYfy-KI", "libSceHttp", 1, "libSceHttp", sceHttpSetCookieSendCallback);
|
|
LIB_FUNCTION("pHc3bxUzivU", "libSceHttp", 1, "libSceHttp", sceHttpSetCookieTotalMaxSize);
|
|
LIB_FUNCTION("8kzIXsRy1bY", "libSceHttp", 1, "libSceHttp",
|
|
sceHttpSetDefaultAcceptEncodingGZIPEnabled);
|
|
LIB_FUNCTION("22buO-UufJY", "libSceHttp", 1, "libSceHttp", sceHttpSetDelayBuildRequestEnabled);
|
|
LIB_FUNCTION("-xm7kZQNpHI", "libSceHttp", 1, "libSceHttp", sceHttpSetEpoll);
|
|
LIB_FUNCTION("LG1YW1Uhkgo", "libSceHttp", 1, "libSceHttp", sceHttpSetEpollId);
|
|
LIB_FUNCTION("pk0AuomQM1o", "libSceHttp", 1, "libSceHttp", sceHttpSetHttp09Enabled);
|
|
LIB_FUNCTION("i9mhafzkEi8", "libSceHttp", 1, "libSceHttp", sceHttpSetInflateGZIPEnabled);
|
|
LIB_FUNCTION("s2-NPIvz+iA", "libSceHttp", 1, "libSceHttp", sceHttpSetNonblock);
|
|
LIB_FUNCTION("gZ9TpeFQ7Gk", "libSceHttp", 1, "libSceHttp", sceHttpSetPolicyOption);
|
|
LIB_FUNCTION("2NeZnMEP3-0", "libSceHttp", 1, "libSceHttp", sceHttpSetPriorityOption);
|
|
LIB_FUNCTION("i+quCZCL+D8", "libSceHttp", 1, "libSceHttp", sceHttpSetProxy);
|
|
LIB_FUNCTION("mMcB2XIDoV4", "libSceHttp", 1, "libSceHttp", sceHttpSetRecvBlockSize);
|
|
LIB_FUNCTION("yigr4V0-HTM", "libSceHttp", 1, "libSceHttp", sceHttpSetRecvTimeOut);
|
|
LIB_FUNCTION("h9wmFZX4i-4", "libSceHttp", 1, "libSceHttp", sceHttpSetRedirectCallback);
|
|
LIB_FUNCTION("PTiFIUxCpJc", "libSceHttp", 1, "libSceHttp", sceHttpSetRequestContentLength);
|
|
LIB_FUNCTION("vO4B-42ef-k", "libSceHttp", 1, "libSceHttp", sceHttpSetRequestStatusCallback);
|
|
LIB_FUNCTION("K1d1LqZRQHQ", "libSceHttp", 1, "libSceHttp", sceHttpSetResolveRetry);
|
|
LIB_FUNCTION("Tc-hAYDKtQc", "libSceHttp", 1, "libSceHttp", sceHttpSetResolveTimeOut);
|
|
LIB_FUNCTION("a4VsZ4oqn68", "libSceHttp", 1, "libSceHttp", sceHttpSetResponseHeaderMaxSize);
|
|
LIB_FUNCTION("xegFfZKBVlw", "libSceHttp", 1, "libSceHttp", sceHttpSetSendTimeOut);
|
|
LIB_FUNCTION("POJ0azHZX3w", "libSceHttp", 1, "libSceHttp", sceHttpSetSocketCreationCallback);
|
|
LIB_FUNCTION("7WcNoAI9Zcw", "libSceHttp", 1, "libSceHttp", sceHttpsFreeCaList);
|
|
LIB_FUNCTION("gcUjwU3fa0M", "libSceHttp", 1, "libSceHttp", sceHttpsGetCaList);
|
|
LIB_FUNCTION("JBN6N-EY+3M", "libSceHttp", 1, "libSceHttp", sceHttpsGetSslError);
|
|
LIB_FUNCTION("DK+GoXCNT04", "libSceHttp", 1, "libSceHttp", sceHttpsLoadCert);
|
|
LIB_FUNCTION("jUjp+yqMNdQ", "libSceHttp", 1, "libSceHttp", sceHttpsSetMinSslVersion);
|
|
LIB_FUNCTION("htyBOoWeS58", "libSceHttp", 1, "libSceHttp", sceHttpsSetSslCallback);
|
|
LIB_FUNCTION("U5ExQGyyx9s", "libSceHttp", 1, "libSceHttp", sceHttpsSetSslVersion);
|
|
LIB_FUNCTION("zXqcE0fizz0", "libSceHttp", 1, "libSceHttp", sceHttpsUnloadCert);
|
|
LIB_FUNCTION("Ik-KpLTlf7Q", "libSceHttp", 1, "libSceHttp", sceHttpTerm);
|
|
LIB_FUNCTION("V-noPEjSB8c", "libSceHttp", 1, "libSceHttp", sceHttpTryGetNonblock);
|
|
LIB_FUNCTION("fmOs6MzCRqk", "libSceHttp", 1, "libSceHttp", sceHttpTrySetNonblock);
|
|
LIB_FUNCTION("59tL1AQBb8U", "libSceHttp", 1, "libSceHttp", sceHttpUnsetEpoll);
|
|
LIB_FUNCTION("5LZA+KPISVA", "libSceHttp", 1, "libSceHttp", sceHttpUriBuild);
|
|
LIB_FUNCTION("CR-l-yI-o7o", "libSceHttp", 1, "libSceHttp", sceHttpUriCopy);
|
|
LIB_FUNCTION("YuOW3dDAKYc", "libSceHttp", 1, "libSceHttp", sceHttpUriEscape);
|
|
LIB_FUNCTION("3lgQ5Qk42ok", "libSceHttp", 1, "libSceHttp", sceHttpUriMerge);
|
|
LIB_FUNCTION("IWalAn-guFs", "libSceHttp", 1, "libSceHttp", sceHttpUriParse);
|
|
LIB_FUNCTION("mUU363n4yc0", "libSceHttp", 1, "libSceHttp", sceHttpUriSweepPath);
|
|
LIB_FUNCTION("thTS+57zoLM", "libSceHttp", 1, "libSceHttp", sceHttpUriUnescape);
|
|
LIB_FUNCTION("qISjDHrxONc", "libSceHttp", 1, "libSceHttp", sceHttpWaitRequest);
|
|
};
|
|
|
|
} // namespace Libraries::Http
|