Merged in changes from the radio project, since a number of changes had been made which fixed various bugs in the web server

Author: aliabbas299792

.gitignore

@@ -4,4 +4,5 @@ build
 .config
 .cache
 .clangd
-compile_commands.json
+compile_commands.json
+**/vendor

.gitmodules

@@ -1,3 +1,6 @@
 [submodule "src/vendor/readerwriterqueue"]
 	path = src/vendor/readerwriterqueue
 	url = https://github.com/cameron314/readerwriterqueue
+[submodule "src/vendor/json"]
+	path = src/vendor/json
+	url = https://github.com/nlohmann/json.git

server

@@ -4,12 +4,14 @@ project(webserver)
 
 set(CMAKE_CXX_STANDARD 11)
 
-# set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-omit-frame-pointer -fsanitize=address")
-# set (CMAKE_LINKER_FLAGS_DEBUG "${CMAKE_LINKER_FLAGS_DEBUG} -fno-omit-frame-pointer -fsanitize=address")
+# set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-omit-frame-pointer -Og -fsanitize=address,undefined")
+# set (CMAKE_LINKER_FLAGS_DEBUG "${CMAKE_LINKER_FLAGS_DEBUG} -fno-omit-frame-pointer -Og -fsanitize=address,undefined")
+
+# set (CMAKE_CXX_FLAGS_RELEASE "-03")
 
 set( SOURCE_FILE_LIST ${SOURCE_FILES} ) # SOURCE_FILES is a space separated list of files passed in on the command line
 separate_arguments(SOURCE_FILE_LIST) # the string list is made into an actual list
 
 add_executable(webserver ${SOURCE_FILE_LIST}) # the list is passed here to actually set the source files
-#SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -D_GLIBCXX_DEBUG=1")
-target_link_libraries(webserver -luring -lcrypto -lwolfssl -lpthread)
+# SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -D_GLIBCXX_DEBUG=1")
+target_link_libraries(webserver -luring -lcrypto -lwolfssl -lpthread -lcurl)

src/CMakeLists.txt

@@ -5,6 +5,7 @@
 #include <unordered_set>
 
 #include <iostream>
+#include <queue>
 
 // If using this across multiple threads, only call free_item/allocate_item on one thread,
 // and only those, after you're sure that (when deleting) the ptr you're using is definitely
@@ -21,7 +22,7 @@ namespace data_store_namespace {
       if(--item.second == 0){
         free(data_vec[idx].first);
         data_vec[idx] = { nullptr, -1 };
-        free_idxs.insert(idx);
+        free_idxs.insert(free_idxs.end(), idx);
       }
     }
 
