feat: add HTTP/1.1 keep-alive sessions

Author: iboukhss

.clang-format

@@ -10,6 +10,9 @@ IndentAccessModifiers: false
 AccessModifierOffset: -4
 
 AllowShortFunctionsOnASingleLine: InlineOnly
+# Experimental flag, could fail at anytime
+ExperimentalAutoDetectBinPacking: true
+
 BreakConstructorInitializers: BeforeColon
 PackConstructorInitializers: Never
 

.clang-tidy

@@ -39,6 +39,8 @@ CheckOptions:
     value: CamelCase
   - key: readability-identifier-naming.EnumConstantPrefix
     value: k
+  - key: readability-identifier-naming.EnumConstantIgnoredRegexp
+    value: '^k([A-Z][a-z]*)+[0-9]+(_[0-9])+$'
   # Global constants
   - key: readability-identifier-naming.GlobalConstantCase
     value: CamelCase

Makefile

@@ -43,6 +43,8 @@ srcs = \
   src/http/http_request.hpp \
   src/http/http_response.cpp \
   src/http/http_response.hpp \
+  src/http/http_version.cpp \
+  src/http/http_version.hpp \
   src/router/router.cpp \
   src/router/router.hpp \
   src/util/log_message.cpp \

src/core/client.cpp

@@ -9,7 +9,8 @@
 #include <iostream>
 
 Client::Client(uint64_t id, int fd, const sockaddr_in& addr)
-    : id_(id),
+    : state_(kReceivingHeaders),
+      id_(id),
       fd_(fd),
       addr_(addr),
       handler_(NULL)

src/core/client.hpp

@@ -12,37 +12,36 @@
 
 class Client {
 public:
+    enum State { kClosingConnection = 0, kReceivingHeaders, kReceivingBody, kSendingResponse };
+
     Client(uint64_t id, int fd, const sockaddr_in& addr);
     ~Client();
 
     // setters
     void set_handler(Handler* handler) { handler_ = handler; }
     void set_nonblocking();
-    void set_request(const HttpRequest& req) { req_ = req; }
-    void set_response(const HttpResponse& res) { res_ = res; }
+    void set_state(Client::State state) { state_ = state; }
 
     // getters
+    Client::State state() { return state_; }
     uint64_t id() const { return id_; }
     int fd() const { return fd_; }
+    bool keep_alive() { return parser_.request().keep_alive; }
     const sockaddr_in& addr() const { return addr_; }
-    const HttpRequest& req() const { return req_; }
-    HttpResponse& res() { return res_; }
-
     std::string& send_buffer() { return send_buffer_; }
-    Handler* handler() const { return handler_; }
     HttpParser& parser() { return parser_; }
+    Handler* handler() const { return handler_; }
 
 private:
     Client();
     Client(const Client& other);
     Client& operator=(const Client& other);
 
 private:
+    Client::State state_;
     uint64_t id_;
     int fd_;
     sockaddr_in addr_;
-    HttpRequest req_;
-    HttpResponse res_; // TODO: remove
     std::string send_buffer_;
     HttpParser parser_;
     Handler* handler_;

src/core/server.cpp

@@ -183,89 +183,142 @@ static void print_raw_data(const char* s, size_t n)
     std::cout.flush();
 }
 
