Loading static files is almost done, for some reason there is a segmentation error thrown when attempting to.

Needs more debugging.

Author: lh5053

index.txt

@@ -0,0 +1 @@
+Example index file

src/Worker.cpp

@@ -3,12 +3,17 @@
 #include <netdb.h>
 #include <unistd.h>
 #include <stdlib.h>
+#include <stdio.h>
 #include <cstring>
 #include <string.h>
+#include <fcntl.h>
+#include <linux/limits.h>
 
 #include "Worker.h"
 #include "BasicHTTP.h"
 
+#define HTTP_REQUEST_LENGTH 8192
+
 /*
  * worker - uses an appropriate handler to serve the request
  */
@@ -23,30 +28,116 @@ Worker::~Worker() {
 	close(this->socket_fd);
 }
 
+//void read_static_file(std::string path, char * data);
+std::string get_working_path();
+
 void Worker::handle_request() {
-    char reply[100], *msg;
+    char *request = (char *)calloc(HTTP_REQUEST_LENGTH, sizeof(char)); // standard limit of 8kb
 
     this->logger.info("Handling request via socket: " + std::to_string(this->socket_fd));
-    // Send welcome message
-    std::string string = "Welcome to HACKttp: " + std::to_string(this->socket_fd) + "\nYour message: ";
-    msg = (char *) string.c_str();
-    send(this->socket_fd, msg, strlen(msg), 0);
-
-    std::string response;
-    while(true){
-        memset(&reply, 0, sizeof reply);
-        if(recv(this->socket_fd, reply, 100, 0) <= 0)
+
+    // first read the request
+    if(recv(this->socket_fd, request, HTTP_REQUEST_LENGTH, 0) <= 0) {
+        // TODO replace with proper HTTP response
+        char * err = std::strerror(errno);
+        throw WorkerException("Error while reading request: " + std::string(err ? err : "unknown error"));
+    }
+
+    // get the static file contents
+    std::string req_str = std::string(request);
+    int space_count = 0;
+    size_t pos = 0, prev_pos = 0;
+    while (space_count < 2) {
+        prev_pos = pos;
+        if ((pos = req_str.find(" ", prev_pos+1)) != std::string::npos) {
+            space_count++;
+        }
+        else
             break;
-        response.append("HackTTP echo: ");
-        response.append(reply);
-        response.append("\nYour message: ");
-        msg = (char *)response.c_str();
-        send(this->socket_fd, msg, strlen(msg), 0);
-        //reply[99] = '\0';
-        printf("Sent back: %s", response.c_str());
-        response.clear();
     }
+
+    char * data;
+    if (space_count == 2) {
+        std::string file_path = req_str.substr(prev_pos, pos-prev_pos);
+//        data = "Contents of file at: " + file_path + "\nUsing request: " + req_str;
+        if (file_path.compare("/"))
+            file_path = "/index.txt";
+
+        file_path = get_working_path() + file_path;
+        int fd = open(file_path.c_str(), O_RDONLY);
+        if (fd < 0) {
+            // TODO: replace with a proper HTTP CODE
+            char * err = std::strerror(errno);
+            throw WorkerException("Error while reading file contents at " + file_path + ": " + std::string(err ? err : "unknown error"));
+        }
+
+        this->logger.debug("Opened file: " + file_path);
+
+        long fsize = lseek(fd, 0, SEEK_END);
+        lseek(fd, 0, SEEK_SET);
+
+        this->logger.debug("File size: " + std::to_string(fsize));
+        data = (char *) malloc(fsize+1);
+        this->logger.debug("Memory assigned");
+        read(fd, &data, fsize);
+        this->logger.debug("Data read");
+        close(fd);
+        // add null termination
+        this->logger.debug("... and null-terminated");
+        data[fsize] = '\0';
+
+//        this->logger.debug("File data: " + std::string(data));
+//        read_static_file(file_path, data);
+    }
+    else {
+        data = (char*) std::string("Error, could not parse request").c_str();
+    }
+
+//    data.append("Welcome to HACKttp: " + std::to_string(this->socket_fd) + "<br/>Your message: ");
+//    data.append(file_path);
+//    send_msg(data);
+
+    // now answer
+//    printf("Sending data: %s\n", data);
+    if (send(this->socket_fd, data, strlen(data), 0) < 0) {
+        char * err = std::strerror(errno);
+        throw WorkerException("Error while reading request: " + std::string(err ? err : "unknown error"));
+    }
+    free(data);
+
     this->logger.debug("Reqest handling done");
 
     return;
 }
+
+void Worker::send_msg(std::string msg) {
+    char *msgc = (char *) msg.c_str();
+    send(this->socket_fd, msgc, strlen(msgc), 0);
+    return;
+}
+
+//void read_static_file(std::string path, char * data) {
+//    // prepend cwd() to path
+//    path = get_working_path() + 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 WorkerException("Error while reading file contents at " + path + ": " + std::string(err ? err : "unknown error"));
+//    }
+//
+//    lseek(fd, 0, SEEK_END);
+//    long fsize = lseek(fd, 0, SEEK_CUR);
+//    lseek(fd, 0, SEEK_SET);
+//
+//    data = (char *) malloc(fsize + 1);
+//    read(fd, &data, fsize);
+//    close(fd);
+//
+//    return;
+//}
+
+std::string get_working_path() {
+   char temp[PATH_MAX];
+   return ( getcwd(temp, PATH_MAX) ? std::string( temp ) : std::string("") );
+}

src/Worker.h

@@ -1,17 +1,34 @@
 #ifndef SRC_WORKER_H_
 #define SRC_WORKER_H_
 
+#include <cstring>
 #include "Logger.h"
 
 class Worker {
 private:
     int socket_fd;
     Logger logger;
+    void send_msg(std::string msg);
 
 public:
 	Worker(int socket_fd);
 	virtual ~Worker();
 	void handle_request();
 };
 
+using namespace std;
+// Possibly we could also add a stack trace here:
+// http://stackoverflow.com/questions/353180/how-do-i-find-the-name-of-the-calling-function
+class WorkerException: public exception {
+    std::string reason;
+
+    public:
+        WorkerException(std::string msg = "Unknown exception") {
+            reason = msg;
+        }
+        virtual const char* what() const throw() {
+            return reason.c_str();
+        }
+};
+
 #endif /* SRC_WORKER_H_ */