HttpResponse.cpp

Go to the documentation of this file.

 
#include "http/HttpResponse.h"
#include "http/JsonResponse.h"
#include "framework_config.h" 
#include "DebugTrace.h"
TRACE_INIT(HttpResponse)
 
#include <sstream>
#include <cstring>
#include <lwip/sockets.h>
#include "utility/utility.h"
#include "framework/FrameworkView.h"
#include "http/HttpFileserver.h"
 
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
 
HttpResponse::HttpResponse(Tcp* tcp)
    : tcp(tcp), status_code(200), headerSent(false)
{
}
 
// ------------------------------------------------------------------------
// Status and Header Management
// ------------------------------------------------------------------------
 
HttpResponse &HttpResponse::status(int code)
{
    status_code = code;
    return *this;
}
 
HttpResponse& HttpResponse::setStatus(int code)
{
    status_code = code;
    return *this;
}
 
HttpResponse& HttpResponse::set(const std::string &field, const std::string &value)
{
    headers[field] = value;
    return *this;
}
 
HttpResponse& HttpResponse::setHeader(const std::string &key, const std::string &value)
{
    headers[key] = value;
    return *this;
}
 
HttpResponse& HttpResponse::setContentType(const std::string &ct)
{
    headers["Content-Type"] = ct;
    return *this;
}
 
HttpResponse& HttpResponse::setAuthorization(const std::string &jwtToken)
{
    if (!jwtToken.empty())
    {
        headers["Authorization"] = "Bearer " + jwtToken;
    }
    return *this;
}
 
std::string HttpResponse::getContentType() const
{
    auto it = headers.find("Content-Type");
    return (it != headers.end()) ? it->second : "text/html";
}
 
bool HttpResponse::isHeaderSent() const
{
    return headerSent;
}
 
int HttpResponse::getSocket() const
{
    return tcp->getSocketFd();
}
 
std::string HttpResponse::getStatusMessage(int code)
{
    switch (code)
    {
    case 200:
        return "OK";
    case 401:
        return "Unauthorized";
    case 404:
        return "Not Found";
    case 500:
        return "Internal Server Error";
    default:
        return "";
    }
}
 
// ------------------------------------------------------------------------
// Cookie Support
// ------------------------------------------------------------------------
 
HttpResponse &HttpResponse::setCookie(const std::string &name, const std::string &value, const std::string &options)
{
    std::ostringstream cookie;
    cookie << name << "=" << value;
    if (!options.empty())
    {
        cookie << "; " << options;
    }
    cookies.push_back(cookie.str());
    return *this;
}
 
HttpResponse &HttpResponse::clearCookie(const std::string &name, const std::string &options)
{
    std::ostringstream cookie;
    cookie << name << "=; Max-Age=0";
    if (!options.empty())
    {
        cookie << "; " << options;
    }
    cookies.push_back(cookie.str());
    return *this;
}
 
// ------------------------------------------------------------------------
// Body and Streaming
// ------------------------------------------------------------------------
 
void HttpResponse::send(const std::string &body)
{
    TRACE("HttpResponse::send()\n");
    if (!headerSent)
    {
        if (headers.find("Content-Length") == headers.end())
        {
            headers["Content-Length"] = std::to_string(body.size());
        }
        if (headers.find("Content-Type") == headers.end())
        {
            headers["Content-Type"] = "text/html";
        }
 
        std::ostringstream resp;
        resp << "HTTP/1.1 " << status_code << " " << getStatusMessage(status_code) << "\r\n";
        for (auto &h : headers)
        {
            resp << h.first << ": " << h.second << "\r\n";
        }
        for (const auto &cookie : cookies)
        {
            resp << "Set-Cookie: " << cookie << "\r\n";
        }
        resp << "\r\n";
 
        std::string header_str = resp.str();
        tcp->send(header_str.c_str(), header_str.size());
        headerSent = true;
    }
 
    tcp->send(body.data(), body.size());
    TRACE("HttpResponse::send() completed\n");
}
 
void HttpResponse::sendHeaders()
{
    if (!headerSent)
    {
        std::ostringstream resp;
        resp << "HTTP/1.1 " << status_code << " " << getStatusMessage(status_code) << "\r\n";
 
        for (auto &h : headers)
        {
            resp << h.first << ": " << h.second << "\r\n";
        }
        for (const auto &cookie : cookies)
        {
            resp << "Set-Cookie: " << cookie << "\r\n";
        }
        if (headers.find("Connection") == headers.end())
        {
            resp << "Connection: close\r\n";
        }
        resp << "\r\n";
 
        std::string header_str = resp.str();
        tcp->send(header_str.c_str(), header_str.size()); 
        headerSent = true;
    }
}
 
