Server.cpp

Go to the documentation of this file.

 
 
#include "Server.hpp"
 
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <unistd.h>
 
#include <algorithm>
#include <cerrno>
#include <cctype>
#include <format>
#include <fstream>
#include <iostream>
#include <mutex>
#include <sstream>
#include <system_error>
#include <thread>
#include <utility>
 
#include "Catalog.hpp"
#include "Output.hpp"
#include "Session.hpp"
#include "Util.hpp"
 
namespace tinysql {
 
namespace {
 
constexpr std::size_t kMaxRequestSize = 64 * 1024;
 
constexpr int kIdleSeconds = 30;
 
std::mutex workMutex;
 
class Socket {
public:
    explicit Socket(int fd) : fd_(fd) {}
 
    ~Socket()
    {
        if (fd_ >= 0) {
            ::close(fd_);
        }
    }
 
    Socket(const Socket&) = delete;             
    Socket& operator=(const Socket&) = delete;  
 
    Socket(Socket&& other) noexcept : fd_(std::exchange(other.fd_, -1)) {}
    Socket& operator=(Socket&&) = delete;  
 
    int fd() const { return fd_; }
 
private:
    int fd_;  
};
 
[[noreturn]] void throwSystemError(std::string_view what)
{
    throw std::system_error(errno, std::generic_category(), std::string(what));
}
 
struct Request {
    std::string method;  
    std::string path;    
    std::string body;    
};
 
std::string_view headerValue(std::string_view head, std::string_view name)
{
    std::size_t lineStart = head.find("\r\n");
    while (lineStart != std::string_view::npos && lineStart + 2 < head.size()) {
        lineStart += 2;
        const std::size_t lineEnd = head.find("\r\n", lineStart);
        const std::string_view line = head.substr(lineStart, lineEnd - lineStart);
        const std::size_t colon = line.find(':');
        if (colon != std::string_view::npos && equalsIgnoreCase(trim(line.substr(0, colon)), name)) {
            return trim(line.substr(colon + 1));
        }
        lineStart = lineEnd;
    }
    return {};
}
 
Request readRequest(int fd)
{
    std::string raw;
    char buffer[4096];
    std::size_t headEnd = std::string::npos;
    std::size_t bodyLength = 0;
    while (raw.size() < kMaxRequestSize) {
        if (headEnd == std::string::npos && (headEnd = raw.find("\r\n\r\n")) != std::string::npos) {
            // The headers are complete: from now on, read until the body has Content-Length bytes.
            bodyLength = parseInteger(headerValue(std::string_view(raw).substr(0, headEnd), "content-length")).value_or(0);
        }
        if (headEnd != std::string::npos && raw.size() >= headEnd + 4 + bodyLength) {
            break;
        }
        const ssize_t n = ::recv(fd, buffer, sizeof buffer, 0);
        if (n <= 0) {
            break;
        }
        raw.append(buffer, static_cast<std::size_t>(n));
    }
 
    Request request;
    if (headEnd == std::string::npos) {
        return request;  // nothing, or not a complete request
    }
    // Request line: "POST /api/sql HTTP/1.1"
    const std::string_view line = std::string_view(raw).substr(0, raw.find("\r\n"));
    const std::size_t space1 = line.find(' ');
    const std::size_t space2 = line.find(' ', space1 + 1);
    if (space1 == std::string_view::npos || space2 == std::string_view::npos) {
        return request;
    }
    request.method = std::string(line.substr(0, space1));
    const std::string_view target = line.substr(space1 + 1, space2 - space1 - 1);
    request.path = std::string(target.substr(0, target.find('?')));
    request.body = raw.substr(headEnd + 4, bodyLength);
    return request;
}
 
void sendAll(int fd, std::string_view data)
{
    while (!data.empty()) {
        const ssize_t n = ::send(fd, data.data(), data.size(), MSG_NOSIGNAL);
        if (n <= 0) {
            return;  // client went away
        }
        data.remove_prefix(static_cast<std::size_t>(n));
    }
}
 
std::string httpResponse(std::string_view status, std::string_view contentType, std::string_view body)
{
    return std::format("HTTP/1.1 {}\r\nContent-Type: {}\r\nContent-Length: {}\r\n"
                       "Cache-Control: no-cache\r\nConnection: close\r\n\r\n{}",
                       status, contentType, body.size(), body);
}
 
std::string errorResponse(std::string_view status, std::string_view message)
{
    return httpResponse(status, "application/json", std::format("{{\"error\":\"{}\"}}", message));
}
 
std::string_view contentTypeFor(std::string_view name)
{
    if (name.ends_with(".html")) return "text/html; charset=utf-8";
    if (name.ends_with(".css")) return "text/css; charset=utf-8";
    if (name.ends_with(".js")) return "text/javascript; charset=utf-8";
    if (name.ends_with(".svg")) return "image/svg+xml";
    if (name.ends_with(".ico")) return "image/x-icon";
    return "application/octet-stream";
}
 
bool isSafeFileName(std::string_view name)
{
    return !name.empty() && name.front() != '.' && std::ranges::all_of(name, [](unsigned char c) {
        return std::isalnum(c) || c == '.' || c == '-' || c == '_';
    });
}
 
std::string serveFile(const ServerConfig& config, std::string_view name)
{
    if (!isSafeFileName(name)) {
        return errorResponse("404 Not Found", "Not found");
    }
    std::ifstream in(config.webDir / name, std::ios::binary);
    if (!in) {
        return errorResponse("404 Not Found", "Not found");
    }
    std::stringstream content;
    content << in.rdbuf();
    return httpResponse("200 OK", contentTypeFor(name), content.str());
}
 
std::string runSql(const ServerConfig& config, std::string_view sql)
{
    Session session(config.dataDir);
    const auto results = session.executeScript(sql);
    for (const StatementResult& result : results) {
        std::cout << renderText(result);
    }
    std::cout << std::flush;
    return httpResponse("200 OK", "application/json", renderJson(results));
}
 
std::string listTables(const ServerConfig& config)
{
    try {
        return httpResponse("200 OK", "application/json", renderTablesJson(Catalog::load(config.dataDir).tables()));
    } catch (const SqlError& e) {
        return errorResponse("500 Internal Server Error", "cannot read the table catalogue");
    }
}
 
std::string clientAddress(const sockaddr_in& address)
{
    char text[INET_ADDRSTRLEN] = {};
    ::inet_ntop(AF_INET, &address.sin_addr, text, sizeof text);
    return text;
}
 
void handleClient(const ServerConfig& config, int fd, const std::string& client)
{
    const Request request = readRequest(fd);
    if (request.method.empty()) {
        // An idle (preconnected) connection that never sent a request: close it without
        // answering. Had we answered, the browser could later read that answer as the reply
        // to the request it sends on this connection.
        return;
    }
 
    std::string response;
    if (request.method == "GET" && request.path == "/api/tables") {
        const std::scoped_lock lock(workMutex);
        response = listTables(config);
    } else if (request.method == "POST" && request.path == "/api/sql") {
        const std::scoped_lock lock(workMutex);  // one request at a time runs SQL
        std::cout << std::format("[{}] POST /api/sql\n", client);
        response = runSql(config, request.body);
    } else if (request.method == "GET") {
        response = serveFile(config, request.path == "/" ? "index.html" : std::string_view(request.path).substr(1));
    } else if (request.method == "POST") {
        response = errorResponse("404 Not Found", "Not found");
    } else {
        response = errorResponse("405 Method Not Allowed", "Only GET and POST are supported");
    }
    sendAll(fd, response);
}
 
}  // namespace
 
void runServer(const ServerConfig& config)
{
    Socket server(::socket(AF_INET, SOCK_STREAM, 0));
    if (server.fd() < 0) {
        throwSystemError("socket");
    }
    const int yes = 1;
    ::setsockopt(server.fd(), SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes);
 
    sockaddr_in address{};
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = htonl(INADDR_ANY);
    address.sin_port = htons(config.port);
    if (::bind(server.fd(), reinterpret_cast<sockaddr*>(&address), sizeof address) < 0) {
        throwSystemError(std::format("bind to port {}", config.port));
    }
    if (::listen(server.fd(), 10) < 0) {
        throwSystemError("listen");
    }
    std::cout << std::format("HTTP server listening on port {}\n", config.port) << std::flush;
 
    while (true) {
        sockaddr_in clientAddr{};
        socklen_t length = sizeof clientAddr;
        Socket client(::accept(server.fd(), reinterpret_cast<sockaddr*>(&clientAddr), &length));
        if (client.fd() < 0) {
            if (errno == EINTR) {
                continue;
            }
            throwSystemError("accept");
        }
 
        const timeval timeout{.tv_sec = kIdleSeconds, .tv_usec = 0};
        ::setsockopt(client.fd(), SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof timeout);
 
        const std::string ip = clientAddress(clientAddr);
        const bool allowed =
            config.allowedClients.empty() ||
            std::ranges::any_of(config.allowedClients, [&](const std::string& prefix) { return ip.starts_with(prefix); });
        if (!allowed) {
            const std::scoped_lock lock(workMutex);
            std::cout << std::format("[{}] rejected: not in the allowed clients\n", ip) << std::flush;
            continue;
        }
 
        // Serve the connection in its own thread, so a slow or silent client never makes the
        // others wait. The thread owns the socket (moved in) and closes it when it ends.
        std::thread([config, ip, socket = std::move(client)] {
            try {
                handleClient(config, socket.fd(), ip);
            } catch (const std::exception& e) {
                const std::scoped_lock lock(workMutex);
                std::cerr << std::format("[{}] error: {}\n", ip, e.what());
            }
        }).detach();
    }
}
 
}  // namespace tinysql