modified: .gitignore

deleted:    requirements.txt
    deleted:    run.bat
	deleted:    run.sh
	deleted:    src/__init__.py
	deleted:    src/mainprocess.py

.gitignore

@@ -6,7 +6,7 @@ __pycache__/
 
 # C extensions
 *.so
-
+.vscode/
 # Distribution / packaging
 .Python
 build/

README.md

@@ -1,6 +1,6 @@
 # OneBot Chatbot Framework
 
-该项目是一个基于OneBot标准的聊天机器人后端框架，采用高度可扩展的插件架构设计，支持消息的模块化处理和插件热加载。
+该项目是一个基于OneBot标准的聊天机器人后端框架，采用高度可扩展的插件架构设计，支持消息的模块化处理和插件热加载。如果你有任何意见或建议，可以通过 jianfeee@outlook.com 联系我。
 
 ## 项目特点
 

app.py

@@ -1,97 +0,0 @@
-import logging
-from flask import Flask, request, jsonify
-from logging.handlers import RotatingFileHandler
-from functools import wraps
-from datetime import datetime
-from src import mainprocess as src
-
-
-app = Flask(__name__)
-
-#===rebot===#
-# 处理私聊消息
-# 处理群聊消息
-@app.route('/', methods=["POST"])
-def handle_event():
-    try:
-        event = request.get_json()
-        event_type = event.get('post_type')
-        
-        # 1. 处理私聊消息
-        if event_type == 'message' and event.get('message_type') == 'private':
-            # 注意：私聊消息在顶层有 user_id
-            uid = event.get('user_id')
-            message = event.get('raw_message')
-            src.process_message(uid, None, message)
-            
-        # 2. 处理群消息
-        elif event_type == 'message' and event.get('message_type') == 'group':
-            gid = event.get('group_id')
-            # 注意：群消息发送者在 sender 内
-            sender = event.get('sender', {})
-            uid = sender.get('user_id')
-            message = event.get('raw_message')
-            src.process_message(uid, gid, message)
-
-        # 3. 处理通知事件（如输入状态）
-        elif event_type == 'notice':
-            notice_type = event.get('notice_type')
-            
-            if notice_type == 'notify' and event.get('sub_type') == 'input_status':
-                # 仅记录，不处理
-                logging.info(f"用户 {event.get('user_id')} 输入状态变化")
-                
-            elif notice_type == 'group_recall':
-                # 示例：处理群消息撤回
-                logging.info(f"群 {event.get('group_id')} 撤回消息")
-                
-            else:
-                # 其他通知类型
-                logging.info(f"Ignored notice: {event}")
-            
-            # 通知事件直接返回成功
-            return jsonify({
-                "status": "ok",
-                "retcode": 0,
-                "data": None
-            })
-            
-        # 4. 处理元事件（如心跳）
-        elif event_type == 'meta_event':
-            # 心跳等元事件直接返回成功
-            return jsonify({
-                "status": "ok",
-                "retcode": 0,
-                "data": None
-            })
-        
-        # 5. 一切正常的消息事件返回成功
-        return jsonify({
-            "status": "ok",
-            "retcode": 0,
-            "data": "Processed successfully"
-        })
-    
-    except KeyError:
-        logging.warning(f"Missing required field in event: {event}")
-        return jsonify({
-            "status": "failed",
-            "retcode": 10001,
-            "message": "Missing required field"
-        }), 400
-        
-    except Exception as e:
-        logging.exception(f"Error processing event: {str(e)}")
-        return jsonify({
-            "status": "failed",
-            "retcode": 20001,
-            "message": "Internal server error"
-        }), 500
-
-
-if __name__ == '__main__':
-    try:
-        port = 25580
-        app.run(debug=True, host='0.0.0.0', port=port)
-    except Exception as e:
-        print(f"启动失败: {e}")

c/CMakeLists.txt