void HttpResponse::start(int code, size_t contentLength, const std::string &contentType, const std::string &contentEncoding)
{
    status_code = code;
    headers["Content-Length"] = std::to_string(contentLength);
    headers["Content-Type"] = contentType;
    if (!contentEncoding.empty())
    {
        headers["Content-Encoding"] = contentEncoding;
    }
 
    std::ostringstream resp;
    resp << "HTTP/1.1 " << status_code << " " << getStatusMessage(status_code) << "\r\n";
    for (auto &h : headers)
    {
        resp << h.first << ": " << h.second << "\r\n";
    }
    for (const auto &cookie : cookies)
    {
        resp << "Set-Cookie: " << cookie << "\r\n";
    }
    resp << "\r\n";
 
    std::string header_str = resp.str();
    tcp->send(header_str.c_str(), header_str.size());
    headerSent = true;
}
 
void HttpResponse::writeChunk(const char *data, size_t length)
{
    if (!headerSent)
    {
        printf("Error: writeChunk called before start()\n");
        return;
    }
 
    int err = tcp->send(data, length); 
    if (err < 0)
    {
        printf("Error sending chunk: %zu\n", err);
        printf("Error: %s\n", strerror(errno));
    }
}
 
void HttpResponse::finish()
{
    // Placeholder for future expansion (e.g., chunked transfer end).
}
 
// ------------------------------------------------------------------------
// Helpers
// ------------------------------------------------------------------------
 
void HttpResponse::sendUnauthorized()
{
    this->status(401)
        .set("Content-Type", "application/json")
        .send("{\"error\": \"Unauthorized\"}");
}
 
void HttpResponse::sendNotFound()
{
    return status(404)
        .setContentType("application/json")
        .send(R"({"error": "Not Found"})");
}
 
void HttpResponse::endServerError(const std::string &message)
{
    return status(500)
        .setContentType("application/json")
        .send("{\"error\": \"" + message + "\"}");
}
 
HttpResponse &HttpResponse::json(const std::string &body)
{
    this->set("Content-Type", "application/json")
        .send(body);
    return *this;
}
// send a json object
HttpResponse &HttpResponse::json(const nlohmann::json &jsonObj)
{
    return json(jsonObj.dump()); // dump() creates a compact string
}
 
HttpResponse &HttpResponse::jsonFormatted(const nlohmann::json &jsonObj)
{
    return json(jsonObj.dump(2)); // dump() creates a compact string
}
 
HttpResponse &HttpResponse::text(const std::string &body)
{
    this->set("Content-Type", "text/plain")
        .send(body);
    return *this;
}
 
HttpResponse &HttpResponse::redirect(const std::string &url, int code)
{
    this->status(code)
        .set("Location", url)
        .send("");
    return *this;
}
 
std::string HttpResponse::renderTemplate(const std::string &tpl, const std::map<std::string, std::string> &context)
{
    std::string result = tpl;
    for (const auto &[key, value] : context)
    {
        std::string placeholder = "{{" + key + "}}";
        size_t pos = 0;
        while ((pos = result.find(placeholder, pos)) != std::string::npos)
        {
            result.replace(pos, placeholder.length(), value);
            pos += value.length();
        }
    }
    return result;
}
 
 
// ------------------------------------------------------------------------
// ─────                 View related                                 ─────
// ------------------------------------------------------------------------
 
 
void HttpResponse::send(const std::string& body, const std::string& contentType) {
    setHeader("Content-Type", contentType);
    send(body);
}
 
#include "framework/FrameworkView.h"
 
void HttpResponse::send(const FrameworkView& view,
                        const std::map<std::string, std::string>& context) {
    view.applyHeaders(*this);
    setContentType(view.getContentType());
    std::string body = view.render(context);
    send(body);
}
 
 
 
HttpResponse& HttpResponse::setBody(const std::string& body) {
    this->body = body;
    return *this;
}
 
void HttpResponse::reset() {
    status_code = 0;
    headers.clear();
    body.clear();
}
 
bool HttpResponse::sendFile(const std::string& path)
{
    FileHandler fileHandler;
    return fileHandler.serveFile(*this, path.c_str());
}
 
HttpResponse& HttpResponse::sendError(int statusCode, const std::string& message) {
    JsonResponse::sendError(*this, statusCode, "error", message);
    return *this;
}
 
//#if defined(PICO_HTTP_ENABLE_STORAGE)
HttpResponse& HttpResponse::toFile(const std::string& path, StorageManager* storage)
{
    if (!storage || body.empty())
        return *this;
 
    storage->writeFile(path,
                reinterpret_cast<const unsigned char*>(body.data()),
                body.size());
                return *this;
}
//#endif