feat: separate router from core

Author: iboukhss

Makefile

@@ -12,12 +12,14 @@ TARGET    = $(BIN_DIR)/$(NAME)
 
 # Source tree (keep in alphabetical order)
 SRCS      = $(addprefix $(SRC_DIR)/, \
+            config/ServerConfig.hpp \
             core/Client.cpp \
             core/Client.hpp \
             core/Server.cpp \
             core/Server.hpp \
             http/HttpResponse.cpp \
             http/HttpResponse.hpp \
+            router/router.cpp \
             util/SyscallError.cpp \
             util/SyscallError.hpp \
             main.cpp \

src/config/ServerConfig.hpp

@@ -0,0 +1,28 @@
+#ifndef CONFIG_SERVER_CONFIG_HPP_
+#define CONFIG_SERVER_CONFIG_HPP_
+
+#include <string>
+#include <vector>
+
+// for dev purpose only
+struct Location {
+    std::string path;
+    std::string index;
+};
+
+struct ServerConfig {
+    int listen_port;                      // port to listen
+    std::vector<std::string> server_name; // host names
+    bool default_server;                  // default server applies to a port
+                                          // and if none is flagged default_server,
+                                          // then the first one is the default one
+    std::vector<std::string> methods;     // allowed methods
+    std::string root;
+    Location default_location;
+    std::vector<Location> locations;
+    int domain;
+    int max_conn;
+    std::string protocol;
+};
+
+#endif // CONFIG_SERVER_CONFIG_HPP_

src/core/Client.hpp

@@ -1,6 +1,9 @@
 #ifndef CORE_CLIENT_HPP_
 #define CORE_CLIENT_HPP_
 
+#include "http/HttpRequest.hpp"
+#include "http/HttpResponse.hpp"
+
 #include <netinet/in.h>
 
 #include <string>
@@ -11,11 +14,19 @@ class Client {
     ~Client();
 
     void set_nonblocking();
+    void set_request(const HttpRequest& req) { req_ = req; }
+    void set_response(const HttpResponse& res) { res_ = res; }
     void set_next(Client* conn) { next_ = conn; }
     void set_prev(Client* conn) { prev_ = conn; }
 
     int fd() const { return fd_; }
     const sockaddr_in& addr() const { return addr_; }
+
+    const HttpRequest& req() const { return req_; }
+    HttpResponse& res() { return res_; }
+    std::string& recv_buffer() { return recv_buffer_; }
+    std::string& send_buffer() { return send_buffer_; }
+
     Client* next() { return next_; }
     Client* prev() { return prev_; }
 
@@ -27,6 +38,8 @@ class Client {
 private:
     int fd_;
     sockaddr_in addr_;
+    HttpRequest req_;
+    HttpResponse res_;
     std::string recv_buffer_;
     std::string send_buffer_;
     Client* prev_;

src/core/Server.cpp

@@ -1,8 +1,8 @@
 #include "core/Server.hpp"
 
+#include "http/HttpRequest.hpp"
 #include "http/HttpResponse.hpp"
 #include "util/SyscallError.hpp"
-#include "util/structs_dev.hpp"
 
 #include <errno.h>
 #include <fcntl.h>
@@ -15,153 +15,8 @@
 
 #include <cstring>
 #include <iostream>
-#include <sstream>
 
-const char* Server::reason_phrase(int error_code)
-{
-    switch (error_code) {
-    case 400:
-        return "Bad request";
-    case 403:
-        return "Forbidden";
-    case 404:
-        return "Not found";
-    case 405:
-        return "Method not allowed";
-    case 500:
-        return "Internal server error";
-    default:
-        return "Unknown";
-    }
-}
-
-enum ErrorCodes {
-    kBadRequest = 400,
-    kForbidden = 403,
-    kNotFound = 404,
-    kMethodNotAllowed = 405,
-    kInternalServerError = 500
-};
-
-int Server::prefix_length(const std::string& req_location, const std::string& location)
-{
-    int len_min = std::min(req_location.size(), location.size());
-    int len_match = 0;
-    for (int i = 0; i < len_min; ++i) {
-        if (req_location[i] != location[i])
-            break;
-        ++len_match;
-    }
-    return (len_match);
-}
-
-// for the moment it takes some static input
-const Location* Server::routing(const std::string& req_location)
-{
-    int longest_match = 0;
-    const Location* best_match = NULL;
-    // iterrate through locations to find longest match
-    for (size_t i = 0; i < config_->locations.size(); i++) {
-        int len_match = prefix_length(req_location, config_->locations[i].path);
-        if (len_match > longest_match) {
-            best_match = &config_->locations[i];
-        }
-    }
-    return (best_match ? best_match : &(config_->default_location));
-}
-
-int Server::valid_method(const std::string& method)
-{
-    for (size_t i = 0; i < config_->methods.size(); ++i) {
-        if (method == config_->methods[i])
-            return (0);
-    }
-    return (1);
-}
-
-// Description : build full path by concat 3 elements and consider for leading/trailing backslashes
-// TO DO (DHE) : In the config parser -> ensure that root has no trailing /
-std::string Server::build_request_path(const HttpRequest& request, const Location* best_match)
-{
-    std::string full_path = config_->root;
-    std::string folder = static_cast<std::string>(best_match->path);
-    // std::cout << "root = " << full_path << std::endl;
-    std::string file =
-        request.path.substr(best_match->path.size(), request.path.size() - best_match->path.size());
-    if (full_path[full_path.size() - 1] != '/')
-        full_path = full_path + "/";
-    if (folder[0] == '/')
-        folder.erase(0, 1);
-    if (folder[folder.size() - 1] != '/')
-        folder = folder + "/";
-    if (file[0] == '/')
-        file.erase(0, 1);
-    full_path = full_path + folder + file;
-
-    if (full_path[full_path.size() - 1] == '/')
-        full_path = full_path + "index.html";
-    return (full_path);
-}
-
-void Server::send_error(Client* conn, int error_code, std::string body)
-{
-    std::ostringstream oss;
-    oss << "HTTP/1.1 " << error_code << " " << reason_phrase(error_code) << "\r\n"
-        << "Content-Type: text/plain\r\n"
-        << "Content-Length: " << body.size() << "\r\n"
-        << "\r\n"
-        << body;
-    std::string response = oss.str();
-    send(conn->fd(), response.c_str(), response.size(),
-         0); // bytes_sent can be used for debbuging
-    std::cout << "fd = " << conn->fd() << " : " << error_code << " " << reason_phrase(error_code)
-              << std::endl;
-    epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, conn->fd(), NULL);
-    remove_connection(conn);
-}
-
-void Server::handle_request(Client* conn, const HttpRequest& request)
-{
-    struct stat sb; // needed by stat to check if file exists
-    if (valid_method(request.method) != 0) {
-        send_error(conn, kMethodNotAllowed, ""); // in the end should be done
-        return;
-    }
-    if (request.path.empty()) {
-        send_error(conn, kBadRequest, "");
-        return;
-    }
-    const Location* longest_match = routing(request.path);
-    if (!longest_match) {
-        send_error(conn, kNotFound, "");
-        return;
-    }
-    std::cout << "longest_match = " << longest_match->path << std::endl;
-    std::string full_path = build_request_path(request, longest_match);
-    std::cout << "full_path = " << full_path << std::endl;
-
-    if (request.method == "GET") {
-        if (stat(full_path.c_str(), &sb) != 0) {
-            send_error(conn, kNotFound, "");
-        }
-        else {
-            send_response(conn); // here the file needs to be read and send to the socket
-        }
-        return;
-    }
-    else if (request.method == "DELETE") {
-    }
-    else if (request.method == "POST") {
-    }
-    else {
-        send_error(conn, kMethodNotAllowed, "");
-        return;
-    }
-    send_response(
-        conn); // just for testing to avoid infinite loop as the socket remains ready for read/write
-}
-
-Server::Server(in_addr_t ip, in_port_t port, int limit_conn, const ServerConfig* config)
+Server::Server(in_addr_t ip, in_port_t port, int limit_conn, ServerConfig& config)
     : config_(config)
 {
     fd_ = ::socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);
@@ -237,14 +92,7 @@ void Server::run()
                 accept_connection();
             }
             else {
-                // reading from socket and storing request in Client (TO DO : IBOUKHSS)
-                // for dev, mimic a http request and call the routing function
-                struct HttpRequest request;
-                request.method = "GET";
-                request.path = "/files/42.txt";
-                handle_request(conn,
-                               request); // no try catch required except if we define a
-                                         // scenario where we want to stop the server
+                handle_events(conn, events_[i].events);
             }
         }
     }
