Moved HTTP requests parsing/headers construction to BasicHTTP.

Moved file/executables handling to dedicated modules (Static/Exec).

Author: LeHack

src/BasicHTTP.cpp

@@ -1,13 +1,80 @@
 #include "BasicHTTP.h"
 
 /*
- * BasicHTTP - implements a simple way to create serializable HTTP reponses that can be returned by router
+ * BasicHTTP - implements a simple way to create serializable HTTP reponses that can be returned by worker
  */
 
 BasicHTTP::BasicHTTP() {
-
+    this->logger = new Logger("BasicHTTP");
 }
 
 BasicHTTP::~BasicHTTP() {
+    delete(this->logger);
+}
+
+bool is_valid(BasicHTTP::request req, std::string http_ver) {
+    // if all tests pass, return true
+    return (
+        (http_ver == "HTTP/1.0" || http_ver == "HTTP/1.1")
+        && req.method == "GET" // || POST
+        && req.uri.length() > 0
+    );
 }
 
+BasicHTTP::request BasicHTTP::parse_request(std::string req_str) {
+    request req;
+    // From http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html#sec5
+    // Request-Line   = Method SP Request-URI SP HTTP-Version CRLF
+    size_t pos = 0, prev_pos = 0;
+
+    // first read the method
+    if ((pos = req_str.find(" ", prev_pos)) != std::string::npos) {
+        req.method = req_str.substr(prev_pos, pos-prev_pos);
+        prev_pos = pos + 1;
+    }
+
+    // the the uri
+    if ((pos = req_str.find(" ", prev_pos)) != std::string::npos) {
+        req.uri = req_str.substr(prev_pos, pos-prev_pos);
+        prev_pos = pos + 1;
+    }
+
+    // finally the HTTP version
+    std::string http_ver;
+    if ((pos = req_str.find("\r\n", prev_pos)) != std::string::npos) {
+        http_ver = req_str.substr(prev_pos, pos-prev_pos);
+        prev_pos = pos + 1;
+    }
+    this->logger->info("Method: " + req.method + ", HTTP version string: " + http_ver + ", URI: " + req.uri);
+
+    // now end with checking if it's actually valid
+    req.valid  = is_valid(req, http_ver);
+
+    return req;
+}
+
+BasicHTTP::response BasicHTTP::render_headers(int code, DataHandler::resource rsrc) {
+    response resp;
+
+    // by default no headers are created
+    resp.has_headers = false;
+    if (rsrc.type != "executable") {
+        resp.headers =
+            "HTTP/1.1 "+std::to_string(code)+" OK\n"
+            "Server: HackTTP\n"
+            "Connection: close\n"
+            "Content-Type: "+rsrc.type+"\n";
+        ;
+
+        if (rsrc.type.find("image/") != std::string::npos) {
+            resp.headers += "Accept-Ranges: bytes\n";
+            resp.headers += "Content-Length: " + std::to_string(rsrc.size) + "\n";
+        }
+
+        // now send the headers
+        resp.headers += "\n";
+        resp.has_headers = true;
+    }
+
+    return resp;
+}

src/BasicHTTP.h

@@ -1,10 +1,45 @@
 #ifndef SRC_BASICHTTP_H_
 #define SRC_BASICHTTP_H_
 
+#include "DataHandler.h"
+#include "Exceptions.h"
+#include "Logger.h"
+
+// Currently returned HTTP CODES
+#define HTTP_OK                 200
+#define HTTP_BAD_REQUEST        400
+#define HTTP_FORBIDDEN          403
+#define HTTP_NOT_FOUND          404
+#define HTTP_UNSUP_MEDIA_TYPE   415
+#define HTTP_INTERNAL_SRV_ERROR 500
+#define HTTP_NOT_IMPLEMENTED    501
+
 class BasicHTTP {
+private:
+    Logger *logger;
 public:
-	BasicHTTP();
+    struct request {
+        std::string method;
+        std::string uri;
+        bool valid;
+    };
+
+    struct response {
+        std::string headers;
+        bool has_headers;
+    };
+
+    BasicHTTP();
 	virtual ~BasicHTTP();
+	request  parse_request(std::string req_str);
+	response render_headers(int code, DataHandler::resource rsrc);
+
+    class Exception: public BaseException {
+        public:
+            Exception(std::string msg = "Unknown basic http exception") {
+                this->reason = msg;
+            }
+    };
 };
 
 #endif /* SRC_BASICHTTP_H_ */