@@ -0,0 +1,23 @@
+cmake_minimum_required(VERSION 3.28.3)
+
+project (Onebot_back C)
+if(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang")
+    add_compile_options(-O0 -g -fno-omit-frame-pointer)
+    add_link_options(-O0)
+endif()
+if(MSVC)
+    add_compile_options(/Od /Zi)
+endif()
+
+add_executable(Start_Onebot_back main.c tem/ctl.c)
+add_executable(Run_pluginmanager run_pluginmanager/run_pluginmanager.c)
+add_library(Network SHARED network/network.c network/swap.c network/cJSON.c network/http/http_rel.c network/erroprocess/erroprocess.c)
+add_library(Swmem SHARED network/swap.c)
+add_library(Interpre SHARED interpreter/interpreter.c tools/pkgmanager/pkginstall.c)
+add_library(Log SHARED tools/log/log.c) 
+add_library(Toml SHARED tools/toml/toml.c)
+add_library(Quit SHARED tools/quit/quit.c)
+
+target_link_libraries(Start_Onebot_back Network Swmem Interpre Log Toml Quit)
+
+include_directories(${PROJECT_SOURCE_DIR})

c/config.h

@@ -0,0 +1,18 @@
+#ifndef SEVERCONFG
+#define SEVERCONFG
+
+#define MAX_LOG 64
+#define MAX_LOG_LENGTH 4096
+
+#define TEM_MAX_BUF 256
+#define TEM_HISTORY_BUF 210
+#define TEM_PROMPT "chatbot$$ "
+
+#define NET_MAX_POOL 1
+#define NET_MAX_MESSAGE_BUF 1024
+#define HTTP_BLOCK_SIZE 512
+#define MAX_HTTP_LENGTH 20
+
+#define INTER_MAX_BUF 256
+
+#endif

c/interpreter/interpreter.c

@@ -0,0 +1,223 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stddef.h>
+#include <string.h>
+#include <termios.h>
+#include <stddef.h>
+#include "interpreter.h"
+#include "tools/pkgmanager/pkginstall.h"
+
+int inter_in_log(const char *log,log_manager *manager)
+{
+    if(strlen(log)>1024)
+        return -1;
+    logs* logss = (logs*)malloc(sizeof(logs));
+    memcpy(logss->log,log,strlen(log));
+    manager->in_log(logss,manager);
+    return 0;
+}
+
+int init_interpreter(Cmd *cmd_dic,ctx *self,int fifo[2],log_manager *log_manager)
+{
+    printf("SYS:prepare env\n");
+    inter_in_log("SYS:prepare env\n",log_manager);
+    printf("SYS:env ready\n");
+    inter_in_log("SYS:env ready\n",log_manager);
+    printf("SYS:loading cmd_dic\n");
+    inter_in_log("SYS:loading cmd_dic\n",log_manager);
+    sprintf(cmd_dic[0].name, "pkginstall");
+    cmd_dic[0].cmd = INSTALL;
+
+    sprintf(cmd_dic[1].name,"run");
+    cmd_dic[1].cmd = RUN;
+
+    sprintf(cmd_dic[2].name,"quit");
+    cmd_dic[2].cmd = QUIT;
+
+    printf("SYS:cmd_dir load complite\n");
+    inter_in_log("SYS:cmd_dir load complite\n",log_manager);
+
+    for(int i =0;i<10;i++)
+    {
+        self->space_index[i] = 0;
+    }
+    self->arg = NULL;
+    printf("SYS:Creating ctl fifo\n");
+    inter_in_log("SYS:Creating ctl fifo\n",log_manager);
+    memcpy(self->fifofd,fifo,2*sizeof(int));
+    self->log_manager = log_manager;
+}
+
+int get_args(ctx *self)
+{
+    int i;
+    if(self->space_index[0]==0)
+        return 0;
+    self->arg = (args*)malloc(sizeof(args));
+    args* arg = self->arg;
+    size_t len = 0;
+    //抽取参数
+    for(i =0;i<9;i++)
+    {
+        if(self->space_index[i+1]==0)
+            break;
+        len = self->space_index[i+1]-self->space_index[i]-1;
+        memcpy(arg->name,&self->command[self->space_index[i]+1],len);
+        arg->name[len] = '\0';
+        //拷贝变量到变量链
+        if(self->space_index[i+2]!=0){
+            arg->next = (args*)malloc(sizeof(args));
+            if(arg->next == NULL){
+                perror("ERROR:fail to get mem");
+                inter_in_log("ERROR:fail to get mem\n",self->log_manager);
+                return -1;
+            }
+            arg = arg->next;
+        }
+        //访问下一个节点
+    }
+
+
+    if(i<9)
+    {
+        len = self->line-self->space_index[i]-2;
+        memcpy(arg->name,&self->command[self->space_index[i]+1],len);
+        arg->name[len] = '\0';
+    }
+    arg->next = NULL;
+    return i;
+}
+
+int args_free(ctx *self)
+{
+    //释放节点使用的空间
+    if(self->arg == NULL)
+        return 1;
+    args *arg = self->arg;
+    args *buf = arg;
+    while(buf!= NULL&&arg->next!=NULL)
+    {
+        buf = arg;
+        arg = arg->next;
+        free(buf);
+    }
+    return 1;
+}
+
+//分割命令
+int split(const char *input,ctx *all_ctx)
+{
+    int sp_index = 0;
+    char buf = input[0];
+    int index = 0;
+    while(buf != '\n')
+    {
+        if(buf == ' '){
+            //记录空格位置
+            all_ctx->space_index[sp_index] = index;
+            sp_index++;
+        }
+        index++;
+        buf = input[index];
+    }
+}
+
+//匹配命令
+int match_cmd(const Cmd* cmd_dic,char *cmd_buf)
+{   
+    int cmd_index = 0;
+    
+    while(cmd_index <CMD_DIR_LENGTH)
+    {
+        if(strcmp(cmd_dic[cmd_index].name,cmd_buf)==0)
+            return cmd_dic[cmd_index].cmd;
+        cmd_index++;
+    }
+    return BAD_INPUT;
+}
+
+
+int exec(const int command,ctx *all_ctx)
+{
+
+    switch (command)
+    {
+    case BAD_INPUT:
+        printf("SYS:bad input,try again\n");
+        inter_in_log("SYS:bad input,try again\n",all_ctx->log_manager);
+        return BAD_INPUT;
+
+    case INSTALL:
+        if(all_ctx->arg == NULL){
+            printf("SYS:Missing args\n");
+            inter_in_log("SYS:Missng args\n",all_ctx->log_manager);
+            return 1;
+        }
+        printf("SYS:init pkgmanager\n");
+        inter_in_log("SYS:init pkgmanager\n",all_ctx->log_manager);
+        pkger *manager = init_pkginstaller();
+        printf("SYS:installing\n");
+        inter_in_log("SYS:installing\n",all_ctx->log_manager);
+        manager->packup(manager);
+        return 1;
+
+    case RUN:
+        printf("SYS:runing\n");
+        inter_in_log("SYS:running\n",all_ctx->log_manager);
+        return 1;
+        
+    case QUIT:
+        printf("SYS:shuting down\n");
+        inter_in_log("SYS:shuting down\n",all_ctx->log_manager);
+        all_ctx->statue = -1;
+        write(all_ctx->fifofd[1],"q",1);
+        return 1;
+    default :
+        return -1;
+    }
+
+}
+
+int interpret(int mod, ctx *all_ctx,Cmd *cmd_dic)
+{
+    if (mod == SIG_MOD)
+    {
+        // 检查空格位置
+
+        split(all_ctx->command,all_ctx);
+        get_args(all_ctx);
+        char *cmd_buf = malloc(INTER_MAX_BUF);
+        int len;
+        if(all_ctx->space_index[0]==0)
+        {
+            len = all_ctx->line;
+        }
+        else
+        {
+            len = all_ctx->space_index[0];
+        }
+        memcpy(cmd_buf,all_ctx->command,len);
+        if(cmd_buf[len-1] == '\n')
+            cmd_buf[len-1] = '\0';
+        //执行命令
+        exec(match_cmd(cmd_dic, cmd_buf),all_ctx);
+
+        //释放所有堆内存
+        free(cmd_buf);
+        args_free(all_ctx);
+        all_ctx->arg = NULL;
+        for(int i =0;i<10;i++)
+        {
+            all_ctx->space_index[i] = 0;
+        }
+    }
+
+    if (mod == FILE_MOD)
+    {
+        //todo 读取命令脚本并执行
+        return -1;
+    }
+    return -1;
+}

c/interpreter/interpreter.h

@@ -0,0 +1,52 @@
+#ifndef INTERPRETER
+#define INTERPRETER
+
+#include "config.h"
+
+#define SIG_MOD 0
+#define FILE_MOD 1
+
+#include "tools/log/log.h"
+
+typedef struct
+{
+    char name[256];
+    int cmd;
+}Cmd;//配置关键词节点
+
+#define CMD_DIR_LENGTH 3
+
+//command 定义
+#define  INSTALL 0
+#define RUN 1
+#define QUIT 2
+#define BAD_INPUT -1
+
+typedef struct args
+{
+    void *loc;
+    int type;
+    char name[256];
+    struct args* next;
+}args;//参数链表
+
+typedef struct ctx
+{
+    int index;//当前位置
+    int space_index[10];//当前行空格位置
+    int line;//当前行长度
+    int word;//当前解释词位置
+    args *arg;//当前环境下参数链表
+    char command[INTER_MAX_BUF];//当前行缓存
+    int statue;//当前状态
+    int fifofd[2];
+    log_manager *log_manager;
+}ctx;//上下文管理
+
+
+int interpret(int mod, ctx *all_ctx,Cmd *cmd_dic);
+int init_interpreter(Cmd *cmd_dic,ctx *self,int fifo[2],log_manager *log_manager);
+
+#define ARG_LENGTH 256
+
+#endif

c/main.c

@@ -0,0 +1,72 @@
+#define _GNU_SOURCE
+#include "tem/ctl.h"
+#include "network/network.h"
+#include "tools/toml/toml.h"
+#include "tools/quit/quit.h"
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int get_config(toml_table_t **server,char *path)
+{
+    FILE* fp;
+    char errbuf[200];
+    //打开配置文件，加载到缓存
+    fp = fopen(path,"r");
+    if(!fp)
+    {
+        perror("cannot parse\n");
+        return 0;
+    }
+    toml_table_t *tem = toml_parse_file(fp,errbuf,sizeof(errbuf));
+    tem = toml_table_in(tem,"app");
+    *server = tem;
+    fclose(fp);
+    return 1;
+}
+
+
+int main()
+{
+    toml_table_t* server;
+    if(!get_config(&server,"config/config.toml"))
+        perror("load config error");
+    int port = (int)toml_int_in(server,"list_port").u.i;
+    //加载配置文件，读取端口
+    log_manager *logsmanager=(log_manager*)malloc(sizeof(log_manager));
+    //创建日志管理器与定时清理线层
+    init_loger(logsmanager);
+    pthread_create(&logsmanager->pid,NULL,logsmanager->clear_log,logsmanager);
+    Ctl *teml = init_tem(logsmanager);
+    teml->config = server;
+    //初始化终端对象
+    int fifo[2];
+    if(pipe(fifo)==-1)
+        perror("ERROR ");
+    netm *networkmanager = (netm*)malloc(sizeof(netm));
+    init_networkmanager(networkmanager,fifo,logsmanager,port);
+    //初始化网络管理器对象
+
+    pthread_create(&networkmanager->pid,NULL,networkmanager->run_network,(void*)networkmanager);
+    //启动网络监听与线程池，并加载插件
+    alres *resource = (alres*)malloc(sizeof(alres));
+    resource->loger = logsmanager;
+    resource->network = networkmanager;
+    resource->tem = teml;
+    on_exit(quit_all,resource);
+    //注册清理函数
+    teml->run(teml,fifo);
+    
+    //启动终端
+
+    
+    //等待网络管理器进程结束
+    pthread_join(networkmanager->pid,NULL);
+    networkmanager->pid = -1;
+    close(fifo[1]);
+    log_manager_stop(logsmanager);
+    pthread_join(logsmanager->pid,NULL);
+    logsmanager->pid = -1;
+    return 1;
+
+}

c/network/cJSON.h

@@ -0,0 +1,306 @@
+/*
+  Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#ifndef cJSON__h
+#define cJSON__h
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32))
+#define __WINDOWS__
+#endif
+
+#ifdef __WINDOWS__
+
+/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention.  For windows you have 3 define options:
+
+CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols
+CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default)
+CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol
+
+For *nix builds that support visibility attribute, you can define similar behavior by
+
+setting default visibility to hidden by adding
+-fvisibility=hidden (for gcc)
+or
+-xldscope=hidden (for sun cc)
+to CFLAGS
+
+then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does
+
+*/
+
+#define CJSON_CDECL __cdecl
+#define CJSON_STDCALL __stdcall
+
+/* export symbols by default, this is necessary for copy pasting the C and header file */
+#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_EXPORT_SYMBOLS
+#endif
+
+#if defined(CJSON_HIDE_SYMBOLS)
+#define CJSON_PUBLIC(type)   type CJSON_STDCALL
+#elif defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_PUBLIC(type)   __declspec(dllexport) type CJSON_STDCALL
+#elif defined(CJSON_IMPORT_SYMBOLS)
+#define CJSON_PUBLIC(type)   __declspec(dllimport) type CJSON_STDCALL
+#endif
+#else /* !__WINDOWS__ */
+#define CJSON_CDECL
+#define CJSON_STDCALL
+
+#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY)
+#define CJSON_PUBLIC(type)   __attribute__((visibility("default"))) type
+#else
+#define CJSON_PUBLIC(type) type
+#endif
+#endif
+
+/* project version */
+#define CJSON_VERSION_MAJOR 1
+#define CJSON_VERSION_MINOR 7
+#define CJSON_VERSION_PATCH 19
+
+#include <stddef.h>
+
+/* cJSON Types: */
+#define cJSON_Invalid (0)
+#define cJSON_False  (1 << 0)
+#define cJSON_True   (1 << 1)
+#define cJSON_NULL   (1 << 2)
+#define cJSON_Number (1 << 3)
+#define cJSON_String (1 << 4)
+#define cJSON_Array  (1 << 5)
+#define cJSON_Object (1 << 6)
+#define cJSON_Raw    (1 << 7) /* raw json */
+
+#define cJSON_IsReference 256
+#define cJSON_StringIsConst 512
+
+/* The cJSON structure: */
+typedef struct cJSON
+{
+    /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
+    struct cJSON *next;
+    struct cJSON *prev;
+    /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
+    struct cJSON *child;
+
+    /* The type of the item, as above. */
+    int type;
+
+    /* The item's string, if type==cJSON_String  and type == cJSON_Raw */
+    char *valuestring;
+    /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */
+    int valueint;
+    /* The item's number, if type==cJSON_Number */
+    double valuedouble;
+
+    /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
+    char *string;
+} cJSON;
+
+typedef struct cJSON_Hooks
+{
+      /* malloc/free are CDECL on Windows regardless of the default calling convention of the compiler, so ensure the hooks allow passing those functions directly. */
+      void *(CJSON_CDECL *malloc_fn)(size_t sz);
+      void (CJSON_CDECL *free_fn)(void *ptr);
+} cJSON_Hooks;
+
+typedef int cJSON_bool;
+
+/* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them.
+ * This is to prevent stack overflows. */
+#ifndef CJSON_NESTING_LIMIT
+#define CJSON_NESTING_LIMIT 1000
+#endif
+
+/* Limits the length of circular references can be before cJSON rejects to parse them.
+ * This is to prevent stack overflows. */
+#ifndef CJSON_CIRCULAR_LIMIT
+#define CJSON_CIRCULAR_LIMIT 10000
+#endif
+
+/* returns the version of cJSON as a string */
+CJSON_PUBLIC(const char*) cJSON_Version(void);
+
+/* Supply malloc, realloc and free functions to cJSON */
+CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks);
+
+/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */
+/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */
+CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value);
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length);
+/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */
+/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated);
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated);
+
+/* Render a cJSON entity to text for transfer/storage. */
+CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item);
+/* Render a cJSON entity to text for transfer/storage without any formatting. */
+CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item);
+/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */
+CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt);
+/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */
+/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */
+CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format);
+/* Delete a cJSON entity and all subentities. */
+CJSON_PUBLIC(void) cJSON_Delete(cJSON *item);
+
+/* Returns the number of items in an array (or object). */
+CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array);
+/* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */
+CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index);
+/* Get item "string" from object. Case insensitive. */
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string);
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string);
+CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string);
+/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */
+CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void);
+
+/* Check item type and return its value */
+CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item);
+CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item);
+
+/* These functions check the type of an item */
+CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item);
+
+/* These calls create a cJSON item of the appropriate type. */
+CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean);
+CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num);
+CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string);
+/* raw json */
+CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw);
+CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void);
+
+/* Create a string where valuestring references a string so
+ * it will not be freed by cJSON_Delete */
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string);
+/* Create an object/array that only references it's elements so
+ * they will not be freed by cJSON_Delete */
+CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child);
+CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child);
+
+/* These utilities create an Array of count items.
+ * The parameter count cannot be greater than the number of elements in the number array, otherwise array access will be out of bounds.*/
+CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count);
+
+/* Append item to the specified array/object. */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item);
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item);
+/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object.
+ * WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before
+ * writing to `item->string` */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item);
+/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item);
+
+/* Remove/Detach items from Arrays/Objects. */
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string);
+
+/* Update array items. */
+CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object,const char *string,cJSON *newitem);
+
+/* Duplicate a cJSON item */
+CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse);
+/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will
+ * need to be released. With recurse!=0, it will duplicate any children connected to the item.
+ * The item->next and ->prev pointers are always zero on return from Duplicate. */
+/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal.
+ * case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */
+CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive);
+
+/* Minify a strings, remove blank characters(such as ' ', '\t', '\r', '\n') from strings.
+ * The input pointer json cannot point to a read-only address area, such as a string constant, 
+ * but should point to a readable and writable address area. */
+CJSON_PUBLIC(void) cJSON_Minify(char *json);
+
+/* Helper functions for creating and adding items to an object at the same time.
+ * They return the added item or NULL on failure. */
+CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean);
+CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number);
+CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string);
+CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw);
+CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name);
+
+/* When assigning an integer value, it needs to be propagated to valuedouble too. */
+#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))
+/* helper for the cJSON_SetNumberValue macro */
+CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number);
+#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))
+/* Change the valuestring of a cJSON_String object, only takes effect when type of object is cJSON_String */
+CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring);
+
+/* If the object is not a boolean type this does nothing and returns cJSON_Invalid else it returns the new type*/
+#define cJSON_SetBoolValue(object, boolValue) ( \
+    (object != NULL && ((object)->type & (cJSON_False|cJSON_True))) ? \
+    (object)->type=((object)->type &(~(cJSON_False|cJSON_True)))|((boolValue)?cJSON_True:cJSON_False) : \
+    cJSON_Invalid\
+)
+
+/* Macro for iterating over an array or object */
+#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)
+
+/* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */
+CJSON_PUBLIC(void *) cJSON_malloc(size_t size);
+CJSON_PUBLIC(void) cJSON_free(void *object);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

