212 lines
10 KiB
C++
212 lines
10 KiB
C++
#include "SceTypes.hpp"
|
|
#include <cstdint>
|
|
#include <cstdlib>
|
|
#include <stdexcept>
|
|
|
|
extern "C" {
|
|
int APS5_VABI sceHttp2Init(int, int, std::size_t, int);
|
|
int APS5_VABI sceHttp2CreateTemplate(int, const char*, int, int);
|
|
int APS5_VABI sceHttp2CreateRequestWithURL(int, const char*, const char*, std::uint64_t);
|
|
int APS5_VABI sceHttp2CreateCookieBox(int);
|
|
int APS5_VABI sceHttp2SetCookieBox(int, int);
|
|
int APS5_VABI sceHttp2CookieFlush(int);
|
|
int APS5_VABI sceHttp2SetRequestNoContentLength(int);
|
|
int APS5_VABI sceHttp2SendRequest(int, const void*, std::size_t);
|
|
int APS5_VABI sceHttp2SendRequestAsync(int, const void*, std::size_t, Http2AsyncOption*, void*);
|
|
int APS5_VABI sceHttp2WaitAsync(int, Http2AsyncResult*, std::uint32_t*, void*);
|
|
int APS5_VABI sceHttp2DeleteRequest(int);
|
|
int APS5_VABI sceHttp2DeleteTemplate(int);
|
|
int APS5_VABI sceHttp2SetMinSslVersion(int, std::uint32_t);
|
|
int APS5_VABI sceHttp2SslEnableOption(int, std::uint32_t);
|
|
int APS5_VABI sceHttp2SslDisableOption(int, std::uint32_t);
|
|
int APS5_VABI sceHttp2Term(int);
|
|
int APS5_VABI sceKernelCreateEqueue(KernelEqueue* eq, const char* name);
|
|
int APS5_VABI sceKernelDeleteEqueue(KernelEqueue eq);
|
|
int APS5_VABI sceKernelWaitEqueue(KernelEqueue eq, KernelEvent* ev, int num, int* out, const KernelUseconds* timo);
|
|
int APS5_VABI sceKernelAddUserEventEdge(KernelEqueue eq, int id);
|
|
int APS5_VABI sceKernelDeleteUserEvent(KernelEqueue eq, int id);
|
|
uintptr_t APS5_VABI sceKernelGetEventId(const KernelEvent* ev);
|
|
void* APS5_VABI sceKernelGetEventUserData(const KernelEvent* ev);
|
|
}
|
|
|
|
struct Http2MemoryPoolStats {
|
|
std::size_t pool_size;
|
|
std::size_t max_inuse_size;
|
|
std::size_t current_inuse_size;
|
|
std::int32_t reserved;
|
|
};
|
|
|
|
extern "C" {
|
|
int APS5_VABI sceHttp2GetMemoryPoolStats(int, Http2MemoryPoolStats*);
|
|
int APS5_VABI sceHttp2SetResolveRetry(int, std::int32_t);
|
|
int APS5_VABI sceHttp2WebSocketSetPingInterval();
|
|
}
|
|
|
|
static void Require(bool value) { if (!value) std::abort(); }
|
|
|
|
static constexpr int InvalidId = static_cast<int>(0x817B1100);
|
|
|
|
static void RequireSslSetters(int id, int expected) {
|
|
Require(sceHttp2SetMinSslVersion(id, 0) == expected);
|
|
Require(sceHttp2SslEnableOption(id, 0) == expected);
|
|
Require(sceHttp2SslDisableOption(id, 0) == expected);
|
|
}
|
|
|
|
template <typename TCall>
|
|
static bool Throws(TCall call) {
|
|
try {
|
|
call();
|
|
} catch (const std::exception&) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int main() {
|
|
const int context = sceHttp2Init(1, 1, 0x10000, 4);
|
|
Require(context > 0);
|
|
Http2MemoryPoolStats stats{1, 1, 1, 1};
|
|
Require(sceHttp2GetMemoryPoolStats(context, &stats) == 0);
|
|
Require(stats.pool_size == 0x10000 && stats.max_inuse_size == 0 && stats.current_inuse_size == 0 && stats.reserved == 0);
|
|
const int box = sceHttp2CreateCookieBox(context);
|
|
const int other = sceHttp2CreateCookieBox(context);
|
|
Require(box > 0 && other > 0 && box != other && box != context);
|
|
const int tmpl = sceHttp2CreateTemplate(context, "agent", 2, 0);
|
|
Require(tmpl > 0 && tmpl != box && tmpl != other);
|
|
Require(sceHttp2SetResolveRetry(tmpl, 3) == 0);
|
|
Require(sceHttp2SetCookieBox(tmpl, box) == 0);
|
|
Require(sceHttp2SetCookieBox(tmpl, 0) == 0);
|
|
const int request = sceHttp2CreateRequestWithURL(tmpl, "POST", "https://example.com/", 16);
|
|
Require(request > 0);
|
|
Require(sceHttp2SetCookieBox(request, other) == 0);
|
|
Require(sceHttp2SetRequestNoContentLength(request) == 0);
|
|
Require(Throws([] { sceHttp2WebSocketSetPingInterval(); }));
|
|
Require(sceHttp2CookieFlush(context) == 0);
|
|
Require(sceHttp2SendRequest(request, nullptr, 0) == static_cast<int>(0x80436063));
|
|
|
|
RequireSslSetters(0, InvalidId);
|
|
RequireSslSetters(-1, InvalidId);
|
|
RequireSslSetters(0x7fffffff, InvalidId);
|
|
RequireSslSetters(context, 0);
|
|
RequireSslSetters(box, 0);
|
|
RequireSslSetters(other, 0);
|
|
RequireSslSetters(tmpl, 0);
|
|
RequireSslSetters(request, 0);
|
|
|
|
const int doomedRequest = sceHttp2CreateRequestWithURL(tmpl, "GET", "https://example.com/doomed", 0);
|
|
Require(doomedRequest > 0);
|
|
Require(sceHttp2DeleteRequest(doomedRequest) == 0);
|
|
RequireSslSetters(doomedRequest, InvalidId);
|
|
Require(sceHttp2DeleteRequest(doomedRequest) == InvalidId);
|
|
|
|
const int doomedTemplate = sceHttp2CreateTemplate(context, "agent", 2, 0);
|
|
Require(doomedTemplate > 0);
|
|
const int doomedTemplateRequest = sceHttp2CreateRequestWithURL(doomedTemplate, "GET", "https://example.com/child", 0);
|
|
Require(doomedTemplateRequest > 0);
|
|
Require(sceHttp2DeleteTemplate(doomedTemplate) == 0);
|
|
RequireSslSetters(doomedTemplate, InvalidId);
|
|
RequireSslSetters(doomedTemplateRequest, InvalidId);
|
|
Require(sceHttp2DeleteTemplate(doomedTemplate) == InvalidId);
|
|
|
|
const int doomedContext = sceHttp2Init(1, 1, 0x2000, 4);
|
|
Require(doomedContext > 0);
|
|
const int doomedContextBox = sceHttp2CreateCookieBox(doomedContext);
|
|
const int doomedContextTemplate = sceHttp2CreateTemplate(doomedContext, "agent", 2, 0);
|
|
Require(doomedContextBox > 0 && doomedContextTemplate > 0);
|
|
const int doomedContextRequest = sceHttp2CreateRequestWithURL(doomedContextTemplate, "GET", "https://example.com/descendant", 0);
|
|
Require(doomedContextRequest > 0);
|
|
RequireSslSetters(doomedContext, 0);
|
|
Require(sceHttp2Term(doomedContext) == 0);
|
|
RequireSslSetters(doomedContext, InvalidId);
|
|
RequireSslSetters(doomedContextBox, InvalidId);
|
|
RequireSslSetters(doomedContextTemplate, InvalidId);
|
|
RequireSslSetters(doomedContextRequest, InvalidId);
|
|
Require(sceHttp2Term(doomedContext) == InvalidId);
|
|
|
|
const int freshContext = sceHttp2Init(1, 1, 0x2000, 4);
|
|
Require(freshContext > 0);
|
|
RequireSslSetters(freshContext, 0);
|
|
Require(sceHttp2Term(freshContext) == 0);
|
|
|
|
KernelEqueue eq = 0;
|
|
Require(sceKernelCreateEqueue(&eq, "http2") == 0);
|
|
Require(sceKernelAddUserEventEdge(eq, request) == 0);
|
|
int tag = 0;
|
|
Http2AsyncOption option{};
|
|
option.equeue = eq;
|
|
option.user_event_id = request;
|
|
option.user_data = &tag;
|
|
Require(sceHttp2SendRequestAsync(request, nullptr, 0, &option, nullptr) == 0);
|
|
KernelEvent event{};
|
|
int count = 0;
|
|
const KernelUseconds timeout = 1000000;
|
|
Require(sceKernelWaitEqueue(eq, &event, 1, &count, &timeout) == 0 && count == 1);
|
|
Require(sceKernelGetEventId(&event) == static_cast<uintptr_t>(request));
|
|
Require(sceKernelGetEventUserData(&event) == &tag);
|
|
Http2AsyncResult result{};
|
|
Require(sceHttp2WaitAsync(request, &result, nullptr, nullptr) == 0);
|
|
Require(result.req_id == request && result.result == static_cast<int>(0x80436063));
|
|
Require(Throws([&] { sceHttp2WaitAsync(request, &result, nullptr, nullptr); }));
|
|
Require(Throws([&] { sceHttp2SendRequestAsync(request, nullptr, 0, nullptr, nullptr); }));
|
|
Require(sceKernelDeleteUserEvent(eq, request) == 0);
|
|
Require(Throws([&] { sceHttp2SendRequestAsync(request, nullptr, 0, &option, nullptr); }));
|
|
Require(Throws([&] { sceHttp2WaitAsync(request, &result, nullptr, nullptr); }));
|
|
Require(sceHttp2DeleteRequest(request) == 0);
|
|
Require(sceKernelDeleteEqueue(eq) == 0);
|
|
Require(sceHttp2Term(context) == 0);
|
|
|
|
KernelEqueue templateEqueue = 0;
|
|
Require(sceKernelCreateEqueue(&templateEqueue, "http2-template") == 0);
|
|
const int cascadeContext = sceHttp2Init(1, 1, 0x3000, 4);
|
|
Require(cascadeContext > 0);
|
|
const int cascadeTemplate = sceHttp2CreateTemplate(cascadeContext, "agent", 2, 0);
|
|
Require(cascadeTemplate > 0);
|
|
const int cascadeRequest = sceHttp2CreateRequestWithURL(cascadeTemplate, "GET", "https://example.com/cascade", 0);
|
|
Require(cascadeRequest > 0);
|
|
Require(sceKernelAddUserEventEdge(templateEqueue, cascadeRequest) == 0);
|
|
Http2AsyncOption cascadeOption{};
|
|
cascadeOption.equeue = templateEqueue;
|
|
cascadeOption.user_event_id = cascadeRequest;
|
|
cascadeOption.user_data = &tag;
|
|
Require(sceHttp2SendRequestAsync(cascadeRequest, nullptr, 0, &cascadeOption, nullptr) == 0);
|
|
KernelEvent cascadeEvent{};
|
|
int cascadeCount = 0;
|
|
Require(sceKernelWaitEqueue(templateEqueue, &cascadeEvent, 1, &cascadeCount, &timeout) == 0 && cascadeCount == 1);
|
|
Require(sceHttp2DeleteTemplate(cascadeTemplate) == 0);
|
|
Require(Throws([&] { sceHttp2WaitAsync(cascadeRequest, &result, nullptr, nullptr); }));
|
|
Require(sceHttp2SendRequestAsync(cascadeRequest, nullptr, 0, &cascadeOption, nullptr) == InvalidId);
|
|
Require(Throws([&] { sceHttp2WaitAsync(cascadeRequest, &result, nullptr, nullptr); }));
|
|
Require(sceHttp2DeleteRequest(cascadeRequest) == InvalidId);
|
|
RequireSslSetters(cascadeRequest, InvalidId);
|
|
Require(sceHttp2Term(cascadeContext) == 0);
|
|
Require(sceKernelDeleteUserEvent(templateEqueue, cascadeRequest) == 0);
|
|
Require(sceKernelDeleteEqueue(templateEqueue) == 0);
|
|
|
|
KernelEqueue termEqueue = 0;
|
|
Require(sceKernelCreateEqueue(&termEqueue, "http2-term") == 0);
|
|
const int terminatedContext = sceHttp2Init(1, 1, 0x4000, 4);
|
|
Require(terminatedContext > 0);
|
|
const int terminatedTemplate = sceHttp2CreateTemplate(terminatedContext, "agent", 2, 0);
|
|
Require(terminatedTemplate > 0);
|
|
const int terminatedRequest = sceHttp2CreateRequestWithURL(terminatedTemplate, "GET", "https://example.com/terminated", 0);
|
|
Require(terminatedRequest > 0);
|
|
Require(sceKernelAddUserEventEdge(termEqueue, terminatedRequest) == 0);
|
|
Http2AsyncOption termOption{};
|
|
termOption.equeue = termEqueue;
|
|
termOption.user_event_id = terminatedRequest;
|
|
termOption.user_data = &tag;
|
|
Require(sceHttp2SendRequestAsync(terminatedRequest, nullptr, 0, &termOption, nullptr) == 0);
|
|
KernelEvent termEvent{};
|
|
int termCount = 0;
|
|
Require(sceKernelWaitEqueue(termEqueue, &termEvent, 1, &termCount, &timeout) == 0 && termCount == 1);
|
|
Require(sceHttp2Term(terminatedContext) == 0);
|
|
Require(sceHttp2SendRequestAsync(terminatedRequest, nullptr, 0, &termOption, nullptr) == InvalidId);
|
|
Require(Throws([&] { sceHttp2WaitAsync(terminatedRequest, &result, nullptr, nullptr); }));
|
|
Require(sceHttp2DeleteRequest(terminatedRequest) == InvalidId);
|
|
Require(sceHttp2DeleteTemplate(terminatedTemplate) == InvalidId);
|
|
RequireSslSetters(terminatedContext, InvalidId);
|
|
RequireSslSetters(terminatedRequest, InvalidId);
|
|
Require(sceKernelDeleteUserEvent(termEqueue, terminatedRequest) == 0);
|
|
Require(sceKernelDeleteEqueue(termEqueue) == 0);
|
|
}
|