7a74227164
Change-Id: I075c1069b489b45283cfac75d8c8c90543a10644 Signed-off-by: Ashod Nakashian <ashod.nakashian@collabora.co.uk>
192 lines
6.8 KiB
C++
192 lines
6.8 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
|
|
/*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <net/HttpRequest.hpp>
|
|
#include <net/Socket.hpp>
|
|
#include <common/Log.hpp>
|
|
#include <common/Util.hpp>
|
|
|
|
#include <chrono>
|
|
#include <string>
|
|
|
|
#ifndef COOLWSD_VERSION
|
|
static_assert(false, "config.h must be included in the .cpp being compiled");
|
|
#endif
|
|
|
|
/// Handles incoming connections and dispatches to the appropriate handler.
|
|
class ServerRequestHandler final : public SimpleSocketHandler
|
|
{
|
|
public:
|
|
ServerRequestHandler() {}
|
|
|
|
private:
|
|
/// Set the socket associated with this ResponseClient.
|
|
void onConnect(const std::shared_ptr<StreamSocket>& socket) override
|
|
{
|
|
_socket = socket;
|
|
LOG_TRC('#' << socket->getFD() << ": Connected to ServerRequestHandler");
|
|
}
|
|
|
|
/// Called after successful socket reads.
|
|
void handleIncomingMessage(SocketDisposition& disposition) override
|
|
{
|
|
std::shared_ptr<StreamSocket> socket = _socket.lock();
|
|
if (!socket)
|
|
{
|
|
LOG_ERR("Invalid socket while handling incoming client request");
|
|
return;
|
|
}
|
|
|
|
LOG_TRC('#' << socket->getFD() << " handleIncomingMessage.");
|
|
|
|
Buffer& data = socket->getInBuffer();
|
|
LOG_TRC('#' << socket->getFD() << " handleIncomingMessage: buffer has ["
|
|
<< std::string(data.data(), data.size()));
|
|
|
|
// Consume the incoming data by parsing and processing the body.
|
|
http::Request request;
|
|
const int64_t read = request.readData(data.data(), data.size());
|
|
if (read < 0)
|
|
{
|
|
// Interrupt the transfer.
|
|
disposition.setClosed();
|
|
socket->shutdown();
|
|
return;
|
|
}
|
|
|
|
if (read == 0)
|
|
{
|
|
// Not enough data.
|
|
return;
|
|
}
|
|
|
|
assert(read > 0 && "Must have read some data!");
|
|
|
|
// Remove consumed data.
|
|
data.eraseFirst(read);
|
|
|
|
LOG_TRC('#' << socket->getFD() << " handleIncomingMessage: removed " << read
|
|
<< " bytes to have " << data.size() << " in the buffer.");
|
|
|
|
if (request.getVerb() == http::Request::VERB_GET)
|
|
{
|
|
// Return test data.
|
|
if (Util::startsWith(request.getUrl(), "/status/"))
|
|
{
|
|
const auto statusCode
|
|
= Util::i32FromString(request.getUrl().substr(sizeof("/status")));
|
|
const auto reason = http::getReasonPhraseForCode(statusCode.first);
|
|
LOG_TRC('#' << socket->getFD() << " handleIncomingMessage: got StatusCode "
|
|
<< statusCode.first << ", sending back: " << reason);
|
|
|
|
http::Response response(http::StatusLine(statusCode.first));
|
|
if (statusCode.first == 402)
|
|
{
|
|
response.setBody("Pay me!");
|
|
}
|
|
else if (statusCode.first == 406)
|
|
{
|
|
response.setBody(
|
|
R"({"message": "Client did not request a supported media type.", )"
|
|
R"("accept": ["image/webp", "image/svg+xml", "image/jpeg", "image/png", "image/*"]})");
|
|
}
|
|
else if (statusCode.first == 418)
|
|
{
|
|
response.setBody("I'm a teapot!");
|
|
}
|
|
|
|
if (response.getBody().empty() && statusCode.first >= 200 && statusCode.first != 204
|
|
&& statusCode.first != 304) // No Content for other tags.
|
|
response.set("Content-Length", "0");
|
|
|
|
socket->send(response);
|
|
}
|
|
else if (request.getUrl() == "/timeout")
|
|
{
|
|
// Don't send anything back.
|
|
}
|
|
else if (Util::startsWith(request.getUrl(), "/inject"))
|
|
{
|
|
// /inject/<hex data> sends back the data (in binary form)
|
|
// verbatim. It doesn't add headers or anything at all.
|
|
const std::string hex = request.getUrl().substr(sizeof("/inject"));
|
|
const std::string bytes = Util::hexStringToBytes(
|
|
reinterpret_cast<const uint8_t*>(hex.data()), hex.size());
|
|
socket->send(bytes);
|
|
socket->shutdown();
|
|
}
|
|
else
|
|
{
|
|
http::Response response(http::StatusLine(200));
|
|
if (Util::startsWith(request.getUrl(), "/echo/"))
|
|
{
|
|
if (Util::startsWith(request.getUrl(), "/echo/chunked/"))
|
|
{
|
|
response.set("transfer-encoding", "chunked");
|
|
std::string body = request.getUrl().substr(sizeof("/echo/chunked"));
|
|
while (!body.empty())
|
|
{
|
|
if (body.size() < 5)
|
|
{
|
|
response.appendChunk(body);
|
|
break;
|
|
}
|
|
|
|
const auto half = body.size() / 2;
|
|
const auto size = (Util::rng::getNext() % half) + 1; // 0-size means the end.
|
|
|
|
const auto chunk = body.substr(0, size);
|
|
response.appendChunk(chunk);
|
|
body = body.substr(size);
|
|
}
|
|
|
|
response.appendChunk(std::string()); // Empty chunk to end.
|
|
}
|
|
else
|
|
response.setBody(request.getUrl().substr(sizeof("/echo")));
|
|
}
|
|
else
|
|
response.setBody("You have reached HttpTestServer " + request.getUrl());
|
|
socket->send(response);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
http::Response response(http::StatusLine(501));
|
|
response.set("Content-Length", "0");
|
|
socket->send(response);
|
|
}
|
|
}
|
|
|
|
int getPollEvents(std::chrono::steady_clock::time_point /* now */,
|
|
int64_t& /* timeoutMaxMs */) override
|
|
{
|
|
return POLLIN;
|
|
}
|
|
|
|
void performWrites(std::size_t) override
|
|
{
|
|
std::shared_ptr<StreamSocket> socket = _socket.lock();
|
|
if (!socket)
|
|
{
|
|
LOG_ERR("Invalid socket while performing writes.");
|
|
return;
|
|
}
|
|
|
|
Buffer& out = socket->getOutBuffer();
|
|
LOG_TRC("performWrites: " << out.size() << " bytes.");
|
|
socket->flush();
|
|
}
|
|
|
|
private:
|
|
// The socket that owns us (we can't own it).
|
|
std::weak_ptr<StreamSocket> _socket;
|
|
};
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|