@@ -61,7 +62,7 @@ namespace data_store_namespace {
 
   class data_store {
     std::vector<std::pair<std::vector<char>, int>> data_vec{};
-    std::unordered_set<int> free_idxs{};
+    std::queue<int> free_idxs{};
 
     struct buff {
       void *ptr{};
@@ -80,15 +81,23 @@ namespace data_store_namespace {
       auto &item = data_vec[idx];
       if(--item.second == 0){
         data_vec[idx] = { {}, -1 };
-        free_idxs.insert(idx);
+        free_idxs.push(idx);
       }
     }
 
+    size_t const size() { return data_vec.size() - free_idxs.size(); }
+    size_t const full_size() {
+      size_t all_size{};
+      for(std::pair<std::vector<char>, int> &item : data_vec)
+        all_size += item.first.size();
+      return all_size;
+    }
+
     buff_idx_pair make_item(size_t size, int uses){ // used to allocate and insert an item
       int idx = 0;
       if(free_idxs.size() > 0){
-        idx = *free_idxs.cbegin();
-        free_idxs.erase(idx);
+        idx = free_idxs.front();
+        free_idxs.pop();
       }else{
         data_vec.emplace_back();
         idx = data_vec.size() - 1;
@@ -101,8 +110,8 @@ namespace data_store_namespace {
     buff_idx_pair insert_item(std::vector<char> &&buff, int uses){ // inserts and from then on assume the buff belongs to this data store
       int idx = 0;
       if(free_idxs.size() > 0){
-        idx = *free_idxs.cbegin();
-        free_idxs.erase(idx);
+        idx = free_idxs.front();
+        free_idxs.pop();
       }else{
         data_vec.emplace_back();
         idx = data_vec.size() - 1;

src/header/data_store.h

@@ -8,8 +8,7 @@
 
 #include <sys/syscall.h> //syscall stuff parameters (as in like __NR_io_uring_enter/__NR_io_uring_setup)
 #include <sys/mman.h> //for mmap
-#include <sys/eventfd.h> // for eventfd
-#include <sys/timerfd.h> // for timerfd
+#include <sys/eventfd.h> // for eventfd=
 
 #include <liburing.h> //for liburing
 
@@ -61,7 +60,7 @@ namespace tcp_tls_server {
     // fields used for any request
     event_type event;
     int client_idx = -1;
-    int ID = -1;
+    int ID = 0;
 
     // fields used for write requests
     size_t written{}; //how much written so far
@@ -71,6 +70,7 @@ namespace tcp_tls_server {
     // fields used for read requests
     std::vector<char> read_data{};
     size_t read_amount{}; //how much has been read (in case of multi read requests)
+    bool auto_retry = false; // whether or not to use custom_read_req_continued
 
     // extra
     int64_t custom_info{}; //any custom info you want to attach to the request
@@ -124,7 +124,7 @@ namespace tcp_tls_server {
   };
 
   struct client_base {
-    int id = -1;
+    int id = 0; // id is only used to ensure the connection is unique
     int sockfd = -1;
     std::queue<write_data> send_data{};
 
@@ -162,20 +162,17 @@ namespace tcp_tls_server {
       std::set<int> freed_indexes{}; //using a set to store free indexes instead
       std::vector<client<T>> clients{};
 
-      int timerfd = timerfd_create(CLOCK_MONOTONIC, 0); // used for pinging connections
-
       void add_tcp_accept_req();
 
       //need it protected rather than private, since need to access from children
       int add_write_req(int client_idx, event_type event, const char *buffer, unsigned int length); //this is for the case you want to write a buffer rather than a vector
       //used internally for sending messages
       int add_read_req(int client_idx, event_type event); //adds a read request to the io_uring ring
-      //arms the timerfd
-      void add_timerfd_read_req();
 
       void custom_read_req_continued(request *req, size_t last_read); //to finish off partial reads
 
       int setup_client(int client_idx);
+      void clean_up_client_resources(int client_idx, bool trigger_callback = true); // used for cleaning up client resources
 
       void event_read(int event_fd, event_type event); //will set a read request for the eventfd
 
@@ -203,12 +200,14 @@ namespace tcp_tls_server {
       void read_connection(int client_idx);
 
       //to read for a custom fd and be notified via the CUSTOM_READ event
-      void custom_read_req(int fd, size_t to_read, int client_idx = -1, std::vector<char> &&buff = {}, size_t read_amount = 0);
+      void custom_read_req(int fd, size_t to_read, bool auto_retry = false, int client_idx = -1, std::vector<char> &&buff = {}, size_t read_amount = 0); // auto_retry is for calling custom_read_req_continued
 
       void notify_event();
       void kill_server(); // will kill the server
 
       bool is_active = true; // is the server active (only false once it received an exit signal)
+
+      std::string get_ip_address(int client_idx);
   };
 
   template<>
@@ -250,7 +249,7 @@ namespace tcp_tls_server {
       }
 
       template<typename U>
-      void broadcast_message(U begin, U end, int num_clients, const char *buff, size_t length, uint64_t custom_info = 0){ //if the buff pointer is ever invalidated, it will just fail to write - so sort of unsafe on its own
+      void broadcast_message(U begin, U end, int num_clients, const char *buff, size_t length, uint64_t custom_info = -1){ //if the buff pointer is ever invalidated, it will just fail to write - so sort of unsafe on its own
         if(num_clients > 0){
           for(auto client_idx_ptr = begin; client_idx_ptr != end; client_idx_ptr++){
             auto &client = clients[(int)*client_idx_ptr];
@@ -265,7 +264,9 @@ namespace tcp_tls_server {
 
       void write_connection(int client_idx, std::vector<char> &&buff); //writing depends on TLS or SSL, unlike read
       void write_connection(int client_idx, char *buff, size_t length); //writing but using a char pointer, doesn't do anything to the data
-      void close_connection(int client_idx); //closing depends on what resources need to be freed
+
+      void start_closing_connection(int client_idx); //closing depends on what resources need to be freed
+      void finish_closing_connection(int client_idx); //closing depends on what resources need to be freed
   };
 
   template<>
@@ -317,7 +318,7 @@ namespace tcp_tls_server {
       }
 
       template<typename U>
-      void broadcast_message(U begin, U end, int num_clients, const char *buff, size_t length, uint64_t custom_info = 0){ //if the buff pointer is ever invalidated, it will just fail to write - so sort of unsafe on its own
+      void broadcast_message(U begin, U end, int num_clients, const char *buff, size_t length, uint64_t custom_info = -1){ //if the buff pointer is ever invalidated, it will just fail to write - so sort of unsafe on its own
         if(num_clients > 0){
           for(auto client_idx_ptr = begin; client_idx_ptr != end; client_idx_ptr++){
             auto &client = clients[(int)*client_idx_ptr];
@@ -332,10 +333,12 @@ namespace tcp_tls_server {
 
       void write_connection(int client_idx, std::vector<char> &&buff); //writing depends on TLS or SSL, unlike read
       void write_connection(int client_idx, char *buff, size_t length); //writing but using a char pointer, doesn't do anything to the data
-      void close_connection(int client_idx); //closing depends on what resources need to be freed
+      
+      void start_closing_connection(int client_idx); //closing depends on what resources need to be freed
+      void finish_closing_connection(int client_idx); //closing depends on what resources need to be freed
   };
 
   #include "../tcp_server/server_base.tcc" //template implementation file
 }
 
-#endif
+#endif

src/header/server.h

@@ -1,15 +1,18 @@
 #ifndef SERVER_ENUMS
 #define SERVER_ENUMS
 
+#include <linux/limits.h>
 #include <vector> //for vectors
 
 enum class server_type { TLS, NON_TLS };
 
+constexpr size_t inotify_read_size = 8192;  // to read many events, for large moves for example
+
 // for use elsewhere too
 constexpr int QUEUE_DEPTH = 256; //the maximum number of events which can be submitted to the io_uring submission queue ring at once, you can have many more pending requests though
 
 namespace tcp_tls_server {
-  enum class event_type{ ACCEPT, ACCEPT_READ, ACCEPT_WRITE, READ, WRITE, NOTIFICATION, CUSTOM_READ, TIMERFD, KILL };
+  enum class event_type{ ACCEPT, ACCEPT_READ, ACCEPT_WRITE, READ, READ_FINAL, WRITE, NOTIFICATION, CUSTOM_READ, KILL };
 
   constexpr int BACKLOG = 10; //max number of connections pending acceptance
   constexpr int READ_SIZE = 8192; //how much one read request should read
@@ -28,6 +31,6 @@ namespace tcp_tls_server {
 #define        READ_CB_PARAMS int client_idx, char* buffer, unsigned int length, tcp_tls_server::server<T> *tcp_server, void *custom_obj
 #define       WRITE_CB_PARAMS int client_idx, int broadcast_additional_info, tcp_tls_server::server<T> *tcp_server, void *custom_obj
 #define       EVENT_CB_PARAMS tcp_tls_server::server<T> *tcp_server, void *custom_obj
-#define CUSTOM_READ_CB_PARAMS int client_idx, int fd, std::vector<char> &&buff, tcp_tls_server::server<T> *tcp_server, void *custom_obj
+#define CUSTOM_READ_CB_PARAMS int client_idx, int fd, std::vector<char> &&buff, size_t read_bytes, tcp_tls_server::server<T> *tcp_server, void *custom_obj
 
-#endif
+#endif

src/header/server_metadata.h

@@ -13,6 +13,7 @@
 #include <unistd.h> //read
 #include <fcntl.h> //open
 #include <sys/types.h> //O_RDONLY
+#include <sys/timerfd.h> //for the timerfd
 
 typedef struct stat stat_struct;
 
@@ -21,6 +22,17 @@ namespace utility {
   uint64_t get_file_size(int file_fd); //gets file size of the file descriptor passed in
   void sigint_handler(int sig_number); //handler used in main for handling SIGINT
 
+  void log_helper_function(std::string msg, bool cerr_or_not);
+  
+  std::string replace(std::string s1, std::string s2, std::string pattern);
+  std::string remove_from_slash_string(std::string slash_string, std::string remove_string); // removes ABCD from `123/abc/ABCD/efg`, making `123/abc/efg`
+  
+  void set_timerfd_interval(int timerfd, int ms);
+  
+  uint64_t random_number(uint64_t min, uint64_t max);
+
+  std::string to_web_name(std::string name); // simple function to make the input lower case, and replace spaces with underscores
+
   //removes first n elements from a vector
   template <typename T>
   void remove_first_n_elements(std::vector<T> &data, int num_elements_to_remove){ //deals correctly with overlaps

src/header/utility.h

@@ -1,10 +1,13 @@
 #ifndef CACHE
 #define CACHE
 
+#include <iostream>
 #include <unordered_set>
 #include <unordered_map>
 #include <vector>
 
+#include "../utility.h"
+
 #include <sys/inotify.h>
 
 #include "common_structs_enums.h"
@@ -16,7 +19,7 @@ namespace web_cache {
     int next_item_idx = -1;
     int prev_item_idx = -1;
     bool outdated = false; //if true, then removed from cache
-    int watch{};
+    int watch = -1;
   };
 
   struct cache_fetch_item {
@@ -43,10 +46,13 @@ namespace web_cache {
 
     cache(){ //only works for cache's which are greater than 1 in size
       for(int i = 0; i < cache_buffer.size(); i++)
-        free_idxs.insert(i);
+        free_idxs.insert(free_idxs.end(), i);
     }
 
     cache_fetch_item fetch_item(const std::string &filepath, int client_idx, web_server::tcp_client &client){
+      if(client_idx < 0) // for the off chance that an invalid client ID is supplied
+        return { false, nullptr };
+      
       if(filepath_to_cache_idx.count(filepath)) {
         auto current_idx = filepath_to_cache_idx[filepath];
         auto &item = cache_buffer[current_idx];
@@ -67,7 +73,7 @@ namespace web_cache {
 
             inotify_rm_watch(inotify_fd, item.watch); //remove the watcher for this item
             watch_to_cache_idx.erase(item.watch);
-            free_idxs.insert(current_idx);
+            free_idxs.insert(free_idxs.end(), current_idx);
             item = cache_item();
 
             return { false, nullptr };
@@ -90,7 +96,7 @@ namespace web_cache {
         if(outdated_file){
           inotify_rm_watch(inotify_fd, item.watch); //remove the watcher for this item
           watch_to_cache_idx.erase(item.watch);
-          free_idxs.insert(current_idx);
+          free_idxs.insert(free_idxs.end(), current_idx);
           item = cache_item();
 
           return { false, nullptr };
@@ -108,7 +114,7 @@ namespace web_cache {
       }
     }
 
-    bool try_insert_item(int client_idx, const std::string &filepath, std::vector<char> &&buff){
+    bool try_insert_item(const std::string &filepath, std::vector<char> &&buff){
       int current_idx = -1;
 
       if(free_idxs.size()){ //if free idxs available
@@ -145,9 +151,9 @@ namespace web_cache {
         filepath_to_cache_idx[filepath] = current_idx;
         cache_idx_to_filepath[current_idx] = filepath;
 
-        current_item.watch = inotify_add_watch(inotify_fd, filepath.c_str(), IN_MODIFY);
+        current_item.watch = inotify_add_watch(inotify_fd, filepath.c_str(), IN_MODIFY); // doesn't watch for deleted/created files in the cache, only modified
         watch_to_cache_idx[current_item.watch] = current_idx;
-
+        
         current_item.prev_item_idx = highest_idx; //promote to highest
         current_item.next_item_idx = -1;
         highest_idx = current_idx; //new highest position
@@ -168,6 +174,11 @@ namespace web_cache {
     }
 
     void finished_with_item(int client_idx, web_server::tcp_client &client){ //requires a pointer to the client object, for the using_file stuff - to ensure it's not decremented too many times
+      if(client_idx < 0){ // for the off chance that an invalid client ID is supplied
+        utility::log_helper_function(std::string(__func__) + " ## " + std::to_string(__LINE__) + " ## " + std::string(__FILE__) + " ## Client idx: " + std::to_string(client_idx) + " ## " + std::to_string(client.using_file), true);
+        return;
+      }
+
       if(client.using_file){
         const auto cache_idx = client_idx_to_cache_idx[client_idx];
         cache_buffer[cache_idx].lock_number--;