c/network/erroprocess/erroprocess.c

@@ -0,0 +1,17 @@
+#include "erroprocess.h"
+#include <stdio.h>
+#include <stddef.h>
+
+int give_upjobs(indiector *self)
+{
+    if(self == NULL)
+    {
+        return -1;
+    }
+    return 1;
+}
+
+int init_indector(indiector *self)
+{
+    
+}

c/network/erroprocess/erroprocess.h

@@ -0,0 +1,24 @@
+#ifndef ERROPROCESS
+#define ERROPROCESS
+
+
+#define BASE_INDIECTOR 2
+#define MAX_index 5
+#define CIR_TIME 20
+typedef struct jobs
+{
+    struct jobs* next;
+    int job;
+}jobs;
+
+
+typedef struct indiector
+{
+    int status;//熔断标志位
+    int retreat_index;//退避指数
+    jobs *head_job;
+    jobs *rear_job;
+    int (*give_upjobs)(struct indiector *);
+}indiector;
+
+#endif

c/network/http/http_rel.c

@@ -0,0 +1,163 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#include "errno.h"
+#include "tools/log/log.h"
+#include "http_rel.h"
+#include <netinet/in.h>
+
+int write_in_bk(char input,httpbuf* blk){
+    if(blk->size%HTTP_BLOCK_SIZE == 0)//块满分配新块
+    {
+        void *tes = realloc(blk->buf,blk->size+HTTP_BLOCK_SIZE);
+        if(tes = NULL){//无法分配内存，清理并返回NULL
+            free(blk->buf);
+            perror("http rec error");
+            return -1;
+       }
+        blk->buf = tes;
+    }
+    blk->buf[blk->size] = input;
+    blk->size++;
+    return 0;
+}
+char *recv_http_request(int cfd){
+    httpbuf buf;
+    buf.buf = NULL;
+    // cppcheck-suppress missingReturn
+    buf.buf = (char*)malloc(HTTP_BLOCK_SIZE);
+    char input;
+    for(;;)
+    {
+        read(cfd,&input,1);
+        switch(input){//截取头部
+            case '\n':
+                if(buf.buf[buf.size-1] == '\r'&&buf.buf[buf.size-2] =='\n'&&buf.buf[buf.size-3] == '\r')
+                {
+                    buf.size-3;
+                    buf.buf = (char*)realloc(buf.buf,buf.size);//截取头部
+                    goto HEAD_RCV;//跳转到头部解析
+                }
+                else
+                {
+                    if(write_in_bk(input,&buf)==-1)
+                        abort();
+                    break;
+                }
+            default:
+                if(write_in_bk(input,&buf)==-1)
+                    abort();//缓存头部
+                break;
+        }
+    }
+    HEAD_RCV:
+    //获取http体长度
+    char length[MAX_HTTP_LENGTH] = {' '};
+    int index = buf.size-1;
+    int tobewrite = MAX_HTTP_LENGTH-1;
+    while(buf.buf[index]!=' ')
+    {
+        length[tobewrite] = buf.buf[index];
+        index--;tobewrite--;
+    }
+    int bodylength = atoi(length);
+    free(buf.buf);//释放头部
+    buf.buf = malloc(bodylength);
+    read(cfd,buf.buf,bodylength);
+    return buf.buf;
+}
+
+
+/**
+ * @brief 初始化HTTP监听socket，所有错误通过logmanager记录
+ * @param port 监听端口
+ * @param logger 日志管理器实例指针
+ * @return 成功返回监听fd，失败返回-1并记录日志
+ */
+int init_http_network(int port, log_manager *logger)
+{
+    logs *log;
+    int fd;
+
+    /* 1. 创建socket */
+    fd = socket(AF_INET, SOCK_STREAM, 0);
+    if (fd == -1) {
+        log = malloc(sizeof(logs));
+        // cppcheck-suppress uninitdata
+        snprintf(log->log, sizeof(log->log), 
+                 "[FATAL] socket() failed: %s", strerror(errno));
+        logger->in_log(log, logger);
+        return -1;
+    }
+
+    /* 2. 设置SO_REUSEADDR，避免TIME_WAIT状态导致bind失败 */
+    int opt = 1;
+    if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) == -1) {
+        log = malloc(sizeof(logs));
+        snprintf(log->log, sizeof(log->log), 
+                 "[ERROR] setsockopt(SO_REUSEADDR) on fd=%d failed: %s", 
+                 fd, strerror(errno));
+        logger->in_log(log, logger);
+        close(fd);
+        return -1;
+    }
+
+    /* 3. 设置为非阻塞模式（配合epoll使用） */
+    int flags = fcntl(fd, F_GETFL, 0);
+    if (flags == -1) {
+        log = malloc(sizeof(logs));
+        snprintf(log->log, sizeof(log->log), 
+                 "[ERROR] fcntl(F_GETFL) on fd=%d failed: %s", fd, strerror(errno));
+        logger->in_log(log, logger);
+
+        close(fd);
+        return -1;
+    }
+    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
+        log = malloc(sizeof(logs));
+        snprintf(log->log, sizeof(log->log), 
+                 "[ERROR] fcntl(O_NONBLOCK) on fd=%d failed: %s", fd, strerror(errno));
+        logger->in_log(log, logger);
+        close(fd);
+        return -1;
+    }
+
+    /* 4. 绑定到指定端口 */
+    struct sockaddr_in addr = {0};
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(port);
+    addr.sin_addr.s_addr = htonl(INADDR_ANY);  // 监听所有网卡
+    
+    if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
+        log = malloc(sizeof(logs));
+        snprintf(log->log, sizeof(log->log), 
+                 "[FATAL] bind(port %d) failed: %s (fd=%d)", 
+                 port, strerror(errno), fd);
+        logger->in_log(log, logger);
+        close(fd);
+        return -1;
+    }
+
+    /* 5. 开始监听 */
+    if (listen(fd, 10) == -1) {
+        log = malloc(sizeof(logs));
+        snprintf(log->log, sizeof(log->log), 
+                 "[FATAL] listen(fd=%d, backlog=10) failed: %s", 
+                 fd, strerror(errno));
+        logger->in_log(log, logger);
+        close(fd);
+        return -1;
+    }
+
+    /* 6. 成功日志 */
+    log = malloc(sizeof(logs));
+    snprintf(log->log, sizeof(log->log), 
+             "[HTTP] Successfully listening on port %d (fd=%d)", port, fd);
+    logger->in_log(log, logger);
+    return fd;
+}

c/network/http/http_rel.h

@@ -0,0 +1,14 @@
+#ifndef HTTP_REL
+#define HTTP_REL
+
+#include "config.h"
+
+typedef struct  httpbuf{
+    char *buf;
+    int size;
+}httpbuf;//http分块结构体
+
+char *recv_http_request(int cfd);
+int init_http_network(int port, log_manager *logger);
+
+#endif

c/network/network.c