src/DataHandler.cpp

@@ -40,7 +40,7 @@ bool is(char * mime, std::string type) {
     return (strstr(mime, type.c_str()) != NULL);
 }
 
-resource DataHandler::read_resource(std::string path) {
+DataHandler::resource DataHandler::read_resource(std::string path) {
     // prepend cwd() to path
 
     if (!verify_path(path))
@@ -51,16 +51,17 @@ resource DataHandler::read_resource(std::string path) {
     this->logger->debug("Checking resource at: " + path);
 
     // check mime type of resource
+    DataHandler::Exec runner;
     std::string args[2] = { "/usr/bin/file", path };
-    resource file_mime = run_command(args);
+    DataHandler::resource file_mime = runner.run_command(args);
     char * mime = file_mime.data;
 
-    resource output;
+    DataHandler::resource output;
     // now check for known mime types
     if (is(mime, "executable")) {
         // run the script
         std::string args[2] = { path, "" }; // TODO: Fix me too!
-        resource script_output = run_command(args);
+        DataHandler::resource script_output = runner.run_command(args);
         output.data = script_output.data;
         output.size = script_output.size;
         output.type = "executable";
@@ -73,7 +74,8 @@ resource DataHandler::read_resource(std::string path) {
     else if (is(mime, "MS Windows icon"))            { output.type = "image/vnd.microsoft.icon";  }
 
     if (output.type.length() > 0 && output.type != "executable") {
-        resource f = get_file(path);
+        DataHandler::Static getter;
+        DataHandler::resource f = getter.get_file(path);
         output.data = f.data;
         output.size = f.size;
     }
@@ -95,32 +97,9 @@ std::string DataHandler::get_working_path() {
    return ( getcwd(temp, PATH_MAX) ? std::string( temp ) : std::string("") );
 }
 
-resource DataHandler::get_file(std::string path) {
-    this->logger->debug("Read file: " + path);
-    int fd = open(path.c_str(), O_RDONLY);
-    if (fd < 0) {
-        // TODO: replace with a proper HTTP CODE
-        char * err = std::strerror(errno);
-        throw DataHandler::FileNotFound("Error while reading file contents at " + path + ": " + std::string(err ? err : "unknown error"));
-    }
-
-    long fsize = lseek(fd, 0, SEEK_END);
-    lseek(fd, 0, SEEK_SET);
-
-    resource data;
-    data.data = (char *) malloc(fsize+1);
-    read(fd, data.data, fsize);
-    close(fd);
-
-    data.data[fsize] = '\0';
-    data.size = fsize;
-
-    return data;
-}
-
-resource DataHandler::get_error_file(int error_code, std::string param) {
+DataHandler::resource DataHandler::get_error_file(int error_code, std::string param) {
     // start by reading the error template
-    resource output = read_resource("/errors/"+ std::to_string(error_code) +".html");
+    DataHandler::resource output = DataHandler::read_resource("/errors/"+ std::to_string(error_code) +".html");
     // now prepare a place to write the filled template
     long new_size = output.size + param.length() - 3;
     char * data = (char *) malloc(new_size * sizeof(char));
@@ -135,85 +114,3 @@ resource DataHandler::get_error_file(int error_code, std::string param) {
 
     return output;
 }
-
-resource DataHandler::run_command(std::string args[]) {
-    int comms[2];
-    // start with a small 1k buffer
-    int buf_pos = 0, buf_max = 1024, buf_blocks = 1;
-    resource output;
-    output.data = (char *) malloc(buf_blocks * buf_max * sizeof(char));
-
-    if (pipe(comms) < 0) {
-        char * err = std::strerror(errno);
-        throw DataHandler::Exception("Cannot create pipe: " + std::string(err ? err : "unknown error"));
-    }
-
-    int pid = fork();
-    if (pid == 0) {
-        // redirect STDOUT to our comms
-        if (dup2(comms[1], STDOUT_FILENO) == -1) {
-            char * err = std::strerror(errno);
-            throw DataHandler::Exception("Cannot redirect STDOUT to pipe: " + std::string(err ? err : "unknown error"));
-        }
-
-        // same with STDERR
-        if (dup2(comms[1], STDERR_FILENO) == -1) {
-            char * err = std::strerror(errno);
-            throw DataHandler::Exception("Cannot redirect STDERR to pipe: " + std::string(err ? err : "unknown error"));
-        }
-
-        // now close the pipe on our side
-        close(comms[0]);
-
-        // now run the target
-        // TODO: Fix me! I'm ugly!
-        if (execl(args[0].c_str(), args[0].c_str(), args[1].c_str(), (char *) 0) < 0) {
-            char * err = std::strerror(errno);
-            throw DataHandler::Exception(
-                "Cannot exec '" + std::string(args[0]) + "' due to: " + std::string(err ? err : "unknown error")
-            );
-        }
-    }
-    else if (pid > 0) {
-        close(comms[1]);
-
-        // Just a char by char read here, you can change it accordingly
-        char rchar;
-        while (read(comms[0], &rchar, 1) == 1) {
-            output.data[buf_pos++] = rchar;
-            if (buf_pos >= buf_max){
-                // extend the buffer by another 1k block
-                buf_blocks++;
-                // reset the curent position
-                buf_pos = 0;
-                // allocate more memory
-                output.data = (char *) realloc(output.data, buf_blocks * buf_max * sizeof(char));
-                if (output.data == NULL) {
-                    char * err = std::strerror(errno);
-                    throw DataHandler::Exception(
-                        "Error while reading output from: " + std::string(args[0]) +", "
-                        + "because of: " + std::string(err ? err : "unknown error")
-                    );
-                }
-            }
-        }
-        // add NULL termination
-        output.data[buf_pos] = '\0';
-        output.size = (buf_blocks - 1) * buf_max + buf_pos + 1;
-
-        close(comms[0]);
-    }
-    else {
-        // fork failed
-        char * err = std::strerror(errno);
-        close(comms[0]);
-        close(comms[1]);
-        throw DataHandler::Exception("Cannot fork: " + std::string(err ? err : "unknown error"));
-    }
-
-    if (strstr(output.data, "DataHandler::Exception") != NULL) {
-        throw DataHandler::Exception("Fork returned an exception: " + std::string(output.data));
-    }
-
-    return output;
-}

src/DataHandler.h

@@ -4,26 +4,44 @@
 #include "Exceptions.h"
 #include "Logger.h"
 
-struct resource {
-    std::string type;
-    char * data;
-    long size;
-};
-
 class DataHandler {
+public:
+    struct resource {
+        std::string type;
+        char * data;
+        long size;
+    };
+
 private:
     Logger *logger;
     std::string get_working_path();
     bool verify_path(std::string path);
-    resource run_command(std::string args[]);
-    resource get_file(std::string path);
-
 public:
-	DataHandler();
+    DataHandler();
 	virtual ~DataHandler();
 	resource read_resource(std::string path);
 	resource get_error_file(int error_code, std::string param);
 
+	class Static {
+        private:
+            Logger *logger;
+        public:
+            Static();
+            ~Static();
+            resource get_file(std::string path);
+            resource get_error_file(int error_code, std::string param);
+	};
+
+    class Exec {
+        private:
+            Logger *logger;
+        public:
+            Exec();
+            ~Exec();
+            resource run_command(std::string args[]);
+    };
+
+	// Exceptions
     class Exception: public BaseException {
         public:
             Exception(std::string msg = "Unknown data handler exception") {