Play your Steam library's Windows games on a jailbroken PS5.
C++
// SPDX-License-Identifier: GPL-3.0-or-later
#include "web/http.h"
#include <cstdio>
#include <cstdlib>
#include <string>
using namespace playden::web;
#define CHECK(condition) \
do { \
if (!(condition)) { \
std::fprintf(stderr, "%s:%d: CHECK failed: %s\n", __FILE__, __LINE__, #condition); \
std::exit(1); \
} \
} while (false)
int main() {
Request request;
CHECK(ParseRequestHead("GET / HTTP/1.1\r\nHost: x\r\n", &request) == ParseResult::kIncomplete);
CHECK(ParseRequestHead("GET /api/logs HTTP/1.1\r\nHost: 10.0.1.68:7031\r\nUser-Agent: curl\r\n\r\n", &request) ==
ParseResult::kOk);
CHECK(request.method == Method::kGet && request.method_text == "GET" && request.path == "/api/logs");
CHECK(request.headers.size() == 2 && request.headers[0].first == "host" && request.headers[0].second == "10.0.1.68:7031");
// A body after the head is ignored.
CHECK(ParseRequestHead("HEAD /x?title=FAKE78012 HTTP/1.0\n\nbody", &request) == ParseResult::kOk);
CHECK(request.method == Method::kHead && request.path == "/x" && request.query == "title=FAKE78012");
CHECK(ParseRequestHead("POST / HTTP/1.1\r\n\r\n", &request) == ParseResult::kOk && request.method == Method::kPost);
CHECK(ParseRequestHead("DELETE /api/logs/runtime.log HTTP/1.1\r\n\r\n", &request) == ParseResult::kOk &&
request.method == Method::kOther && request.method_text == "DELETE");
// Percent escapes decode in the path; a bad escape or a NUL is refused.
CHECK(ParseRequestHead("GET /api/logs/title-FAKE78012%2Elog HTTP/1.1\r\n\r\n", &request) == ParseResult::kOk);
CHECK(request.path == "/api/logs/title-FAKE78012.log");
CHECK(ParseRequestHead("GET /a%2 HTTP/1.1\r\n\r\n", &request) == ParseResult::kBadRequest);
CHECK(ParseRequestHead("GET /a%zz HTTP/1.1\r\n\r\n", &request) == ParseResult::kBadRequest);
CHECK(ParseRequestHead("GET /a%00b HTTP/1.1\r\n\r\n", &request) == ParseResult::kBadRequest);
// Bad request lines.
CHECK(ParseRequestHead("GET\r\n\r\n", &request) == ParseResult::kBadRequest);
CHECK(ParseRequestHead("GET / HTTP/2\r\n\r\n", &request) == ParseResult::kBadRequest);
CHECK(ParseRequestHead("GET http://evil/ HTTP/1.1\r\n\r\n", &request) == ParseResult::kBadRequest);
CHECK(ParseRequestHead("GET * HTTP/1.1\r\n\r\n", &request) == ParseResult::kBadRequest);
CHECK(ParseRequestHead("GET / HTTP/1.1\r\n\r\n", &request) == ParseResult::kBadRequest);
CHECK(ParseRequestHead("G(T / HTTP/1.1\r\n\r\n", &request) == ParseResult::kBadRequest);
CHECK(ParseRequestHead(std::string("GET /\x7f HTTP/1.1\r\n\r\n"), &request) == ParseResult::kBadRequest);
CHECK(ParseRequestHead("GET / HTTP/1.1\r\nNo colon\r\n\r\n", &request) == ParseResult::kBadRequest);
CHECK(ParseRequestHead("GET / HTTP/1.1\r\n: empty\r\n\r\n", &request) == ParseResult::kBadRequest);
CHECK(ParseRequestHead(std::string("GET / HTTP/1.1\r\nX: a\x01" "b\r\n\r\n"), &request) == ParseResult::kBadRequest);
// The head limit: 8 KB, with or without the blank line seen.
const std::string big_header = "X-Big: " + std::string(kMaxRequestHead, 'a');
CHECK(ParseRequestHead("GET / HTTP/1.1\r\n" + big_header, &request) == ParseResult::kTooLarge);
CHECK(ParseRequestHead("GET / HTTP/1.1\r\n" + big_header + "\r\n\r\n", &request) == ParseResult::kTooLarge);
const std::string fits = "GET / HTTP/1.1\r\nX: " + std::string(kMaxRequestHead - 25, 'a') + "\r\n\r\n";
CHECK(fits.size() <= kMaxRequestHead && ParseRequestHead(fits, &request) == ParseResult::kOk);
// Query values.
CHECK(QueryValue("title=FAKE78012", "title") == std::optional<std::string>("FAKE78012"));
CHECK(QueryValue("a=1&title=all&b", "title") == std::optional<std::string>("all"));
CHECK(QueryValue("a=1&b", "b") == std::optional<std::string>(""));
CHECK(!QueryValue("a=1", "title"));
CHECK(QueryValue("t%69tle=x+y%21", "title") == std::optional<std::string>("x y!"));
CHECK(!QueryValue("title=%zz", "title"));
// Responses: status line, headers, Connection: close; HEAD sends no body.
std::string sent;
const auto into = [&sent](const char* data, std::size_t size) { sent.append(data, size); return true; };
Response get(into, false);
CHECK(get.Send(200, "text/plain", "hi", {{"Cache-Control", "no-store"}}));
CHECK(sent.rfind("HTTP/1.1 200 OK\r\n", 0) == 0);
CHECK(sent.find("Content-Length: 2\r\n") != std::string::npos && sent.find("Cache-Control: no-store\r\n") != std::string::npos);
CHECK(sent.find("Connection: close\r\n\r\nhi") != std::string::npos && get.body_bytes() == 2 && get.status() == 200);
sent.clear();
Response head(into, true);
CHECK(head.Send(404, "text/plain", "missing"));
CHECK(sent.rfind("HTTP/1.1 404 Not Found\r\n", 0) == 0 && sent.find("Content-Length: 7\r\n") != std::string::npos);
CHECK(sent.size() >= 4 && sent.compare(sent.size() - 4, 4, "\r\n\r\n") == 0 && head.body_bytes() == 0);
// A client gone mid-answer: the response says so and writes nothing more.
Response gone([](const char*, std::size_t) { return false; }, false);
CHECK(!gone.Start(200, "text/plain", std::nullopt) && gone.failed() && !gone.Body("x"));
// The body's length, and where the body starts.
{
Request request;
std::size_t head = 0;
const std::string text = "POST /u HTTP/1.1\r\nContent-Length: 12\r\n\r\nbody";
CHECK(ParseRequestHead(text, &request, &head) == ParseResult::kOk);
CHECK(request.content_length == std::uint64_t{12} && text.substr(head) == "body");
CHECK(HeaderValue(request, "content-length") == std::string("12") && !HeaderValue(request, "origin"));
Request none;
CHECK(ParseRequestHead("GET / HTTP/1.1\r\n\r\n", &none) == ParseResult::kOk && !none.content_length);
for (const char* bad : {"POST / HTTP/1.1\r\nContent-Length: 1\r\nContent-Length: 2\r\n\r\n",
"POST / HTTP/1.1\r\nContent-Length: x\r\n\r\n", "POST / HTTP/1.1\r\nContent-Length: -1\r\n\r\n",
"POST / HTTP/1.1\r\nContent-Length: 12345678901234567890\r\n\r\n",
"POST / HTTP/1.1\r\nTransfer-Encoding: chunked\r\n\r\n"}) {
Request refused;
CHECK(ParseRequestHead(bad, &refused) == ParseResult::kBadRequest);
}
}
// A chunked answer: each piece framed, the end only after FinishChunks; HEAD sends neither.
{
std::string out;
Response response([&out](const char* data, std::size_t size) { out.append(data, size); return true; }, false);
CHECK(response.StartChunked(200, "application/zip"));
CHECK(response.Body("hello"));
CHECK(out.find("Transfer-Encoding: chunked\r\n") != std::string::npos);
CHECK(out.size() > 10 && out.compare(out.size() - 10, 10, "5\r\nhello\r\n") == 0);
CHECK(response.FinishChunks());
CHECK(out.compare(out.size() - 5, 5, "0\r\n\r\n") == 0);
CHECK(response.body_bytes() == 5);
std::string head;
Response head_only([&head](const char* data, std::size_t size) { head.append(data, size); return true; }, true);
CHECK(head_only.StartChunked(200, "application/zip") && head_only.Body("hello") && head_only.FinishChunks());
CHECK(head.find("hello") == std::string::npos && head.find("chunked") == std::string::npos);
}
std::puts("web_request: ok");
}