@@ -0,0 +1,332 @@
+#define _GNU_SOURCE 
+
+#include "network.h"
+#include "swap.h"
+#include "http/http_rel.h"
+#include "cJSON.h"
+#include "tools/log/log.h"
+#include "tools/quit/quit.h"
+#include "erroprocess/erroprocess.h"
+
+#include <semaphore.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stddef.h>
+#include <errno.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/epoll.h>
+#include <sys/mman.h>
+
+static void safe_strcpy(char *dst, size_t dst_size, const char *src)
+{
+    if (!src) { dst[0] = '\0'; return; }
+    size_t len = strlen(src);
+    if (len >= dst_size) len = dst_size - 1;
+    memcpy(dst, src, len);
+    dst[len] = '\0';
+}
+
+/* 主解析 */
+int rbt_parse_json(const char *json_text, rbt_msg *out)
+{
+    memset(out, 0, sizeof(*out));          // 统一清 0，gid 天然 '\0'
+
+    cJSON *root = cJSON_Parse(json_text);
+    if (!root) return -1;
+
+    /* 1. 取群号（可能没有） */
+    cJSON *gid = cJSON_GetObjectItemCaseSensitive(root, "group_id");
+    if (cJSON_IsString(gid))
+        safe_strcpy(out->gid, sizeof(out->gid), gid->valuestring);
+    else if (cJSON_IsNumber(gid))          // 有些框架是数字
+        snprintf(out->gid, sizeof(out->gid), "%d", gid->valueint);
+
+    /* 2. 用户号 */
+    cJSON *uid = cJSON_GetObjectItemCaseSensitive(root, "user_id");
+    if (cJSON_IsString(uid))
+        safe_strcpy(out->uid, sizeof(out->uid), uid->valuestring);
+    else if (cJSON_IsNumber(uid))
+        snprintf(out->uid, sizeof(out->uid), "%d", uid->valueint);
+
+    /* 3. 昵称在 sender 对象里 */
+    cJSON *sender = cJSON_GetObjectItemCaseSensitive(root, "sender");
+    if (cJSON_IsObject(sender)) {
+        cJSON *nick = cJSON_GetObjectItemCaseSensitive(sender, "nickname");
+        safe_strcpy(out->nickname, sizeof(out->nickname),
+                    cJSON_IsString(nick) ? nick->valuestring : NULL);
+    }
+
+    /* 4. 原始消息 */
+    cJSON *raw = cJSON_GetObjectItemCaseSensitive(root, "raw_message");
+    safe_strcpy(out->raw_message, sizeof(out->raw_message),
+                cJSON_IsString(raw) ? raw->valuestring : NULL);
+
+    /* 5. 消息类型 */
+    cJSON *type = cJSON_GetObjectItemCaseSensitive(root, "message_type");
+    if (cJSON_IsString(type)) {
+        if (strcmp(type->valuestring, "group") == 0)
+            out->message_type = 'g';
+        else if (strcmp(type->valuestring, "private") == 0)
+            out->message_type = 'p';
+        /* else 保持 0 */
+    }
+    cJSON_Delete(root);
+    return 0;   // 成功
+}
+
+
+ssize_t read_req(int fd, void *buf)
+{
+    // TODO 修改读取任务函数
+    ssize_t n = read(fd, buf, NET_MAX_MESSAGE_BUF);
+    if (n == 0)              /* 写端已关闭，管道永不会再有数据 */
+        return 0;
+    return (n > 0) ? n : -1;
+}
+
+int process_message(char *req, log_manager *logger,rbt_msg *swap) {
+    if(req == NULL) return 0;
+    
+    int fd;
+    char type[16], end[16];
+    if(sscanf(req, "%15s/%d/%15s", type, &fd, end) != 3) {
+        free(req);
+        return -1;
+    }
+    
+    const char *body = recv_http_request(fd);
+    
+    if(rbt_parse_json(body,swap) == 0) {
+        logs *log = malloc(sizeof(logs));
+        // cppcheck-suppress uninitdata
+        snprintf(log->log, sizeof(log->log), "%s message %s processed ok\n", 
+                 swap->nickname,swap->raw_message);
+        make_swap(swap);
+        logger->in_log(log, logger);
+    }
+    
+    const char *response = 
+        "HTTP/1.1 200 OK\r\n"
+        "Content-Type: text/plain\r\n"
+        "Content-Length: 2\r\n"
+        "\r\n"
+        "OK";
+    write(fd, response, strlen(response));
+    
+    close(fd);
+    free(req);
+    return 0;
+}
+
+int iss_work(netm *self,char *command)
+{
+    int i = self->last_alc;
+    //查询空闲线程
+    while(atomic_load(&(self->pool[i].status)) ==0)
+    {
+        if(i<NET_MAX_POOL)
+            i++;
+        else{
+            i=0;
+        }
+    }
+    //向空闲线程发送数据
+    write(self->pool[i].fifo_fd[0],command,strlen(command));
+    //设置线程程为working
+    atomic_fetch_sub(&self->pool[i].status,1);
+    self->last_alc = i;
+}
+
+void *pth_module(void *args_p)
+{
+    net_args *argms = (net_args*)args_p;
+    pth_m *pmd = argms->pth;
+    log_manager *logger = argms->log;
+    //参数解析
+    free(args_p);
+    char name[256] = {'\0'};
+    sprintf(name,"chatrebot%lu",pthread_self());
+    int swapfd = create_swap(name);
+    //创建共享内存
+    char swap_arg[64] = {'\0'};
+    sprintf(swap_arg,"%d",swapfd);
+    pid_t id = fork();
+    if(id == 0)
+    {
+        char *args[]={
+            "Pluginmanager",
+            "--swap",swap_arg,
+        NULL};
+        execv("Run_pluhginmanager",args);
+    }
+    logs *pth_log = (logs*)malloc(sizeof(logs));
+    // cppcheck-suppress uninitdata
+    sprintf(pth_log->log,"PID:%lu launched python plugines\n",pthread_self());
+    
+    logger->in_log(pth_log,logger);
+    rbt_msg *swap = (rbt_msg*)mmap(NULL, sizeof(rbt_msg), PROT_READ|PROT_WRITE, MAP_SHARED,swapfd, 0);
+    //拉起python插件管理器
+    for(;;){
+        //线程池中，单个线程模型
+
+        char *req = (char*)malloc(NET_MAX_MESSAGE_BUF);
+        //从管道中读取请求，并解析，无内容时休眠
+        int n = read_req(pmd->fifo_fd[0],(void*)req);
+        //管道关闭时退出;
+
+        if (n == EOF) {
+            return NULL;
+            break;
+        }
+        else{
+            pth_log = (logs*)malloc(sizeof(logs));
+            sprintf(pth_log->log,"processd message");
+            logger->in_log(pth_log,logger);
+            process_message(req,logger,swap);
+            atomic_fetch_add(&pmd->status, 1);
+        }
+    }
+}
+
+int start_pool(netm  *self)
+{
+    for(int i = 0;i<NET_MAX_POOL;i++)
+    {
+        //为线程开辟管道
+        pipe(self->pool[i].fifo_fd);
+        //启动线程
+        net_args *arg = (net_args*)malloc(sizeof(net_args));
+        arg->pth = &self->pool[i];
+        arg->log = self->logmanager;
+        
+        self->pool[i].status = 1;
+        pthread_create(&self->pool[i].pthread_id,NULL,pth_module,(void*)arg);
+    }
+}
+
+int shutdown_pool(netm *self)
+{
+    for(int i = 0;i<NET_MAX_POOL;i++)
+    {
+        if(self->pool[i].status == -1)
+            continue;
+        self->pool[i].status = -1;
+        close(self->pool[i].fifo_fd[1]);
+    }
+    self->statue = ALL_STOP;
+    return 1;
+}
+
+int server_run(int port,int fifo_fd,netm *self)
+{
+    int epfd = epoll_create1(EPOLL_CLOEXEC);
+    if (epfd == -1) {
+        perror("epoll_create1");
+        exit(EXIT_FAILURE);
+    }
+    struct epoll_event ev;
+    //设置epoll同时监听控制管道与http请求
+    ev.events = EPOLLIN;
+    ev.data.fd = fifo_fd;
+    epoll_ctl(epfd, EPOLL_CTL_ADD, fifo_fd, &ev);
+    char iss_buf[256];
+    self->http_fd = init_http_network(port,self->logmanager);
+
+    ev.data.fd = self->http_fd;
+    epoll_ctl(epfd, EPOLL_CTL_ADD, self->http_fd, &ev);
+    struct epoll_event events[10];
+    self->epoll_fd = epfd;
+    self->statue = SERVER_ON;
+    for(;;)
+    {
+        /*工作循环-----------------------------*/
+        int nf = epoll_wait(epfd,events,10,-1);
+        if (nf == -1) { 
+                perror("epoll_wait"); 
+                break; 
+        }
+        for(int i = 0; i<nf;i++){
+
+            if(events[i].data.fd ==self->http_fd)
+            {
+                int nt_fd = accept4(self->http_fd,NULL,NULL,SOCK_NONBLOCK | SOCK_CLOEXEC);
+                printf("%d\n",nt_fd);
+                if(nt_fd == -1)
+                    continue;
+                sprintf(iss_buf,"s/%d/e",nt_fd);
+                self->iss_work(self,iss_buf);
+            }
+            if(events[i].data.fd == fifo_fd) {
+                char buffer[256];
+                ssize_t bytes_read;
+                
+                // 一次性读取所有可用数据
+                bytes_read = read(fifo_fd, buffer, sizeof(buffer));
+                
+                if (bytes_read > 0) {
+                    printf("DEBUG: Read %zd bytes from pipe: ", bytes_read);
+                    for (int j = 0; j < bytes_read; j++) {
+                        printf("%c ", buffer[j]);
+                    }
+                    printf("\n");
+                    
+                    // 处理每个命令（按接收顺序）
+                    for (int j = 0; j < bytes_read; j++) {
+                        printf("Processing command[%d]: %c\n", j, buffer[j]);
+                        
+                        switch(buffer[j]) {
+                            case 'q':
+                                printf("Quit command found at position %d\n", j);
+                                quit_server(self);
+                                return 1;  // 立即退出，不处理后续命令
+                            case 'u':
+                                printf("Update command\n");
+                                // 更新逻辑
+                                break;
+                            default:
+                                printf("Unknown command: %c (ASCII: %d)\n", 
+                                    buffer[j], buffer[j]);
+                        }
+                    }
+                } else if (bytes_read == 0) {
+                    printf("Pipe closed by writer\n");
+                    close(fifo_fd);
+                } else if (errno != EAGAIN && errno != EWOULDBLOCK) {
+                    perror("Error reading from pipe");
+                }
+            }
+        }
+        /*工作循环----------------------------*/
+    }
+}
+
+void *run_network(void *self_d)
+{
+    netm *self = (netm*)self_d;
+    self->start_pool(self);
+    self->statue = POOL_ON;
+    server_run(self->port,self->fifo_fd[0],self);
+    self->shutdown_pool(self);
+}
+
+int init_networkmanager(netm *self,int *fifo,log_manager *logmanager,int port)
+{
+    self->run_network = run_network;
+    self->iss_work = iss_work;
+    self->start_pool = start_pool;
+    self->shutdown_pool = shutdown_pool;
+    //装载方法
+    self->fifo_fd[0]= fifo[0];
+    self->fifo_fd[1]= fifo[1];
+    self->last_alc = 0;
+    self->port = port;
+    //初始化参数
+    self->logmanager = logmanager;
+    self->err_indictor = (indiector*)malloc(sizeof(indiector));
+    self->statue = ALL_STOP;
+    return 0;
+}

c/network/network.h