-void Server::handle_events(Client& conn, uint32_t events)
+static void log_request_info(uint64_t client_id, const HttpRequest& request)
+{
+    LOG(INFO) << "Client #" << client_id << ": " << request.method << " " << request.path << " "
+              << request.http_version;
+}
+
+void Server::read_from_socket(Client& conn)
 {
+    if (conn.state() != Client::kReceivingHeaders && conn.state() != Client::kReceivingBody)
+        return;
+
     char tmp[4096];
-    uint64_t client_id = conn.id();
+    ssize_t bytes_received = recv(conn.fd(), tmp, sizeof(tmp), 0);
+
+    if (bytes_received == 0) {
+        LOG(INFO) << "Client #" << conn.id() << ": connection closed by remote client";
+        conn.set_state(Client::kClosingConnection);
+        return;
+    }
+
     HttpParser& parser = conn.parser();
-    uint32_t next_events = 0;
+    parser.append_data(tmp, bytes_received);
+    print_raw_data(tmp, bytes_received);
 
-    // Can read from socket
-    if (events & EPOLLIN) {
+    if (conn.state() == Client::kReceivingHeaders) {
 
-        size_t bytes_received = recv(conn.fd(), tmp, sizeof(tmp), 0);
+        if (parser.state() == HttpParser::kParsingError) {
+            LOG(ERROR) << "Client #" << conn.id() << ": invalid HTTP request";
+            conn.set_state(Client::kClosingConnection);
+            return;
+        }
 
-        if (bytes_received == 0) {
-            LOG(INFO) << "Client #" << client_id << ": connection closed by remote client";
-            close_connection(conn);
+        if (parser.state() < HttpParser::kParsingBody) {
             return;
         }
 
-        LOG(DEBUG) << "Client #" << client_id << ": " << bytes_received << " bytes received";
-        print_raw_data(tmp, bytes_received);
+        LOG(DEBUG) << "WE PARSED ALL HEADERS";
 
-        // Feed data to the parser
-        parser.feed_data(tmp, bytes_received);
+        // We parsed headers and might have some or all body bytes?
+        log_request_info(conn.id(), parser.request());
+        conn.set_handler(router_.handle_request(parser.request()));
 
-        if (parser.status() == HttpParser::kError) {
-            LOG(ERROR) << "Client #" << client_id << ": invalid HTTP request";
-            close_connection(conn);
-            return;
+        if (conn.handler()->needs_input()) {
+            conn.set_state(Client::kReceivingBody);
         }
+        else {
+            conn.set_state(Client::kSendingResponse);
+        }
+    }
 
-        if (!conn.handler() && parser.status() >= HttpParser::kHeadersDone) {
-            HttpRequest req = parser.request();
-            LOG(INFO) << "Client #" << client_id << ": " << req.method << " " << req.path << " "
-                      << req.http_version;
-
-            Handler* h = router_.handle_request(req);
-            conn.set_handler(h);
+    if (conn.state() == Client::kReceivingBody) {
+        size_t n = 0;
+        while ((n = parser.read_body_chunk(tmp, sizeof(tmp))) > 0) {
+            conn.handler()->write_data(tmp, n);
         }
-        if (conn.handler()) {
-            if (conn.handler()->needs_input()) {
-                size_t n = parser.slurp_data(tmp, sizeof(tmp));
-                (void) conn.handler()->write_data(tmp, n);
-            }
+        if (conn.handler()->has_output()) {
+            conn.set_state(Client::kSendingResponse);
         }
     }
+}
 
-    // Can write to socket
-    if (events & EPOLLOUT) {
-        if (conn.handler()) {
+void Server::write_to_socket(Client& conn)
+{
+    assert(conn.handler() && "Handler must exist when writing to socket");
 
-            Handler& handler = *conn.handler();
-            std::string& send_buffer = conn.send_buffer();
+    if (conn.state() != Client::kSendingResponse)
+        return;
 
-            if (handler.has_output()) {
-                size_t n = handler.read_data(tmp, sizeof(tmp));
-                send_buffer.append(tmp, n);
-            }
-            if (!send_buffer.empty()) {
-                size_t bytes_sent = send(conn.fd(), send_buffer.data(), send_buffer.size(), 0);
-                if (bytes_sent == 0) {
-                    LOG(WARN) << "Client #" << client_id << ": failed to send any bytes!";
-                }
-                else {
-                    send_buffer.erase(0, bytes_sent);
-                }
-            }
-            // Treat all connections as HTTP/1.0 for now (do not keep-alive)
-            if (send_buffer.empty() && handler.is_done()) {
-                LOG(DEBUG) << "Client #" << client_id << ": response sent";
-                close_connection(conn);
-                return;
-            }
+    char tmp[4096];
+    Handler& handler = *conn.handler();
+    std::string& send_buffer = conn.send_buffer();
+
+    if (handler.has_output()) {
+        size_t n = handler.read_data(tmp, sizeof(tmp));
+        send_buffer.append(tmp, n);
+    }
+    if (!send_buffer.empty()) {
+        size_t bytes_sent = send(conn.fd(), send_buffer.data(), send_buffer.size(), 0);
+        if (bytes_sent == 0) {
+            LOG(WARN) << "Client #" << conn.id() << ": failed to send any bytes!";
+        }
+        else {
+            send_buffer.erase(0, bytes_sent);
         }
     }
 
-    // Update next event subscription
-    if (!conn.handler() || conn.handler()->needs_input())
-        next_events |= EPOLLIN;
-    if (conn.handler() && (conn.handler()->has_output() || !conn.send_buffer().empty()))
-        next_events |= EPOLLOUT;
+    // All data has been written to socket -> either close or keep going
+    if (handler.is_done() && send_buffer.empty()) {
+        LOG(DEBUG) << "Client #" << conn.id() << ": response sent";
+
+        if (conn.keep_alive()) {
+            conn.parser().reset_for_next_request();
+            delete conn.handler();
+            conn.set_handler(NULL);
+            conn.set_state(Client::kReceivingHeaders);
+            LOG(DEBUG) << "WE DELETED THE HANDLER";
+        }
+        else {
+            conn.set_state(Client::kClosingConnection);
+        }
+    }
+}
+
+void Server::handle_events(Client& conn, uint32_t events)
+{
+    if (events & EPOLLIN) {
+        read_from_socket(conn);
+        LOG(DEBUG) << "WE READ FROM SOCKET";
+    }
+    if (events & EPOLLOUT) {
+        write_to_socket(conn);
+        LOG(DEBUG) << "WE WROTE TO SOCKET";
+    }
+
+    if (conn.state() == Client::kClosingConnection) {
+        close_connection(conn);
+        return;
+    }
 
     epoll_event ev;
-    ev.data.u64 = client_id;
-    ev.events = next_events;
+    ev.data.u64 = conn.id();
+
+    if (conn.state() == Client::kReceivingHeaders) {
+        ev.events = EPOLLIN;
+        epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, conn.fd(), &ev);
+        LOG(DEBUG) << "WE REGISTERED EPOLLIN";
+        return;
+    }
+
+    uint32_t event_mask = 0;
+
+    if (conn.handler()->needs_input())
+        event_mask |= EPOLLIN;
+    if (conn.handler()->has_output() || !conn.send_buffer().empty())
+        event_mask |= EPOLLOUT;
+
+    ev.events = event_mask;
     epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, conn.fd(), &ev);
 }

src/core/server.hpp

@@ -27,6 +27,8 @@ class Server {
 
     void accept_connection();
     void handle_events(Client& conn, uint32_t events);
+    void read_from_socket(Client& conn);
+    void write_to_socket(Client& conn);
 
     uint64_t add_connection(int client_fd, const sockaddr_in& addr);
     void close_connection(Client& conn);

src/core/server_defaults.hpp

@@ -1,10 +1,12 @@
 #ifndef SERVER_DEFAULTS_HPP_
 #define SERVER_DEFAULTS_HPP_
 
+#include "http/http_version.hpp"
+
 #define WEBSERV_DEFAULT_PORT          8080
 #define WEBSERV_DEFAULT_BACKLOG       128
 #define WEBSERV_DEFAULT_MAX_BODY_SIZE (1 << 20) // 1MB
 
-#define WEBSERV_DEFAULT_HTTP_VERSION  "HTTP/1.0"
+#define WEBSERV_DEFAULT_HTTP_VERSION  kHttpVersion1_1
 
 #endif // SERVER_DEFAULTS_HPP_

src/handler/error_handler.cpp

@@ -24,7 +24,6 @@ size_t ErrorHandler::write_data(const char* buf, size_t n)
 ErrorHandler::ErrorHandler(HttpResponse::Status code)
     : res_sent_(false)
 {
-    res_.http_version = "HTTP/1.1";
     res_.code = code;
     res_.inline_body = "<h1> some error code to be shown here <h1>";
     LOG(DEBUG) << "ErrorHandler constructed with code " << code;

src/handler/error_handler.hpp

@@ -14,16 +14,17 @@ class ErrorHandler : public Handler {
     virtual size_t read_data(char* buf, size_t n);
     virtual size_t write_data(const char* buf, size_t n);
 
-    virtual bool has_output() const { return (!res_sent_); };
-    virtual bool needs_input() const { return (false); };
-    virtual bool is_done() const { return (res_sent_); };
+    virtual bool has_output() const { return (!res_sent_); }
+    virtual bool needs_input() const { return (false); }
+    virtual bool is_done() const { return (res_sent_); }
 
-    int error_code() { return res_.code; };
+    int error_code() { return res_.code; }
 
 private:
     ErrorHandler(const ErrorHandler&);
     ErrorHandler& operator=(const ErrorHandler&);
 
+    // NOTE: HttpResponse is default constructed with HTTP/1.1 + keep-alive
     HttpResponse res_;
     bool res_sent_;
 };