added CORS

source/utils.cpp

@@ -0,0 +1,192 @@
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include "utils.hpp"
+#include "crow/http_response.h"
+#include <algorithm>
+#include <fstream>
+#include <sstream>
+
+using namespace std;
+
+namespace utils {
+
+map<string, string> parseBody(const string& body)
+{
+    size_t pos = 0;
+    size_t start = 0;
+    map<string, string> data;
+
+    while (true)
+    {
+        pos = body.find('=', start);
+        const string key = body.substr(start, pos - start);
+
+        size_t nextPos = body.find('&', pos + 1);
+        string value = body.substr(pos + 1, nextPos - (pos + 1));
+        data[key] = value;
+
+        if (nextPos == std::string::npos)
+        {
+            break;
+        }
+        start = nextPos + 1;
+    }
+    return data;
+}
+
+optional<string> getBodyName(const string& body) {
+    const auto pos = body.find('=');
+    if (pos == std::string::npos) return {};
+
+    const string key = body.substr(0, pos);
+    string value = body.substr(pos + 1);
+
+    if (key != "name") return {};
+
+    return value;
+}
+
+expected<bool, string> isLocalPortOpen(uint16_t portno) {
+    const char *hostname = "localhost";
+ 
+    int sockfd;
+    bool ret;
+    struct sockaddr_in serv_addr;
+    struct hostent *server;
+ 
+    sockfd = socket(AF_INET, SOCK_STREAM, 0);
+    if (sockfd < 0) {
+        close(sockfd);
+        return unexpected("ERROR opening socket");
+    }
+ 
+    server = gethostbyname(hostname);
+ 
+    if (server == NULL) {
+        close(sockfd);
+        return unexpected("ERROR, no such host");
+    }
+ 
+    bzero((char *) &serv_addr, sizeof(serv_addr));
+    serv_addr.sin_family = AF_INET;
+    bcopy((char *)server->h_addr,
+         (char *)&serv_addr.sin_addr.s_addr,
+         server->h_length);
+ 
+    serv_addr.sin_port = htons(portno);
+    if (connect(sockfd,(struct sockaddr *) &serv_addr,sizeof(serv_addr)) < 0) {
+        ret = false;
+    } else {
+        ret = true;
+    }
+ 
+    close(sockfd);
+    return ret;
+}
+
+string to_id_format(const string& s){
+    string new_s = s;
+
+   // transform(new_s.begin(), new_s.end(), new_s.begin(),
+   // [](unsigned char c){ return std::tolower(c); });
+
+    replace( new_s.begin(), new_s.end(), ' ',  '-'); 
+
+    return new_s;
+}
+
+string loadFile(const string& path) {
+    ifstream f(path);
+    stringstream buffer;
+    buffer << f.rdbuf();
+    return buffer.str();
+}
+
+std::filesystem::path getDataDir(){
+    return std::getenv("XDG_DATA_HOME") 
+    ? std::filesystem::path(std::getenv("XDG_DATA_HOME")) / APPLICATION_NAME 
+    : std::filesystem::path(std::getenv("HOME")) / ".local" / "share" / APPLICATION_NAME;
+}
+
+std::string urlDecode(const std::string& str) {
+    std::ostringstream decoded;
+    for (size_t i = 0; i < str.length(); ++i) {
+        if (str[i] == '%' && i + 2 < str.length()) {
+            std::istringstream hex_stream(str.substr(i + 1, 2));
+            int hex = 0;
+            if (hex_stream >> std::hex >> hex) {
+                decoded << static_cast<char>(hex);
+                i += 2;
+            } else {
+                decoded << '%'; // malformed encoding, keep as-is
+            }
+        } else if (str[i] == '+') {
+            decoded << ' '; // '+' is often used for spaces in form-encoding
+        } else {
+            decoded << str[i];
+        }
+    }
+    return decoded.str();
+}
+
+string currentTime(){
+    auto now = std::chrono::system_clock::now();
+    std::time_t t = std::chrono::system_clock::to_time_t(now);
+    std::stringstream ss;
+    ss << std::put_time(std::gmtime(&t), "%Y-%m-%d %H:%M:%S");
+    return ss.str();
+}
+
+std::string read_file(const std::string& path) {
+    std::ifstream file(path, std::ios::binary);
+    if (!file) {
+        throw std::runtime_error("Cannot open file: " + path);
+    }
+    std::ostringstream ss;
+    ss << file.rdbuf();
+    return ss.str();
+}
+
+// Simple MIME type detection
+std::string get_mime_type(const std::string& path) {
+    if (path.ends_with(".html")) return "text/html";
+    if (path.ends_with(".js")) return "text/javascript";
+    if (path.ends_with(".css")) return "text/css";
+    if (path.ends_with(".json")) return "application/json";
+    if (path.ends_with(".svg")) return "image/svg+xml";
+    if (path.ends_with(".png")) return "image/png";
+    if (path.ends_with(".jpg") || path.ends_with(".jpeg")) return "image/jpeg";
+    if (path.ends_with(".woff")) return "font/woff";
+    if (path.ends_with(".woff2")) return "font/woff2";
+    if (path.ends_with(".pdf")) return "application/pdf";
+    return "application/octet-stream";
+}
+
+crow::response getFile(const filesystem::path& file_path){
+    // If file exists, serve it
+    if (filesystem::exists(file_path)) {
+        auto data = read_file(file_path);
+        auto mime = get_mime_type(file_path.string());
+        return crow::response(200, mime.c_str(), data);
+    }
+
+    // SPA fallback: serve root index.html for unknown routes
+    filesystem::path fallback = build_dir / "index.html";
+    auto data = read_file(fallback);
+    return crow::response(404, "text/html", data);
+}
+
+std::expected<nlohmann::json, std::string> parseJson(const std::string& input) {
+    try {
+        return nlohmann::json::parse(input);
+    }
+    catch (const nlohmann::json::exception& e) {
+        return std::unexpected(e.what());
+    }
+}
+}