@@ -0,0 +1,58 @@
+#ifndef NETWORK
+#define NETWORK
+
+#define POOL_ON 1
+#define SERVER_ON 2
+#define ALL_STOP 0
+
+#include <pthread.h>
+#include "tools/log/log.h"
+#include "erroprocess/erroprocess.h"
+#include <stdatomic.h>
+//单个线程模型
+typedef struct pthread_module
+{
+    pthread_t pthread_id;
+    int fifo_fd[2];
+    atomic_int status;
+}pth_m;
+//打包线程模型参数
+typedef struct net_args
+{
+    log_manager *log;
+    pth_m *pth;
+}net_args;
+
+typedef struct network_manager//网络管理器
+{
+    pth_m pool[NET_MAX_POOL];
+    void *(*run_network)(void*);//启动网络监听
+    int (*start_pool)(struct network_manager*);
+    int (*shutdown_pool)(struct network_manager*);
+    int (*iss_work)(struct network_manager*,char *);
+    
+    int fifo_fd[2];
+    pthread_t pid;
+    log_manager *logmanager;
+    indiector *err_indictor; 
+    int last_alc;
+    int port;
+    int epoll_fd;
+    int http_fd;
+    int statue;
+}netm;
+
+typedef struct rebot_message
+{
+    char raw_message[NET_MAX_MESSAGE_BUF];
+    char nickname[64];
+    char gid[32];
+    char uid[32];
+    char message_type;
+    sem_t status;
+    int state;
+}rbt_msg;
+
+int init_networkmanager(netm *self,int *fifo,log_manager *logmanager,int port);
+
+#endif

c/network/swap.c

