path: root/src/http1.cc

//
// Created by luqiu on 2018-5-22.
//

/* HTTP/HTTP2 Protocol Handler
 *
 * Author: Lu Qiuwen<[email protected]>
 * Date: 2018-04-08
 *
 */

#include <vector>
#include <array>
#include <list>
#include <map>
#include <memory>
#include <cassert>

#include <http_parser.h>
#include <event2/bufferevent.h>
#include <evdns.h>

#include "pxyconn.h"
#include "http.h"
#include "httpscan.h"
#include "compat.h"
#include "util.h"


class Http1Connection : public HttpConnection
{
public:
    Http1Connection() = default;
    ~Http1Connection() = default;

    int on_connection_read_request(pxy_conn_ctx_t *conn_ctx, pxy_conn_desc_t *conn_this, pxy_conn_desc_t *conn_other);
    int on_connection_read_response(pxy_conn_ctx_t *conn_ctx, struct bufferevent *bev);
    int on_connection_close(pxy_conn_ctx_t *conn_ctx, struct bufferevent *bev);

private:
    using http_sessions_t = std::list<std::unique_ptr<HttpSession>>;
    http_sessions_t http_sessions_;

    HttpSession & create_new_session();
    HttpSession & last_uncomplete_session();

    void drop_last_session();
    void drop_first_session();
};

class Http1Request : public HttpRequest
{
public:
    Http1Request();
    virtual ~Http1Request() = default;

    virtual ssize_t ConstructFromMemory(const char *buf, size_t buflen);
    virtual ssize_t ConstructFromEvBuf(struct evbuffer * evbuf_ptr);

    virtual evbuffer_unique_ptr_t StolenEvbuf() { return std::move(evbuf_content_raw_); }

    bool ReadOnly() override { return readonly_; }
    void ReadOnly(bool is_readonly) override { readonly_ = is_readonly; }

    bool Forward() override { return forward_; }
    void Forward(bool is_forward) override { forward_ = is_forward; }
    virtual void ForEachHeader(for_each_header_cb_t cb);
    bool Complete() override { return request_complete_; }

private:
    std::string str_uri{};
    std::map<std::string, std::string> str_headers{};
    std::string str_last_header_field_{};

    bool request_header_complete_{false};
    bool request_body_complete_{false};
    bool request_complete_{false};

    bool forward_{true};
    bool readonly_{false};

    std::unique_ptr<struct http_parser> parser_{new struct http_parser};
    evbuffer_unique_ptr_t evbuf_content_raw_{evbuffer_unique_ptr_t(evbuffer_new())};
};

Http1Request::Http1Request()
{
    http_parser_init(parser_.get(), HTTP_REQUEST);
}

ssize_t Http1Request::ConstructFromMemory(const char *buf, size_t buflen)
{
    static http_data_cb __http_parser_cb_on_uri = [](http_parser *parser, const char *at, size_t length) -> int
    {
        auto *__ptr_this = reinterpret_cast<Http1Request *>(parser->data);
        __ptr_this->str_uri = std::string(at, at + length);
        return 0;
    };

    static http_data_cb __http_parser_cb_on_header_field = [](http_parser *parser, const char *at, size_t length) -> int
    {
        auto *__ptr_this = reinterpret_cast<Http1Request *>(parser->data);
        __ptr_this->str_last_header_field_ = std::string(at, at + length);
        return 0;
    };

    static http_data_cb __http_parser_cb_on_header_value = [](http_parser *parser, const char *at, size_t length) -> int
    {
        auto *__ptr_this = reinterpret_cast<Http1Request *>(parser->data);
        __ptr_this->str_headers[__ptr_this->str_last_header_field_] = std::string(at, at + length);
        return 0;
    };

    static http_cb __http_parser_cb_on_message_complete = [](http_parser *parser) -> int
    {
        auto *__ptr_this = reinterpret_cast<Http1Request *>(parser->data);
        __ptr_this->request_complete_ = true;
        return 0;
    };

    static struct http_parser_settings __parser_setting =
    {
        nullptr, /* on_message_begin */
        __http_parser_cb_on_uri, /* on_url */
        nullptr, /* on_status */
        __http_parser_cb_on_header_field, /* on_header_field */
        __http_parser_cb_on_header_value, /* on_header_value */
        __http_parser_cb_on_message_complete, /* on_headers_complete */
        nullptr, /* on_body */
        nullptr /* on_message_complete */
    };

    parser_->data = this;
    size_t sz_parsed = http_parser_execute(parser_.get(), &__parser_setting, buf, buflen);

    /* 解析错误 */
    if (sz_parsed && parser_->http_errno > 0)
    {
        log_err_printf("Http Parser errno: %d", parser_->http_errno);
        return -1;
    }

    return sz_parsed;
}

