Merge remote-tracking branch 'lj/main'

Author: 0WAQ

.gitmodules

@@ -0,0 +1,6 @@
+[submodule "drogon"]
+	path = drogon
+	url = https://github.com/drogonframework/drogon
+[submodule "jwt-cpp"]
+	path = jwt-cpp
+	url = https://github.com/Thalhammer/jwt-cpp

CMakeLists.txt

@@ -24,7 +24,7 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
 
-add_executable(${PROJECT_NAME} main.cc mysql.cc user_controller.cc jwt_controller.cc msg_controller.cc)
+add_executable(${PROJECT_NAME} main.cc mysql.cc user_controller.cc jwt_controller.cc msg_controller.cc file_controller.cc)
 
 
 # 链接MySQL Connector/C++库
@@ -52,7 +52,7 @@ target_link_libraries(${PROJECT_NAME} PRIVATE -L${MYSQL_CONNECTOR_CPP_ROOT}/lib6
 find_package(OpenSSL REQUIRED)
 
 # 添加 OpenSSL 库到可执行文件链接参数
-target_link_libraries(flypen PRIVATE OpenSSL::Crypto)
+target_link_libraries(${PROJECT_NAME} PRIVATE OpenSSL::Crypto)
 
 #link_directories(/home/lgy/c++kc/mysql-connector/lib64)
 #
@@ -95,4 +95,4 @@ target_sources(${PROJECT_NAME}
 
 # ##############################################################################
 
-add_subdirectory(test)
+#add_subdirectory(test)

drogon

@@ -0,0 +1,67 @@
+#include "file_controller.h"
+#include <iostream>
+#include <stdexcept>
+#include <stdio.h>
+#include <string>
+#include <json/json.h>
+
+
+std::string shell_commons(const char* cmd) {
+    char buffer[128];
+    std::string result = "";
+    FILE* pipe = popen(cmd, "r");
+    if (!pipe) throw std::runtime_error("popen() failed!");
+    try {
+        while (fgets(buffer, sizeof buffer, pipe) != NULL) {
+            result += buffer;
+        }
+    } catch (...) {
+        pclose(pipe);
+        throw;
+    }
+    pclose(pipe);
+    return result;
+}
+
+void genTree(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
+{
+    char *pathvar;
+    pathvar = getenv("PWD");
+    std::string result = shell_commons(("cd "+std::string(pathvar)+"/.. " + "&&"+"tree -J root" ).c_str()) ;
+    auto res = HttpResponse::newHttpResponse();
+    res->addHeader("Access-Control-Allow-Origin", "*");
+    res ->setBody(result);  
+    callback(res);
+}
+void catFile(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
+{
+    char *pathvar;
+    pathvar = getenv("PWD");
+    std::string path = req->getParameter("path");
+    std::string result = shell_commons(("cat "+std::string(pathvar)+"/../root/"+path).c_str()) ;
+    auto res = HttpResponse::newHttpResponse();
+    res->addHeader("Access-Control-Allow-Origin", "*");
+    res ->setBody(result);  
+    callback(res);
+}
+void saveFile(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
+{
+    auto body = req->getBody();
+    Json::Value req_json;
+    Json::Reader reader;
+    std::string bodyStr(body);
+    if (!reader.parse(bodyStr, req_json)) {
+        std::cout<<"parse failed"<<std::endl;
+        callback(HttpResponse::newHttpResponse());
+        return;
+    }
+    char *pathvar;
+    pathvar = getenv("PWD");
+    std::string filename = req_json["filename"].asString();
+    std::string content = req_json["content"].asString();
+    std::string result = shell_commons(("echo '"+content+"'>"+std::string(pathvar)+"/../root/"+filename).c_str()) ;
+    auto res = HttpResponse::newHttpResponse();
+    res->addHeader("Access-Control-Allow-Origin", "*");
+    res ->setBody("success");  
+    callback(res);
+}

file_controller.cc

@@ -0,0 +1,11 @@
+#ifndef _FILE_CONTROLLER_H_
+#define _FILE_CONTROLLER_H_
+#include <string>
+#include <drogon/drogon.h>
+using namespace drogon;
+std::string shell_commons(const char* cmd);
+void genTree(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback);
+void catFile(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback);
+void saveFile(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback);
+//std::string 
+#endif

file_controller.h

@@ -1,9 +1,12 @@
-#include "jwt_controller.h"
 #include <iostream>
+#include <drogon/drogon.h>
 #include <jwt-cpp/jwt.h>
 #include <cstring>
 #include <chrono>
+#include "jwt_controller.h"
+
 using namespace jwt;
+
 std::string jwtGen(const Json::Value& req_json)
 {
     auto now = std::chrono::system_clock::now();
@@ -16,11 +19,6 @@ std::string jwtGen(const Json::Value& req_json)
     .sign(jwt::algorithm::hs256{"secret"});
     return std::string(token);
 }
-// std::string jwtDecode(const std::string& token)
-// {
-//     auto decoded_token = jwt::decode(token);
-//     return decoded_token.get_payload_claim("name").as_string();
-// }
 
 std::string jwtDecrypt(const std::string& token)
 {
@@ -35,4 +33,21 @@ std::string jwtDecrypt(const std::string& token)
         std::cout<<"Failed to decrypt JWT: " + std::string(e.what())<<std::endl;
         throw std::runtime_error("Failed to decrypt JWT");
     }
+}
+
+bool jwtVerify(const drogon::HttpRequestPtr &req){
+    std::string authHeader = req->getHeader("Authorization");
+    if (authHeader.substr(0, 7) == "Bearer ") {
+        std::string bearerToken = authHeader.substr(7);
+        try {
+            std::string sender = jwtDecrypt(bearerToken);
+            return true;
+        } catch (const std::exception &e) {
+            std::cout << "Wrong token" << std::endl;
+            return false;
+        }
+    } else {
+        std::cout << "No Authorization" << std::endl;
+        return false;
+    }
 }

jwt-cpp

@@ -1,7 +1,12 @@
 #ifndef _JWT_CONTROLLER_H_
 #define _JWT_CONTROLLER_H_
+
+#include <drogon/drogon.h>
 #include <json/json.h>
 #include <cstring>
+
 std::string jwtGen(const Json::Value& req_json);
 std::string jwtDecrypt(const std::string& token);
+bool jwtVerify(const drogon::HttpRequestPtr &req);
+
 #endif

jwt_controller.cc

@@ -2,6 +2,7 @@
 #include <drogon/drogon.h>
 #include "msg_controller.h"
 #include "user_controller.h"
+#include "file_controller.h"
 #include <drogon/WebSocketController.h>
 using namespace drogon;
 std::unordered_map<std::string, WebSocketConnectionPtr> clientTable;
@@ -29,6 +30,19 @@ int main() {
       drogon::app().registerHandler("/api/info", [](const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback) {
         info(req, std::move(callback));
     });
+
+    drogon::app().registerHandler("/api/file/tree", [](const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback) {
+        genTree(req, std::move(callback));
+    });  
+    drogon::app().registerHandler("/api/file/cat", [](const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback) {
+        catFile(req, std::move(callback));
+    });  
+    drogon::app().registerHandler("/api/file/save", [](const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback) {
+        saveFile(req, std::move(callback));
+    });  
+      drogon::app().registerHandler("/api/avatar", [](const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback) {
+        avatar(req, std::move(callback));
+    });
     drogon::app().run();
     return 0;
 }