@@ -0,0 +1,53 @@
+#define _GNU_SOURCE  
+
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <linux/memfd.h>
+#include <sys/syscall.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+
+#include "network.h"
+#include "swap.h"
+
+
+
+int make_swap(rbt_msg *swap)
+{
+   swap->state = NEWMSG;
+   sem_post(&swap->status);
+}
+
+int create_swap(const char *name)
+{
+   int fd = memfd_create(name,0);
+
+   //申请共享内存
+   ftruncate(fd, sizeof(rbt_msg));
+   //调整关闭策略
+   int flags = fcntl(fd, F_GETFD);
+   flags &= ~FD_CLOEXEC;
+   fcntl(fd, F_SETFD, flags);
+   //调整大小
+   rbt_msg *init_msg = (rbt_msg*)mmap(NULL, sizeof(rbt_msg), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
+   char buf[NET_MAX_MESSAGE_BUF] = {'\0'};
+   //初始化
+   memcpy(init_msg->raw_message,buf,NET_MAX_MESSAGE_BUF);
+   memcpy(init_msg->nickname,buf,64);
+   sem_init(&init_msg->status,1,1);
+   init_msg->raw_message[0] = '\0';
+   init_msg->state = FREE;
+   init_msg->uid[0] = '\0';
+   munmap((void*)init_msg,sizeof(rbt_msg)); 
+   return fd;
+}
+
+int close_swap(int shmid,rbt_msg *swap)
+{
+   swap->state = QUITPLG;//置退出态
+   sem_post(&swap->status);//发送信号量
+   close(shmid);//关闭共享内存
+}

c/network/swap.h

@@ -0,0 +1,13 @@
+#ifndef SWAP
+#define SWAP
+
+#include  "config.h"
+#define QUITPLG 0
+#define NEWMSG 1
+#define FREE 2
+
+int make_swap(rbt_msg *swap);
+int create_swap(const char *name);
+int close_swap(int shmid,rbt_msg *swap);
+
+#endif

c/run_pluginmanager/run_pluginmanager.c

@@ -0,0 +1,9 @@
+#include <unistd.h>
+
+int main(int argc,char **argv)
+{
+    for(;;)
+    {
+        
+    }
+}

c/tem/ctl.c

@@ -0,0 +1,293 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stddef.h>
+#include <string.h>
+#include <termios.h>
+#include <pthread.h>
+#include <signal.h>
+
+#include "ctl.h"
+
+#include "interpreter/interpreter.h"
+#include "tools/log/log.h"
+
+static void goto_col(int x)
+{
+    char seq[32];
+    int  n = snprintf(seq, sizeof(seq), "\r\033[%dC", x+1); /* 1-based */
+    write(STDOUT_FILENO, seq, n);
+}
+
+int replace_chars(int start_pos, int old_len, const char *new_str) {
+    // 1. 移动光标到起始位置
+    if(new_str == NULL)
+        return -1;
+    char move_cmd[16];
+    int move_len = snprintf(move_cmd, sizeof(move_cmd), "\033[%dG", start_pos + 1); // ANSI 列从1开始
+    write(STDOUT_FILENO, move_cmd, move_len);
+
+    // 2. 写入新内容
+    int new_len = strlen(new_str);
+    write(STDOUT_FILENO, new_str, new_len-1);
+
+    // 3. 如果新内容比原内容短，删除剩余部分
+    if (new_len < old_len) {
+        write(STDOUT_FILENO, "\033[K", 3);
+        return 0 ;
+    }
+    return 0;
+}
+
+int take_history(Ctl *self,int *currant_index,int *length,char *buf,int toward)
+{
+    if(toward ==1)
+    {
+        if(*currant_index>0)
+            (*currant_index)--;
+        else
+            *currant_index = TEM_HISTORY_BUF-1;
+
+    }
+    else if(toward == 0)
+    {
+        if(*currant_index <TEM_HISTORY_BUF-1)
+            (*currant_index)++;
+        else
+            *currant_index = 0;
+    }
+
+    if(self->history[*currant_index] == NULL){
+        *length = *length-2;
+        return 0;
+    }
+    replace_chars(sizeof(TEM_PROMPT)-1,*length,self->history[*currant_index]);
+    memcpy(buf,self->history[*currant_index],TEM_MAX_BUF);
+    buf[strlen(buf)-1] = '\0';
+    *length = strlen(buf);
+    return 0;
+}
+
+
+
+int del_char(int length, int index, char *buf)
+{ 
+    int buf_idx = index - sizeof(TEM_PROMPT);  // 待删字符在 buf 中的下标
+
+    if (length == index)           // 行尾退格
+    {
+        write(STDOUT_FILENO, "\b \b", 3);
+        return 1;
+    }
+
+    int str_len = length - index;      
+    char *new_str = (char*)malloc(str_len);
+    memcpy(new_str, &buf[buf_idx+2], str_len-1);
+    write(STDOUT_FILENO, new_str, str_len);
+    goto_col(length - 2);
+    write(STDOUT_FILENO, "\033[K", 3);
+    goto_col(index - 1);
+    char *restr = buf+index-sizeof(TEM_PROMPT)+1;
+    memcpy(restr,new_str,str_len);
+    free(new_str);
+    return 1;
+}
+
+
+int get_cursor(int *col)
+{
+    int row;
+    struct termios old, tmp;
+    tcgetattr(STDIN_FILENO, &old);
+    tmp = old;
+    cfmakeraw(&tmp);
+    tcsetattr(STDIN_FILENO, TCSADRAIN, &tmp);
+
+    /* 发 DSR 查询：ESC [ 6 n */
+    write(STDOUT_FILENO, "\033[6n", 4);
+
+    /* 读应答，最大 16 字节足够：ESC [ rr ; cc R */
+    char buf[16] = {0};
+    int i = 0;
+    while (i < sizeof(buf) - 1) {
+        read(STDIN_FILENO, &buf[i], 1);
+        if (buf[i] == 'R') break;
+        ++i;
+    }
+    buf[++i] = '\0';
+
+    tcsetattr(STDIN_FILENO, TCSADRAIN, &old);   /* 恢复终端属性 */
+
+    /* 解析 ESC [ row ; col R */
+    if (sscanf(buf, "\033[%d;%dR",&row, col) != 2)
+        return -1;
+    return 0;
+}
+
+int read_line(char *buf,Ctl *self)
+{
+    int length = 0;
+    char input_buf;
+    int cursor_index = 0;
+    int currant_index = self->index;
+    while(read(0,&input_buf,1)==1&&length<TEM_MAX_BUF)
+    {
+        switch (input_buf) {
+            case '\n':                    
+                buf[length++] = input_buf;
+                write(STDOUT_FILENO,"\n",1);
+                buf[length] = '\0';
+                return length;
+            
+            //backspace
+            case 0x7F:
+                buf[length] = '\0';
+                if(length == 0)
+                    break;
+                length--;
+                get_cursor(&cursor_index);
+                del_char(length+sizeof(TEM_PROMPT),cursor_index-1,buf);
+                break;
+            //方向键
+            case 0x41: case 0x42: case 0x43: case 0x44:
+                if (length >= 2 &&
+                    buf[length - 1] == 0x5B &&
+                    buf[length - 2] == 0x1B)
+                {
+                    switch(input_buf)
+                    {
+                        case 0x41:
+                            take_history(self,&currant_index,&length,buf,1);
+                            break;
+                            //一定记得加break!!!
+                        case 0x42:
+                            take_history(self,&currant_index,&length,buf,0);
+                            break;
+                        case 0x43:
+                            get_cursor(&cursor_index);
+                            length = length-2;
+                            if(cursor_index == sizeof(TEM_PROMPT)+length)
+                            {
+                                break;
+                            }
+                            write(STDOUT_FILENO, "\x1b[C", 3);
+                            break;
+                        case 0x44:
+                            get_cursor(&cursor_index);
+                            length = length -2;
+                            if(cursor_index == sizeof(TEM_PROMPT))
+                            {
+                                break;
+                            }
+                            write(STDOUT_FILENO, "\x1b[D", 3);
+                            break;
+
+                    }      
+                    break;                
+                }
+            default:                       
+                write(STDOUT_FILENO, &input_buf, 1);
+                buf[length++] = input_buf;
+                cursor_index = length;
+                break;
+            }
+
+    }
+    if(length>=TEM_MAX_BUF)
+    {
+        perror("SYS:input pass edge");
+        return 0;
+    }
+    return 0;
+
+}
+
+int infifo(Ctl *self,const char *cmd)
+{
+    if(self->history[self->index]!=NULL){
+        memcpy(self->history[self->index],cmd,TEM_MAX_BUF);
+    }
+    else{
+        self->history[self->index] = (char*)malloc(TEM_MAX_BUF*sizeof(char));
+        memcpy(self->history[self->index],cmd,TEM_MAX_BUF);
+    }
+    //存储命令历史s
+    if(self->index<TEM_HISTORY_BUF){
+        self->index++;
+        return 0;
+    }
+    else{
+        self->index = 0;
+        return 0;
+    }
+
+}
+
+int free_history(Ctl *self)
+{
+    for(int i = 0;i<6;i++)
+    {
+        if(self->history[i]!=NULL)
+        {
+            free(self->history[i]);
+        }
+    }
+    return 1;
+}
+
+int teml(Ctl *self,int fifo[2])
+{   
+    char input[TEM_MAX_BUF] = {'\0'};
+    ctx *command = (ctx*)malloc(sizeof(ctx));
+    Cmd cmd_dir[10];
+    init_interpreter(cmd_dir,command,fifo,self->logmanager);
+    command->statue = 0;
+    self->command = command;
+    do
+    {   //设置缓冲区，接收用户输入
+        write(STDOUT_FILENO,TEM_PROMPT,sizeof(TEM_PROMPT));
+        command->line = read_line(input,self);
+        if(command->line == -1)
+            perror("sys error");
+        //将用户输入入队
+        infifo(self,input);
+        logs *log = (logs*)malloc(sizeof(logs));
+        memcpy(log->log,input,sizeof(input));
+        self->logmanager->in_log(log,self->logmanager);
+        memcpy(command->command,input,sizeof(input));        
+        interpret(SIG_MOD,command,cmd_dir);
+        const char fexp[256] = {'\0'};
+        memcpy(&input,&fexp,TEM_MAX_BUF);
+    }while(command->statue == 0);
+    free_history(self);
+    self->command = NULL;
+    free(command);
+}
+
+Ctl *init_tem(log_manager *logmanager)
+{
+    //初始化终端对象
+    Ctl *tem = (Ctl*)malloc(sizeof(Ctl));
+    tem->run = teml;
+    tem->infifo = infifo;
+    tem->index = 0;
+    tem->logmanager = logmanager;
+    char *his_buf[TEM_HISTORY_BUF] = {NULL};
+    memcpy(tem->history,his_buf,TEM_HISTORY_BUF);
+    for(int i =0;i<6;i++)
+    {
+        tem->history[i] = NULL;
+    }
+    struct termios tio_setting;
+    tcgetattr(STDIN_FILENO,&tio_setting);
+    tio_setting.c_lflag &= ~(ICANON|ECHO);
+    tio_setting.c_cflag |=ISIG;
+    tio_setting.c_cc[VMIN] =1;
+    tio_setting.c_cc[VTIME] = 0;
+    tcsetattr(STDERR_FILENO,TCSAFLUSH,&tio_setting);
+
+    return tem;
+}
+
+

c/tem/ctl.h

@@ -0,0 +1,27 @@
+#ifndef CTL
+#define CTL
+
+#include <pthread.h>
+#include "tools/toml/toml.h"
+#include "tools/log/log.h"
+#include "interpreter/interpreter.h"
+#include "config.h"
+
+
+
+typedef struct Ctl
+{
+    int (*run)(struct Ctl*,int *);
+    int (*infifo)(struct Ctl*,const char*);
+    int index;
+    char *history[TEM_HISTORY_BUF];
+    log_manager *logmanager;
+    ctx *command;//解释器上下文
+    toml_table_t *config;
+}Ctl;
+
+Ctl *init_tem(log_manager *logmanager);
+int free_history(Ctl *self);
+
+
+#endif

c/tools/log/log.c

@@ -0,0 +1,290 @@
+#define _POSIX_C_SOURCE 200112L
+#include "log.h"
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <time.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+
+int write_into_block(char *writein,char *org,int *length,int maxlength,char *logname)
+{
+    if(writein == NULL||org == NULL||length == NULL||logname == NULL)
+        return -1;
+    if(*length+strlen(org)<maxlength-1)
+    {
+        strcpy(&writein[*length],org);
+        *length +=strlen(org);//栈内存充足
+    }
+    else
+    {
+        int n = *length + strlen(org) - maxlength;
+        strncpy(&writein[*length],org,strlen(org)-n);//栈内存不足
+        writein[maxlength-1] = '\0';
+        int fd = open(logname,O_CREAT | O_WRONLY | O_APPEND, 0644);
+        if(fd != -1)
+        {
+            write(fd,writein,maxlength);
+            close(fd);
+        }
+        else if(fd == -1)
+            perror("log:");//仅警告
+        *length = n;
+        strcpy(writein,&org[*length]);//剩余部分拷贝 
+    }
+    return 0;
+}
+
+int in_log(logs *log,log_manager *self)
+{
+    if(log == NULL||self == NULL)
+        return -1;
+    log->log[MAX_LOG_LENGTH-1] = '\0';
+    sem_wait(&self->log_sem);//加锁
+    if(self->log == NULL){
+        self->log = log;
+        self->rear = log;
+        self->count++;
+        sem_post(&self->log_sem);
+        return self->count;
+    }
+    if(self->count == 1)
+        self->log->next = log;
+    self->count++;
+    log->next = NULL;
+    self->rear->next = log;
+    self->rear = log;
+    sem_post(&self->log_sem);
+    return self->count;
+}
+
+logs *out_log(log_manager *self)
+{
+    if(self == NULL)
+        return NULL;
+    sem_wait(&self->log_sem);
+    logs *buf = self->log;
+    if(buf==NULL)
+    {
+        sem_post(&self->log_sem);
+        return NULL;
+    }
+    if(self->log->next ==NULL)
+        self->log = self->rear = NULL;
+    else
+        self->log = self->log->next;
+    self->count--;
+    sem_post(&self->log_sem);
+    buf->next =NULL;
+    return buf;
+}
+
+int sleep_with_signal(log_manager *self)
+{
+    struct timespec ts;
+    int rc;
+
+    /* 计算绝对超时：当前 + 1000 s */
+    if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0)
+        return -1;                     /* 罕见失败 */
+
+    ts.tv_sec += 1000;
+    /* 纳秒部分无需处理，1000 s 整不会溢出 */
+
+    pthread_mutex_lock(&self->mtx);    /* 进入临界区 */
+
+    while (1) {
+        rc = pthread_cond_timedwait(&self->cond, &self->mtx, &ts);
+        if (rc == ETIMEDOUT) {         /* 1000 s 到点 */
+            pthread_mutex_unlock(&self->mtx);
+            return 1;                  /* 正常超时 */
+        }
+        if (rc != 0) {                 /* 其他错误 */
+            pthread_mutex_unlock(&self->mtx);
+            return -1;
+        }
+
+        /* 被 signal / broadcast 提前唤醒，检查 stop */
+        if (self->stop == 1) {/* 主线程要求退出 */
+            pthread_mutex_unlock(&self->mtx);
+            return 0;                  /* 告诉调用者：该结束了 */
+        }
+    }
+}
+
+int cleanup(log_manager *self)
+{
+    if(self->log ==NULL)
+        return 1;
+    logs *tobeclean,*loc;
+    sem_wait(&self->log_sem);//获取信号量
+    loc = self->log;
+    self->log = NULL;
+    self->count = 0;//摘取log链
+    sem_post(&self->log_sem);
+    //释放信号量
+    char *logbuf;
+    void *logbufbk;
+    char failback[MAX_LOG_LENGTH];
+    logbuf = (char*)malloc(1);
+    logbuf[0] = '\0';
+    size_t buf_length = 0,buf_lengthbk = 0;
+    int fd;
+    while(loc->next !=NULL)
+    {
+        tobeclean = loc;
+        loc = loc->next;
+        if(logbuf != failback){
+            logbufbk = logbuf;
+            logbuf = (char*)realloc(logbuf,strlen(logbuf)+strlen(tobeclean->log)+1);//为日志分配新的内存
+        }
+        if(logbuf == NULL){
+            fd = open("log.txt",O_CREAT | O_WRONLY | O_APPEND, 0644);
+            if(fd != -1)
+            {
+                write(fd,logbufbk,buf_length);
+                close(fd);
+            }
+            free(logbufbk);
+            logbuf = failback;//降级策略，堆空间不足时，使用预分配栈空间
+            buf_length = 0;
+        }
+        if(logbuf != failback){
+            buf_lengthbk = buf_length;
+            buf_length = strlen(logbuf)+strlen(tobeclean->log);
+            strcpy(logbuf+buf_lengthbk,tobeclean->log);
+        }
+        else
+        {
+            write_into_block(logbuf,tobeclean->log,&buf_length,MAX_LOG_LENGTH,"log.txt");
+        }
+        free(tobeclean);
+    }
+    if(logbuf != failback){
+        logbufbk = logbuf; 
+        logbuf = (char*)realloc(logbuf,strlen(logbuf)+strlen(loc->log)+2);
+        if(logbuf == NULL)
+        {
+            free(logbufbk);
+            logbuf = failback;
+            strcpy(logbuf,loc->log);
+            buf_length = strlen(loc->log);
+            
+        }
+        else{
+        buf_lengthbk = buf_length;
+        buf_length = strlen(logbuf)+strlen(loc->log);
+        strcpy(logbuf+buf_lengthbk,loc->log);
+        }
+    }
+    else{
+        write_into_block(logbuf,loc->log,&buf_length,MAX_LOG_LENGTH,"log.txt");
+    }
+
+    logbuf[buf_length] = '\0';
+    
+    free(loc);
+
+    fd = open("log.txt",O_CREAT | O_WRONLY | O_APPEND, 0644);
+    if(fd == -1){
+        perror("file:");
+        if(logbuf != failback)
+            free(logbuf);
+        return -1;
+    }
+    int error_buf = write(fd,logbuf,strlen(logbuf));
+    if(error_buf==-1){
+        close(fd);
+        if(logbuf != failback)
+            free(logbuf);
+        return -1;
+    }
+    else if(error_buf<buf_length)
+        write(fd,"unknown error case log write cut down\n",38);
+    if(logbuf != failback)
+        free(logbuf);
+    close(fd);
+    return 0; 
+}
+
+void log_manager_stop(log_manager *self)
+{
+    pthread_mutex_lock(&self->mtx);
+    if(self->stop == 1){
+        pthread_mutex_unlock(&self->mtx);
+        return ;
+    }
+    self->stop = 1;
+                  /* 置退出标志 */
+    printf("SYS:stopping loger\n");
+    logs *log = malloc(sizeof(logs));
+    strcpy(log->log,"SYS:stopping loger\n");
+    self->in_log(log,self);
+    log = malloc(sizeof(logs));
+    strcpy(log->log,"SYS:done\n");
+    printf("SYS:done\n");
+    self->in_log(log,self);
+    pthread_mutex_unlock(&self->mtx);
+    pthread_cond_broadcast(&self->cond); /* 唤醒所有等待线程 */
+}
+
+//定期清理函数
+void *clear_log(void *self_p)
+{
+    log_manager *self = (log_manager*)self_p;
+    for(;;)
+    {
+        sleep_with_signal(self);
+        sem_wait(&self->log_sem);
+        if((self->count<MAX_LOG||self->log==NULL)&&self->stop !=1){
+            sem_post(&self->log_sem);
+            continue;
+        }
+        sem_post(&self->log_sem);
+        cleanup(self);
+        if(self->stop == 1){
+            return NULL;
+        }
+    }
+}
+
+int init_loger(log_manager *self)
+{
+    if(self == NULL)
+    {
+        perror("NULL\n");
+        return -1;
+    }
+    if(sem_init(&self->log_sem, 0,1)==-1)
+        return -1;
+    if(pthread_mutex_init(&self->mtx,NULL)==-1)
+    {
+        if(sem_destroy(&self->log_sem)==-1)
+        {
+            perror("log:");
+        }
+        return -1;   
+    }
+    if(pthread_cond_init(&self->cond,NULL)==-1)
+    {
+        if(sem_destroy(&self->log_sem)==-1)
+        {
+            perror("log:");
+        }
+        if(pthread_mutex_destroy(&self->mtx)==-1)
+        {
+            perror("log:");
+        }
+        return -1;
+    }
+    self->in_log = in_log;
+    self->out_log = out_log;
+    self->clear_log = clear_log;
+    self->log = NULL;
+    self->stop =  0;
+    self->cleanup = cleanup;
+    self->count = 0;
+    return 0;
+}