ssize_t Http1Request::ConstructFromEvBuf(struct evbuffer * evbuf_ptr)
{
    /* 展平输入的Buffer为线性空间 */
    auto * __data_ptr = (const char *)(evbuffer_pullup(evbuf_ptr, -1));
    size_t __data_len = evbuffer_get_length(evbuf_ptr);

    /* 解析输入的Buffer */
    ssize_t forward_len = ConstructFromMemory(__data_ptr, __data_len);
    if (forward_len < 0) return forward_len;

    /* 已解析的部分，从原Buffer中抽离出来 */
    struct evbuffer * reserved_buffer = evbuffer_new();
    evbuffer_remove_buffer(evbuf_ptr, reserved_buffer, static_cast<size_t>(forward_len));

    /* 保存在上下文中 */
    evbuffer_add_buffer(evbuf_content_raw_.get(), reserved_buffer);
    return forward_len;
}

void Http1Request::ForEachHeader(HttpRequest::for_each_header_cb_t cb)
{
    for(auto & __iterate : str_headers)
    {
        const std::string & __key = __iterate.first;
        const std::string & __value = __iterate.second;

        cb(__key, __value);
    }

    return;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//  HTTP Response Parser Implementation for HTTP 1.0/1.1
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

static const char *informational_phrases[] = {
    /* 100 */ "Continue",
    /* 101 */ "Switching Protocols"
};

static const char *success_phrases[] = {
    /* 200 */ "OK",
    /* 201 */ "Created",
    /* 202 */ "Accepted",
    /* 203 */ "Non-Authoritative Information",
    /* 204 */ "No Content",
    /* 205 */ "Reset Content",
    /* 206 */ "Partial Content"
};

static const char *redirection_phrases[] = {
    /* 300 */ "Multiple Choices",
    /* 301 */ "Moved Permanently",
    /* 302 */ "Found",
    /* 303 */ "See Other",
    /* 304 */ "Not Modified",
    /* 305 */ "Use Proxy",
    /* 307 */ "Temporary Redirect"
};

static const char *client_error_phrases[] = {
    /* 400 */ "Bad Request",
    /* 401 */ "Unauthorized",
    /* 402 */ "Payment Required",
    /* 403 */ "Forbidden",
    /* 404 */ "Not Found",
    /* 405 */ "Method Not Allowed",
    /* 406 */ "Not Acceptable",
    /* 407 */ "Proxy Authentication Required",
    /* 408 */ "Request Time-out",
    /* 409 */ "Conflict",
    /* 410 */ "Gone",
    /* 411 */ "Length Required",
    /* 412 */ "Precondition Failed",
    /* 413 */ "Request Entity Too Large",
    /* 414 */ "Request-URI Too Large",
    /* 415 */ "Unsupported Media Type",
    /* 416 */ "Requested range not satisfiable",
    /* 417 */ "Expectation Failed"
};

static const char *server_error_phrases[] = {
    /* 500 */ "Internal Server Error",
    /* 501 */ "Not Implemented",
    /* 502 */ "Bad Gateway",
    /* 503 */ "Service Unavailable",
    /* 504 */ "Gateway Time-out",
    /* 505 */ "HTTP Version not supported"
};

const char * __resp_code_to_str(int resp_code)
{
    if (resp_code >= 101 && resp_code <= 102) return informational_phrases[resp_code - 101];
    if (resp_code >= 200 && resp_code <= 206) return success_phrases[resp_code - 200];
    if (resp_code >= 300 && resp_code <= 307) return redirection_phrases[resp_code - 300];
    if (resp_code >= 400 && resp_code <= 417) return client_error_phrases[resp_code - 400];
    if (resp_code >= 500 && resp_code <= 505) return server_error_phrases[resp_code - 500];

    return nullptr;
}

class Http1Response : public HttpResponse
{
public:
    Http1Response();
    virtual ~Http1Response() = default;

    virtual ssize_t ConstructFromMemory(const char * buf, size_t buflen);
    virtual ssize_t ConstructFromEvBuf(struct evbuffer * evbuf_len);
    evbuffer_unique_ptr_t StolenEvBuf() { return std::move(evbuf_content_raw_); }

    virtual int ResponseCode() final { return resp_code_; }
    virtual bool ReadOnly() final { return readonly_; }
    virtual void ReadOnly(bool is_readonly) final { readonly_ = is_readonly; }
    virtual bool Forward() final {return forward_; }
    virtual void Forward(bool is_forward) final { forward_ = is_forward; }
    virtual bool Complete() final { return parse_complete_; }
    virtual void Construct() final;

private:
    int resp_code_;
    short resp_version_major_;
    short resp_version_minor_;

    std::map<std::string, std::string> str_headers{};
    std::string str_last_header_field_{};

    bool parse_complete_{false};
    bool forward_{true};
    bool readonly_{false};

    std::unique_ptr<struct http_parser> parser_{new struct http_parser};
    evbuffer_unique_ptr_t evbuf_content_raw_{nullptr};
};

Http1Response::Http1Response()
{
    http_parser_init(parser_.get(), HTTP_RESPONSE);
}

ssize_t Http1Response::ConstructFromMemory(const char *buf, size_t buflen)
{
    struct http_parser_settings __parser_setting{nullptr};

    __parser_setting.on_status = [](http_parser *parser, const char *at, size_t length) -> int
    {
        auto *__ptr_this = reinterpret_cast<Http1Response *>(parser->data);
        __ptr_this->str_uri = std::string(at, at + length);
        return 0;
    };

    __parser_setting.on_header_field = [](http_parser *parser, const char *at, size_t length) -> int
    {
        auto *__ptr_this = reinterpret_cast<Http1Response *>(parser->data);
        __ptr_this->str_last_header_field_ = std::string(at, at + length);
        return 0;
    };

    __parser_setting.on_header_value = [](http_parser *parser, const char *at, size_t length) -> int
    {
        auto *__ptr_this = reinterpret_cast<Http1Response *>(parser->data);
        __ptr_this->str_headers[__ptr_this->str_last_header_field_] = std::string(at, at + length);
        return 0;
    };

    __parser_setting.on_message_complete = [](http_parser * parser)->int
    {
        auto *__ptr_this = reinterpret_cast<Http1Response *>(parser->data);
        __ptr_this->parse_complete_ = true;
        return 0;
    };

    parser_->data = this;
    size_t sz_parsed = http_parser_execute(parser_.get(), &__parser_setting, buf, buflen);

    /* 解析错误 */
    if (sz_parsed && parser_->http_errno > 0)
    {
        throw invalid_input_format(string_format("Failed at http parsing: errcode=%u, %s, %s",
            parser_->http_errno, http_errno_name(static_cast<http_errno>(parser_->http_errno)),
            http_errno_description(static_cast<http_errno>(parser_->http_errno))));
    }

    return sz_parsed;
}

ssize_t Http1Response::ConstructFromEvBuf(struct evbuffer *evbuf_ptr)
{
    /* 展平输入的Buffer为线性空间 */
    auto * __data_ptr = (const char *)(evbuffer_pullup(evbuf_ptr, -1));
    size_t __data_len = evbuffer_get_length(evbuf_ptr);

    /* 解析输入的Buffer */
    ssize_t forward_len = ConstructFromMemory(__data_ptr, __data_len);
    if (forward_len < 0) return forward_len;

    /* 已解析的部分，从原Buffer中抽离出来 */
    struct evbuffer * reserved_buffer = evbuffer_new();
    evbuffer_remove_buffer(evbuf_ptr, reserved_buffer, static_cast<size_t>(forward_len));

    /* 保存在上下文中 */
    evbuffer_add_buffer(evbuf_content_raw_.get(), reserved_buffer);
    return forward_len;
}

void Http1Response::Construct()
{
    /* 新申请EvBuffer */
    evbuffer_unique_ptr_t evbuf_construct = evbuffer_unique_ptr_t(evbuffer_new());
    struct evbuffer * evbuf_ptr = evbuf_construct.get();

    /* 应答第一行 */
    evbuffer_add_printf(evbuf_ptr, "HTTP/%d.%d %d %s\r\n",
        resp_version_major_, resp_version_minor_, resp_code_, __resp_code_to_str(resp_code_));

    /* 应答头部 */
    for(const auto & __iterate : str_headers)
    {
        const auto & __header_field = __iterate.first;
        const auto & __header_value = __iterate.second;

        evbuffer_add_printf(evbuf_ptr, "%s:%s\r\n", __header_field.c_str(), __header_value.c_str());
    }

    /* TODO: 消息体的构建 */
    evbuf_content_raw_ = std::move(evbuf_construct);
}

int Http1Connection::on_connection_close(pxy_conn_ctx_t *conn_ctx, struct bufferevent *bev)
{
    return 0;
}

int Http1Connection::on_connection_read_request(pxy_conn_ctx_t *conn_ctx,
                                                pxy_conn_desc_t *conn_this, pxy_conn_desc_t *conn_other)
{
    /* Get the last session */
    auto http_session_ctx = last_uncomplete_session();

    auto * request_ctx = reinterpret_cast<Http1Request *>(http_session_ctx.request());
    auto *downstream_evbuf = bufferevent_get_input(conn_this->bev);
    auto *upstream_evbuf = bufferevent_get_output(conn_other->bev);

    ssize_t forward_len = request_ctx->ConstructFromEvBuf(downstream_evbuf);

    if (forward_len < 0)
    {
        conn_ctx->passthrough = 1;
        return 0;
    }

    if (request_ctx->request_complete)
    {
        httpscan_ctx->ScanRequestHeader(http_session_ctx);
        httpscan_ctx->ScanRequestBody(http_session_ctx);

        if (http_session_ctx->need_to_close_connection)
        {
            conn_ctx->enomem = 1;
            return 0;
        }

        /* 转发请求 */
        if (request_ctx->forward)
        {
            evbuffer_add_buffer(upstream_evbuf, request_ctx->StolenRawEvbuf());
            return 0;
        }

        /* 丢弃请求，检查是否构建了响应 */
        auto * response_ctx = reinterpret_cast<Http1Response *>(http_session_ctx->response());
        if (response_ctx != nullptr)
        {
            struct evbuffer * resp_evbuf = response_ctx->stolen_content_raw();
            bufferevent_write_buffer(conn_this->bev, resp_evbuf);

            printf("bufferevent_get_enabled, conn_this = %d\n", bufferevent_get_enabled(conn_this->bev));
            printf("bufferevent_get_enabled, conn_other = %d\n", bufferevent_get_enabled(conn_other->bev));
        }

        /* 最后一个Session已经处理完毕，丢弃上下文 */
        drop_last_session();
        return 0;
    }

    if (request_ctx->transport_forward)
    {
        evbuffer_add_buffer(upstream_evbuf, request_ctx->StolenRawEvbuf());
        return 0;
    }

    return 0;
}

int Http1Connection::on_connection_read_response(pxy_conn_ctx_t *conn_ctx, struct bufferevent *bev)
{
    return 0;
}

HttpSession & Http1Connection::create_new_session()
{
    /* Create new session, set a new request */
    auto __http_session = std::unique_ptr<HttpSession>(new HttpSession(*this));
    __http_session->request(HttpRequestFactory(1, 0));

    /* Add to the last record */
    http_sessions_.push_back(__http_session);
    return *__http_session;
}

HttpSession & Http1Connection::last_uncomplete_session()
{
    if (http_sessions_.cbegin() == http_sessions_.cend())
        return create_new_session();

    /* 最后一个Session已经处理结束了，新建一个Session */
    auto __session = http_sessions_.back();
    if (__session->request()->request_complete)
        return create_new_session();

    /* 否则，返回最后一个没有完全处理结束的Session */
    return __session;
}

void Http1Connection::drop_last_session()
{
    assert(http_sessions_.cbegin() != http_sessions_.cend());
    http_sessions_.pop_back();
}

void Http1Connection::drop_first_session()
{
    assert(http_sessions_.cbegin() != http_sessions_.cend());
    http_sessions_.pop_front();
}

std::unique_ptr<HttpRequest> HttpRequestFactory(int primary_version, int second_version)
{
    if (primary_version == 1 && second_version == 0)
        return std::move(std::make_unique<Http1Request>());
    if (primary_version == 1 && second_version == 1)
        return std::move(std::make_unique<Http1Request>());

    assert(0);
    return nullptr;
}

std::unique_ptr<HttpResponse> HttpResponseFactory(int primary_version, int second_version)
{
    if (primary_version == 1 && second_version == 0)
        return std::move(std::make_unique<Http1Response>());
    if (primary_version == 1 && second_version == 1)
        return std::move(std::make_unique<Http1Response>());

    assert(0);
    return nullptr;
}