@@ -289,6 +137,8 @@ void Server::accept_connection()
         return;
     }
 
+    std::cout << "* Connection established\n";
+
     Client* client = new Client(client_fd, addr);
 
     epoll_event ev;
@@ -302,10 +152,72 @@ void Server::accept_connection()
     add_connection(client);
 }
 
+void Server::handle_events(Client* conn, uint32_t events)
+{
+    if (events & EPOLLIN) {
+        receive_request(conn);
+    }
+    if (events & EPOLLOUT) {
+        send_response(conn);
+    }
+}
+
+static void print_http_request(const std::string& s)
+{
+    std::cout << "< ";
+
+    for (size_t i = 0; i < s.size(); ++i) {
+        char c = s[i];
+        if (c == '\r') {
+            std::cout << "\\r";
+        }
+        else if (c == '\n') {
+            std::cout << "\\n\n";
+            if (i < s.size() - 1) {
+                std::cout << "< ";
+            }
+        }
+        else {
+            std::cout.put(c);
+        }
+    }
+    std::cout.flush();
+}
+
+void Server::receive_request(Client* conn)
+{
+    int client_fd = conn->fd();
+    char buf[4096];
+
+    int n_bytes = recv(client_fd, buf, sizeof(buf), 0);
+    conn->recv_buffer().append(buf, n_bytes);
+
+    std::cout << "* Request received\n";
+
+    print_http_request(conn->recv_buffer());
+
+    epoll_event ev;
+    ev.events = EPOLLOUT;
+    ev.data.ptr = conn;
+    epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, client_fd, &ev);
+
+    // reading from socket and storing request in Client (TO DO : IBOUKHSS)
+    // for dev, mimic a http request and call the routing function
+    HttpRequest req;
+    req.method = "GET";
+    req.path = "/files/42.txt";
+
+    conn->set_request(req);
+
+    // no try catch required except if we define a
+    // scenario where we want to stop the server
+    handle_request(conn, req);
+}
+
 void Server::send_response(Client* conn)
 {
     int client_fd = conn->fd();
-    HttpResponse res = {200, "text/plain", "Hello, client!\n"};
+    HttpResponse res = conn->res();
     std::string raw = res.to_string();
 
     send(client_fd, raw.data(), raw.size(), 0);