c/tools/log/log.h

@@ -0,0 +1,34 @@
+#ifndef LOG
+#define LOG
+
+#include "config.h"
+#include <semaphore.h>
+#include <pthread.h>
+
+
+typedef struct logs
+{
+    char log[MAX_LOG_LENGTH];
+    struct logs *next;
+}logs;
+
+typedef struct log_manager
+{
+    pthread_t pid;
+    int (*in_log)(logs *,struct log_manager*);
+    logs* (*out_log)(struct log_manager*);
+    void *(*clear_log)(void*);
+    int (*cleanup)(struct log_manager*);
+    sem_t log_sem;
+    logs *log;
+    logs *rear;
+    int count;
+    pthread_mutex_t mtx;
+    pthread_cond_t cond;
+    int stop;
+}log_manager;
+
+void log_manager_stop(log_manager *self);
+int init_loger(log_manager *self);
+
+#endif

c/tools/pkgmanager/pkginstall.c

@@ -0,0 +1,40 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "pkginstall.h"
+
+int check_python(pkger *self)
+{
+    //只需要检查pip是否存在，即可确定python是否存在
+    int pip_ex = system("pip -V >/dev/null 2>&1");
+    if(WIFEXITED(pip_ex) && WEXITSTATUS(pip_ex) == 0)
+        return 1;
+    else
+        return 0;
+}
+
+
+//TO_DO 完成一下函数实现
+
+int install_dependence(pkger *self)
+{
+
+}
+
+int check_dir(pkger *self)
+{
+    
+}
+
+int packup(pkger *self)
+{
+
+}//运行包安装器时执行此函数，注意所有函数通过结构体内部调用。
+
+pkger *init_pkginstaller()
+{
+    pkger *self = (pkger*)malloc(sizeof(pkger));
+    self->check_dir = check_dir;
+    self->check_python = check_python;
+    self->install_dependence = install_dependence;
+    self->packup = packup;
+}

c/tools/pkgmanager/pkginstall.h

@@ -0,0 +1,21 @@
+#ifndef PKGINSTALL
+
+#define PKGINSTALL
+
+typedef struct pkger
+{
+    //data
+    int requirement;//存储requirement.txt的文件fd
+    char dir[256];
+    //method
+    int (*check_python)(struct pkger*);
+    int (*install_dependence)(struct pkger*);
+    int (*check_dir)(struct pkger*);
+    int (*packup)(struct pkger*);
+
+}pkger;
+
+pkger *init_pkginstaller();
+
+
+#endif

c/tools/quit/quit.c

@@ -0,0 +1,100 @@
+#define _GNU_SOURCE 
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include<unistd.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/epoll.h>
+#include "quit.h"
+#include "tem/ctl.h"
+#include "tools/toml/toml.h"
+
+int quit_server(netm *self)
+{
+    if(self ==NULL)
+        return -1;
+    
+    //关闭epoll监听
+    if(self->epoll_fd != -1)
+    {
+        epoll_ctl(self->epoll_fd,EPOLL_CTL_DEL,self->http_fd,NULL);
+        epoll_ctl(self->epoll_fd,EPOLL_CTL_DEL,self->fifo_fd[0],NULL);
+        self->epoll_fd = -1;
+    }
+    //关闭socket监听
+    if(self->http_fd != -1)
+    {
+        shutdown(self->http_fd, SHUT_RDWR);
+        if(close(self->http_fd)==-1)
+            perror("http");
+        self->http_fd =-1;
+    }
+    //关闭管道监听
+    if(self->fifo_fd[1] != -1)
+    {
+        if(close(self->fifo_fd[1])==-1)
+            return -1;
+        self->fifo_fd[1] = -1;
+    }
+    
+    free(self->err_indictor);
+    self->statue = POOL_ON;
+    return 0;
+}
+
+void quit_all(int status,void *self_p)
+{
+    alres *resouce =(alres*)self_p;
+    //转换参数
+
+    resouce->network->shutdown_pool(resouce->network);
+    logs *netlog = (logs*)malloc(sizeof(logs));
+    netlog->next = NULL;
+    memcpy(netlog->log,"shuting down networkserver",27);
+    
+    if(resouce->network->statue == SERVER_ON)
+    {
+        quit_server(resouce->network);
+    }
+    if(resouce->network->statue == POOL_ON)
+    {
+        resouce->network->shutdown_pool(resouce->network);
+    }
+    resouce->loger->in_log(netlog,resouce->loger);
+    free(resouce->network);
+    //释放网络资源
+    if(resouce->tem->command !=NULL){
+        free_history(resouce->tem);
+        if(resouce->tem->command->arg != NULL)
+        {
+            args* arg  = resouce->tem->command->arg;
+            if(arg->next !=NULL)
+            {
+                while(arg->next != NULL){
+                args* tobefree = arg;
+                arg = arg->next;
+                free(tobefree);
+                }
+                free(arg);
+            }
+        }
+        toml_free(resouce->tem->config);
+        free(resouce->tem->command);
+    }
+    //释放终端资源
+    //释放日志管理器
+    if(resouce->loger->pid != -1){
+        log_manager_stop(resouce->loger);
+        pthread_join(resouce->loger->pid,NULL);
+    }
+    pthread_mutex_destroy(&resouce->loger->mtx);
+    pthread_cond_destroy(&resouce->loger->cond);
+    log_manager_stop(resouce->loger);
+    sem_destroy(&resouce->loger->log_sem);
+    //销毁信号量
+
+    free(resouce->loger);
+    //清理日志
+}

c/tools/quit/quit.h

@@ -0,0 +1,20 @@
+#ifndef QUIT_LIB
+#define QUIT_LIB
+
+#include "network/network.h"
+#include "tem/ctl.h"
+#include "tools/log/log.h"
+typedef struct all_resources
+{
+    Ctl *tem;
+    netm *network;
+    log_manager *loger;
+
+}alres;
+
+
+void quit_all(int status,void *self_p);
+int quit_server(netm *self);
+
+
+#endif

c/tools/toml/toml.h

@@ -0,0 +1,175 @@
+/*
+  MIT License
+
+  Copyright (c) CK Tan
+  https://github.com/cktan/tomlc99
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+#ifndef TOML_H
+#define TOML_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4996)
+#endif
+
+#include <stdint.h>
+#include <stdio.h>
+
+#ifdef __cplusplus
+#define TOML_EXTERN extern "C"
+#else
+#define TOML_EXTERN extern
+#endif
+
+typedef struct toml_timestamp_t toml_timestamp_t;
+typedef struct toml_table_t toml_table_t;
+typedef struct toml_array_t toml_array_t;
+typedef struct toml_datum_t toml_datum_t;
+
+/* Parse a file. Return a table on success, or 0 otherwise.
+ * Caller must toml_free(the-return-value) after use.
+ */
+TOML_EXTERN toml_table_t *toml_parse_file(FILE *fp, char *errbuf, int errbufsz);
+
+/* Parse a string containing the full config.
+ * Return a table on success, or 0 otherwise.
+ * Caller must toml_free(the-return-value) after use.
+ */
+TOML_EXTERN toml_table_t *toml_parse(char *conf, /* NUL terminated, please. */
+                                     char *errbuf, int errbufsz);
+
+/* Free the table returned by toml_parse() or toml_parse_file(). Once
+ * this function is called, any handles accessed through this tab
+ * directly or indirectly are no longer valid.
+ */
+TOML_EXTERN void toml_free(toml_table_t *tab);
+
+/* Timestamp types. The year, month, day, hour, minute, second, z
+ * fields may be NULL if they are not relevant. e.g. In a DATE
+ * type, the hour, minute, second and z fields will be NULLs.
+ */
+struct toml_timestamp_t {
+  struct { /* internal. do not use. */
+    int year, month, day;
+    int hour, minute, second, millisec;
+    char z[10];
+  } __buffer;
+  int *year, *month, *day;
+  int *hour, *minute, *second, *millisec;
+  char *z;
+};
+
+/*-----------------------------------------------------------------
+ *  Enhanced access methods
+ */
+struct toml_datum_t {
+  int ok;
+  union {
+    toml_timestamp_t *ts; /* ts must be freed after use */
+    char *s;              /* string value. s must be freed after use */
+    int b;                /* bool value */
+    int64_t i;            /* int value */
+    double d;             /* double value */
+  } u;
+};
+
+/* on arrays: */
+/* ... retrieve size of array. */
+TOML_EXTERN int toml_array_nelem(const toml_array_t *arr);
+/* ... retrieve values using index. */
+TOML_EXTERN toml_datum_t toml_string_at(const toml_array_t *arr, int idx);
+TOML_EXTERN toml_datum_t toml_bool_at(const toml_array_t *arr, int idx);
+TOML_EXTERN toml_datum_t toml_int_at(const toml_array_t *arr, int idx);
+TOML_EXTERN toml_datum_t toml_double_at(const toml_array_t *arr, int idx);
+TOML_EXTERN toml_datum_t toml_timestamp_at(const toml_array_t *arr, int idx);
+/* ... retrieve array or table using index. */
+TOML_EXTERN toml_array_t *toml_array_at(const toml_array_t *arr, int idx);
+TOML_EXTERN toml_table_t *toml_table_at(const toml_array_t *arr, int idx);
+
+/* on tables: */
+/* ... retrieve the key in table at keyidx. Return 0 if out of range. */
+TOML_EXTERN const char *toml_key_in(const toml_table_t *tab, int keyidx);
+/* ... returns 1 if key exists in tab, 0 otherwise */
+TOML_EXTERN int toml_key_exists(const toml_table_t *tab, const char *key);
+/* ... retrieve values using key. */
+TOML_EXTERN toml_datum_t toml_string_in(const toml_table_t *arr,
+                                        const char *key);
+TOML_EXTERN toml_datum_t toml_bool_in(const toml_table_t *arr, const char *key);
+TOML_EXTERN toml_datum_t toml_int_in(const toml_table_t *arr, const char *key);
+TOML_EXTERN toml_datum_t toml_double_in(const toml_table_t *arr,
+                                        const char *key);
+TOML_EXTERN toml_datum_t toml_timestamp_in(const toml_table_t *arr,
+                                           const char *key);
+/* .. retrieve array or table using key. */
+TOML_EXTERN toml_array_t *toml_array_in(const toml_table_t *tab,
+                                        const char *key);
+TOML_EXTERN toml_table_t *toml_table_in(const toml_table_t *tab,
+                                        const char *key);
+
+/*-----------------------------------------------------------------
+ * lesser used
+ */
+/* Return the array kind: 't'able, 'a'rray, 'v'alue, 'm'ixed */
+TOML_EXTERN char toml_array_kind(const toml_array_t *arr);
+
+/* For array kind 'v'alue, return the type of values
+   i:int, d:double, b:bool, s:string, t:time, D:date, T:timestamp, 'm'ixed
+   0 if unknown
+*/
+TOML_EXTERN char toml_array_type(const toml_array_t *arr);
+
+/* Return the key of an array */
+TOML_EXTERN const char *toml_array_key(const toml_array_t *arr);
+
+/* Return the number of key-values in a table */
+TOML_EXTERN int toml_table_nkval(const toml_table_t *tab);
+
+/* Return the number of arrays in a table */
+TOML_EXTERN int toml_table_narr(const toml_table_t *tab);
+
+/* Return the number of sub-tables in a table */
+TOML_EXTERN int toml_table_ntab(const toml_table_t *tab);
+
+/* Return the key of a table*/
+TOML_EXTERN const char *toml_table_key(const toml_table_t *tab);
+
+/*--------------------------------------------------------------
+ * misc
+ */
+TOML_EXTERN int toml_utf8_to_ucs(const char *orig, int len, int64_t *ret);
+TOML_EXTERN int toml_ucs_to_utf8(int64_t code, char buf[6]);
+TOML_EXTERN void toml_set_memutil(void *(*xxmalloc)(size_t),
+                                  void (*xxfree)(void *));
+
+/*--------------------------------------------------------------
+ *  deprecated
+ */
+/* A raw value, must be processed by toml_rto* before using. */
+typedef const char *toml_raw_t;
+TOML_EXTERN toml_raw_t toml_raw_in(const toml_table_t *tab, const char *key);
+TOML_EXTERN toml_raw_t toml_raw_at(const toml_array_t *arr, int idx);
+TOML_EXTERN int toml_rtos(toml_raw_t s, char **ret);
+TOML_EXTERN int toml_rtob(toml_raw_t s, int *ret);
+TOML_EXTERN int toml_rtoi(toml_raw_t s, int64_t *ret);
+TOML_EXTERN int toml_rtod(toml_raw_t s, double *ret);
+TOML_EXTERN int toml_rtod_ex(toml_raw_t s, double *ret, char *buf, int buflen);
+TOML_EXTERN int toml_rtots(toml_raw_t s, toml_timestamp_t *ret);
+
+#endif /* TOML_H */

