feat: getters for fd

Author: StokesAsselborn

src/handler/delete_handler.cpp

@@ -14,7 +14,9 @@
 
 DeleteHandler::DeleteHandler(const std::string& path)
     : file_path_(path),
-      headers_off_(0)
+      headers_off_(0),
+      read_fd_(-1),
+      write_fd_(-1)
 {
     struct stat file_stat;
     HttpResponse res;
@@ -52,6 +54,14 @@ DeleteHandler::DeleteHandler(const std::string& path)
 
 DeleteHandler::~DeleteHandler()
 {
+    if (read_fd_ != -1) {
+        close(read_fd_);
+        read_fd_ = -1;
+    }
+    if (write_fd_ != -1) {
+        close(write_fd_);
+        write_fd_ = -1;
+    }
 }
 
 size_t DeleteHandler::read_data(char* buf, size_t n)

src/handler/delete_handler.hpp

@@ -12,6 +12,9 @@ class DeleteHandler : public Handler {
     explicit DeleteHandler(const std::string& path);
     virtual ~DeleteHandler();
 
+    virtual int get_read_fd() const { return read_fd_; };
+    virtual int get_write_fd() const { return write_fd_; };
+
     virtual size_t read_data(char* buf, size_t n);
     virtual size_t write_data(const char* buf, size_t n);
 
@@ -30,6 +33,9 @@ class DeleteHandler : public Handler {
 
     std::string headers_;
     size_t headers_off_;
+
+    int read_fd_;
+    int write_fd_;
 };
 
 #endif

src/handler/error_handler.cpp

@@ -2,6 +2,8 @@
 
 #include "util/log_message.hpp"
 
+#include <unistd.h>
+
 #include <cstring>
 #include <iostream>
 
@@ -23,7 +25,9 @@ size_t ErrorHandler::write_data(const char* buf, size_t n)
 }
 
 ErrorHandler::ErrorHandler(HttpResponse::Status code)
-    : res_sent_(false)
+    : res_sent_(false),
+      read_fd_(-1),
+      write_fd_(-1)
 {
     res_.code = code;
     res_.inline_body = "<h1> some error code to be shown here <h1>";
@@ -32,4 +36,12 @@ ErrorHandler::ErrorHandler(HttpResponse::Status code)
 
 ErrorHandler::~ErrorHandler()
 {
+    if (read_fd_ != -1) {
+        close(read_fd_);
+        read_fd_ = -1;
+    }
+    if (write_fd_ != -1) {
+        close(write_fd_);
+        write_fd_ = -1;
+    }
 }

src/handler/error_handler.hpp

@@ -11,6 +11,9 @@ class ErrorHandler : public Handler {
     explicit ErrorHandler(HttpResponse::Status code);
     virtual ~ErrorHandler();
 
+    virtual int get_read_fd() const { return read_fd_; };
+    virtual int get_write_fd() const { return write_fd_; };
+
     virtual size_t read_data(char* buf, size_t n);
     virtual size_t write_data(const char* buf, size_t n);
 
@@ -27,6 +30,9 @@ class ErrorHandler : public Handler {
     // NOTE: HttpResponse is default constructed with HTTP/1.1 + keep-alive
     HttpResponse res_;
     bool res_sent_;
+
+    int read_fd_;
+    int write_fd_;
 };
 
 #endif

src/handler/handler.hpp

@@ -7,6 +7,9 @@ class Handler {
 public:
     virtual ~Handler() {}
 
+    virtual int get_read_fd() const = 0;
+    virtual int get_write_fd() const = 0;
+
     virtual size_t read_data(char* buf, size_t n) = 0;
     virtual size_t write_data(const char* buf, size_t n) = 0;
 

src/handler/static_file_handler.cpp

@@ -74,10 +74,11 @@ static const char* derive_file_type(const std::string& file_path)
 StaticFileHandler::StaticFileHandler(const std::string& path,
                                      const RouteConfig& rc,
                                      const HttpRequest& saved_request)
-    : fd_(-1),
-      file_size_(0),
+    : file_size_(0),
       eof_reached_(false),
-      headers_off_(0)
+      headers_off_(0),
+      read_fd_(-1),
+      write_fd_(-1)
 {
     HttpResponse res(saved_request.http_version);
     std::string full_path = resolve_path(path, rc.config.index_files);
@@ -93,7 +94,7 @@ StaticFileHandler::StaticFileHandler(const std::string& path,
 
     struct stat file_stat;
 
-    fd_ = open(full_path.c_str(), O_RDONLY);
+    read_fd_ = open(full_path.c_str(), O_RDONLY);
     stat(full_path.c_str(), &file_stat);
     file_size_ = file_stat.st_size;
 
@@ -107,8 +108,14 @@ StaticFileHandler::StaticFileHandler(const std::string& path,
 
 StaticFileHandler::~StaticFileHandler()
 {
-    if (fd_ != -1)
-        close(fd_);
+    if (read_fd_ != -1) {
+        close(read_fd_);
+        read_fd_ = -1;
+    }
+    if (write_fd_ != -1) {
+        close(write_fd_);
+        write_fd_ = -1;
+    }
 }
 
 size_t StaticFileHandler::read_data(char* buf, size_t n)
@@ -128,7 +135,7 @@ size_t StaticFileHandler::read_data(char* buf, size_t n)
         }
     }
     if (has_body() && !body_sent()) {
-        int body_bytes = read(fd_, buf + bytes_written, n - bytes_written);
+        int body_bytes = read(read_fd_, buf + bytes_written, n - bytes_written);
         if (body_bytes == -1) {
             throw std::runtime_error("read failed");
         }

src/handler/static_file_handler.hpp

@@ -17,6 +17,9 @@ class StaticFileHandler : public Handler {
 
     virtual ~StaticFileHandler();
 
+    virtual int get_read_fd() const { return read_fd_; };
+    virtual int get_write_fd() const { return write_fd_; };
+
     virtual size_t read_data(char* buf, size_t n);
     virtual size_t write_data(const char* buf, size_t n);
 
@@ -28,15 +31,17 @@ class StaticFileHandler : public Handler {
     StaticFileHandler(const StaticFileHandler&);
     StaticFileHandler& operator=(const StaticFileHandler&);
 
-    bool has_body() const { return fd_ != -1; }
+    bool has_body() const { return read_fd_ != -1; }
     bool headers_sent() const { return headers_off_ == headers_.size(); }
     bool body_sent() const { return eof_reached_; }
 
-    int fd_;
     off_t file_size_;
     bool eof_reached_;
     std::string headers_;
     size_t headers_off_;
+
+    int read_fd_;
+    int write_fd_;
 };
 
 #endif

src/handler/upload_handler.cpp

@@ -29,11 +29,12 @@ Also, the UploadHandler could handle, both POST and PUT requests
 
 UploadHandler::UploadHandler(const std::string& path, size_t content_length)
     : file_path_(path),
-      fd_(-1),
       bytes_written_(0),
       content_length_(content_length),
       eob_reached_(false),
-      headers_off_(0)
+      headers_off_(0),
+      read_fd_(-1),
+      write_fd_(-1)
 {
     struct stat file_stat;
     if (stat(path.c_str(), &file_stat) == 0 && S_ISREG(file_stat.st_mode)) {
@@ -44,8 +45,8 @@ UploadHandler::UploadHandler(const std::string& path, size_t content_length)
         headers_ = res.to_string();
         return;
     }
-    fd_ = open(path.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0644);
-    if (fd_ == -1) {
+    write_fd_ = open(path.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0644);
+    if (write_fd_ == -1) {
         HttpResponse res;
         res.code = HttpResponse::kStatusDiskFull;
         res.inline_body = "<h1> 507 Disk Full </h1>"; // to display a message during testing
@@ -56,8 +57,14 @@ UploadHandler::UploadHandler(const std::string& path, size_t content_length)
 
 UploadHandler::~UploadHandler()
 {
-    if (fd_ != -1)
-        close(fd_);
+    if (read_fd_ != -1) {
+        close(read_fd_);
+        read_fd_ = -1;
+    }
+    if (write_fd_ != -1) {
+        close(write_fd_);
+        write_fd_ = -1;
+    }
 }
 
 bool UploadHandler::needs_input() const
@@ -81,7 +88,7 @@ size_t UploadHandler::read_data(char* buf, size_t n)
 
 size_t UploadHandler::write_data(const char* buf, size_t n)
 {
-    ssize_t bytes = write(fd_, buf, n);
+    ssize_t bytes = write(write_fd_, buf, n);
     if (bytes == -1) {
         // error occured
         eob_reached_ = true;

src/handler/upload_handler.hpp

@@ -12,6 +12,9 @@ class UploadHandler : public Handler {
     explicit UploadHandler(const std::string& path, size_t content_lenght);
     virtual ~UploadHandler();
 
+    virtual int get_read_fd() const { return read_fd_; };
+    virtual int get_write_fd() const { return write_fd_; };
+
     virtual size_t read_data(char* buf, size_t n); // we should not read from this handler
     virtual size_t write_data(const char* buf, size_t n);
 
@@ -29,12 +32,14 @@ class UploadHandler : public Handler {
 
     const std::string file_path_;
 
-    int fd_;
     size_t bytes_written_;
     size_t content_length_;
     bool eob_reached_;
     std::string headers_;
     size_t headers_off_;
+
+    int read_fd_;
+    int write_fd_;
 };
 
 #endif