requirements.txt

@@ -1,16 +0,0 @@
-blinker==1.9.0
-certifi==2025.8.3
-charset-normalizer==3.4.2
-click==8.2.1
-colorama==0.4.6
-Flask==3.1.1
-idna==3.10
-itsdangerous==2.2.0
-Jinja2==3.1.6
-MarkupSafe==3.0.2
-packaging==25.0
-pkg==0.2
-requests==2.32.4
-toml==0.10.2
-urllib3==2.5.0
-Werkzeug==3.1.3

run.bat

@@ -1,74 +0,0 @@
-@echo off
-
-
-set PROJECT_DIR=%~dp0
-set VENV_DIR=%PROJECT_DIR%.venv
-
-
-if exist "%VENV_DIR%\Scripts\activate.bat" (
-
-    call "%VENV_DIR%\Scripts\activate.bat"
-) else (
-
-    python -m venv "%VENV_DIR%"
-    call "%VENV_DIR%\Scripts\activate.bat"
-    
-    if errorlevel 1 (
-        echo error: fail to create env
-        pause
-        exit /b 1
-    )
-)
-
-
-if "%VIRTUAL_ENV%" == "" (
-    echo error: fail to activate env
-    pause
-    exit /b 1
-)
-
-echo installing dependence...
-
-pip install -r requirements.txt
-if errorlevel 1 (
-    echo error: fail to install dependence
-    pause
-    exit /b 1
-)
-
-pip install waitress
-if errorlevel 1 (
-    echo error: fail to install waitress 
-    pause
-    exit /b 1
-)
-
-
-echo reading port from config...
-for /f "usebackq tokens=*" %%P in (`python -c "from src.file_store_api import ConfigManager; config=ConfigManager().load_config(); print(config.get('app', {}).get('list_port', 25580))"`) do (
-    set PORT=%%P
-)
-
-
-if "%PORT%"=="" (
-    set PORT=25580
-    echo can't read port,use custom port:25580
-) else (
-    echo success read port: %PORT%
-)
-
-
-echo starting rebot_server...
-echo listening at: %PORT%
-
-
-waitress-serve --host=0.0.0.0 --port=%PORT% app:app
-
-
-if errorlevel 1 (
-    echo error,fail to start
-    pause
-    exit /b 1
-)
-
-pause

run.sh

@@ -1,51 +0,0 @@
-#!/bin/bash
-
-PROJECT_DIR=$(cd "$(dirname "$0")"; pwd)
-VENV_DIR="$PROJECT_DIR/.venv"
-FLASK_APP="app:app"
-
-
-echo "Activating virtual environment..."
-
-if [ -f "$VENV_DIR/bin/activate" ]; then
-    source "$VENV_DIR/bin/activate"
-else
-    echo "Creating new virtual environment..."
-    python3 -m venv "$VENV_DIR"
-    source "$VENV_DIR/bin/activate"
-fi
-
-if [ -z "$VIRTUAL_ENV" ]; then
-    echo "Error: Failed to activate virtual environment"
-    exit 1
-fi
-
-echo "Installing dependencies..."
-pip install --upgrade pip
-pip install -r requirements.txt
-pip install gunicorn
-
-echo "Reading port from configuration..."
-
-PORT=$(python3 -c \
-"
-from src.file_store_api import ConfigManager
-try:
-    config = ConfigManager().load_config()
-    port = config.get('app', {}).get('list_port')
-    print(str(port) if port else '')
-except Exception as e:
-    print('ERROR: ' + str(e))
-    exit(1)
-")
-
-if [[ "$PORT" == ERROR:* ]] || [ -z "$PORT" ]; then
-    echo "Failed to get port from config: $PORT"
-    echo "Using default port 25580"
-    PORT=25580
-fi
-
-echo "Starting rebot server..."
-echo "Listening on port: $PORT"
-
-gunicorn -w 4 -b 0.0.0.0:$PORT "$FLASK_APP" --access-logfile - --error-logfile -

src/mainprocess.py

@@ -1,79 +0,0 @@
-import sys
-import src.modules.user_modules as usermod
-from src.modules.plugin_modules import BasePlugin, MessageContext
-import src.file_store_api as file_M
-import src.plugin_manager as plm
-
-manager = plm.PluginManager()
-config = file_M.ConfigManager()
-rebot_id = config.load_config().get("rebot").get("id")
-def process_message(uid: str, gid: str | None, message: str) -> str:
-    # 创建上下文
-    ctx = MessageContext(uid=uid, gid=gid, raw_message=message,id = rebot_id)
-    
-    plugin_manager = manager
-    manager.scan_plugins()
-    # 阶段1: before_load 插件（加载数据前）
-    ctx.phase = "before_load"
-    early_plugins = []
-    for name, plugin_cls in plugin_manager._plugins.items():
-        plugin = plugin_cls(ctx)
-        if hasattr(plugin, 'before_load') and callable(plugin.before_load):
-            early_plugins.append(plugin)
-    
-    for plugin in early_plugins:
-        try:
-            result = plugin.before_load()
-            if result is not None:  # 拦截逻辑
-                return result
-        except Exception as e:
-            print(f"error:Plugin {plugin.__class__.__name__} before_load error: {str(e)}")
-    
-    # 消息加载逻辑
-    if gid is not None:
-        ctx.group.messages = ctx.chat_manager.load_group_messages(ctx.group)
-        ctx.user.messages = ctx.chat_manager.load_user_group_messages(user=ctx.user, group=ctx.group)
-    else:
-        ctx.user.messages = ctx.chat_manager.load_private_messages(ctx.user)
-        
-    # 阶段2: after_load 插件（加载数据后）
-    ctx.phase = "after_load"
-    loaded_plugins = []
-    for name, plugin_cls in plugin_manager._plugins.items():
-        plugin = plugin_cls(ctx)
-        if hasattr(plugin, 'after_load') and callable(plugin.after_load):
-            loaded_plugins.append(plugin)
-    
-    for plugin in loaded_plugins:
-        try:
-            result = plugin.after_load()
-            if result is not None:
-                ctx.response = result
-                break
-        except Exception as e:
-            print(f"error:Plugin {plugin.__class__.__name__} after_load error: {str(e)}")
-    
-    # 消息保存逻辑
-    if gid is not None:
-        ctx.chat_manager.save_group_message(ctx.group, role="user", content=ctx.raw_message, sender_id=ctx.user.user_id)
-    else:
-        ctx.chat_manager.save_private_message(ctx.user, role="user", content=ctx.raw_message)
-
-    # 阶段3: after_save 插件（保存数据后）
-    ctx.phase = "after_save"
-    saved_plugins = []
-    for name, plugin_cls in plugin_manager._plugins.items():
-        plugin = plugin_cls(ctx)
-        if hasattr(plugin, 'after_save') and callable(plugin.after_save):
-            saved_plugins.append(plugin)
-    
-    for plugin in saved_plugins:
-        try:
-            result = plugin.after_save()
-            if result is not None and ctx.response is None:
-                ctx.response = result
-        except Exception as e:
-            print(f"error:Plugin {plugin.__class__.__name__} after_save error: {str(e)}")
-    plugin_manager.cleanup()
-    
-    return ctx.response if ctx.response is not None else "ok"