为提高性能，改用c替换原本的flask

c/CMakeLists.txt

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.28.3)
+
+project (Onebot_back C)
+
+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_rel.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)
+
+target_link_libraries(Start_Onebot_back Network Swmem Interpre Log Toml)
+
+include_directories(${PROJECT_SOURCE_DIR})

c/interpreter/interpreter.c

@@ -0,0 +1,196 @@
+#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 init_interpreter(Cmd *cmd_dic,ctx *self,int fifo[2])
+{
+    printf("SYS:prepare env\n");
+    printf("SYS:env ready\n");
+    printf("SYS:loading cmd_dic\n");
+    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");
+
+    for(int i =0;i<10;i++)
+    {
+        self->space_index[i] = 0;
+    }
+    self->arg = NULL;
+    printf("SYS:Creating ctl fifo\n");
+    memcpy(self->fifofd,fifo,2*sizeof(int));
+    
+}
+
+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");
+                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 exce(const int command,ctx *all_ctx)
+{
+
+    switch (command)
+    {
+    case BAD_INPUT:
+        printf("SYS:bad input,try again\n");
+        return BAD_INPUT;
+
+    case INSTALL:
+        if(all_ctx->arg == NULL){
+            printf("SYS:Missing args\n");
+            return 1;
+        }
+        printf("SYS:init pkgmanager\n");
+        pkger *manager = init_pkginstaller();
+        printf("SYS:installing\n");
+        manager->packup(manager);
+        return 1;
+
+    case RUN:
+        printf("runing\n");
+        return 1;
+        
+    case QUIT:
+        printf("shuting down\n");
+        all_ctx->statue = -1;
+        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(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';
+        //执行命令
+        exce(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)
+    {
+    }
+}

c/interpreter/interpreter.h

@@ -0,0 +1,49 @@
+#ifndef INTERPRETER
+#define INTERPRETER
+
+#define MAX_BUF 256
+
+#define SIG_MOD 0
+#define FILE_MOD 1
+
+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[MAX_BUF];//当前行缓存
+    int statue;//当前状态
+    int fifofd[2];
+}ctx;//上下文管理
+
+
+int interpret(int mod, ctx *all_ctx,Cmd *cmd_dic);
+int init_interpreter(Cmd *cmd_dic,ctx *self,int fifo[2]);
+
+#define ARG_LENGTH 256
+
+#endif

c/main.c

@@ -0,0 +1,58 @@
+#include "tem/ctl.h"
+#include "network/network.h"
+#include "tools/toml/toml.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);
+
+    Ctl *teml = init_tem(logsmanager);
+    //初始化终端对象
+    int fifo[2];
+    if(pipe(fifo)==-1)
+        perror("ERROR ");
+    netm *networkmanager = (netm*)malloc(sizeof(netm));
+    init_networkmanager(networkmanager,fifo,logsmanager,port);
+    //初始化网络管理器对象
+    pthread_t network_id;
+    pthread_create(&network_id,NULL,networkmanager->run_network,(void*)networkmanager);
+    //启动网络监听与线程池，并加载插件
+    teml->run(teml,fifo);
+    //启动终端
+    pthread_join(network_id,NULL);
+    //等待网络管理器进程结束
+
+    free(teml);
+    free(networkmanager);
+    free(logsmanager);
+    //释放内存
+    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/http_rel.c

@@ -0,0 +1,24 @@
+#include <stddef.h>
+#include <string.h>
+#include "http_rel.h"
+
+const char *http_get_body(const char *buf)
+{
+    if (!buf) return NULL;
+
+    /* 找到 header 与 body 之间的空行 "\r\n\r\n" */
+    const char *sep = strstr(buf, "\r\n\r\n");
+    if (!sep) return NULL;          /* 格式错误 */
+
+    const char *body = sep + 4;     /* 跳过 "\r\n\r\n" */
+
+    /* 简单判断：如果后面还有数据，就认为是 body */
+    if (*body == '\0') return NULL; /* 没有 body */
+
+    return body;
+}
+
+const char *resave_http(int fd)
+{
+    
+}

c/network/http_rel.h

@@ -0,0 +1,6 @@
+#ifndef HTTP_REL
+#define HTTP_REL
+
+const char *http_get_body(const char *buf);
+
+#endif

c/network/network.c

@@ -0,0 +1,251 @@
+#define _GNU_SOURCE 
+
+#include "network.h"
+#include "swap.h"
+#include "http_rel.h"
+#include "cJSON.h"
+#include "tools/log/log.h"
+#include <semaphore.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stddef.h>
+#include <errno.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/epoll.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;   // 成功
+}
+
+int init_network(int port)
+{
+    int fd = socket(AF_INET, SOCK_STREAM, 0);
+    struct sockaddr_in addr = {0};
+    addr.sin_family      = AF_INET;      // 和 socket() 一致
+    addr.sin_port        = htons(port); // 端口号必须网络字节序
+    addr.sin_addr.s_addr = htonl(INADDR_ANY); // 0.0.0.0：本机所有网卡
+    bind(fd, (struct sockaddr *)&addr, sizeof(addr));
+    return fd;
+}
+
+ssize_t read_req(int fd, void *buf)
+{
+    ssize_t n = read(fd, buf, MAX_MESSAGE_BUF);
+    if (n == 0)              /* 写端已关闭，管道永不会再有数据 */
+        return -1;
+    return (n > 0) ? n : -1;
+}
+
+int process_message(char *req,log_manager *logger)
+{
+    const char *body = http_get_body(req);
+    rbt_msg message;
+    rbt_parse_json(body,&message);
+    make_swap((void*)&message);
+    logs *log = malloc(sizeof log);
+    if(snprintf(log->log,sizeof(log->log),
+        "%s message %s processd ok\n",message.nickname,message.raw_message)<1024);
+    logger->in_log(log,logger);
+}
+
+int iss_work(netm *self,char *command)
+{
+    int i = self->last_alc+1;
+    //查询空闲线程
+    while(self->pool[i].fifo_fd ==0)
+    {
+        if(i<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)
+{
+    args *argms = (args*)args_p;
+    pth_m *pmd = argms->pth;
+    log_manager *logger = argms->log;
+    //参数解析
+    char name[256] = {'\0'};
+    sprintf(name,"chatrebot%lu",pmd->pthread_id);
+    int swap = create_swap(name);
+    //创建共享内存
+    char swap_arg[64] = {'\0'};
+    sprintf(swap_arg,"%d",swap);
+    pid_t id = fork();
+    if(id == 0)
+    {
+        char *args[]={
+            "Pluginmanager",
+            "--swap",swap_arg,
+        NULL};
+        execv("Run_pluhginmanager",args);
+    }
+    //拉起python插件管理器
+    for(;;){
+        //线程池中，单个线程模型
+
+        char req[64*1024];
+        //从管道中读取请求，并解析，无内容时休眠
+        int n = read_req(pmd->fifo_fd[0],req);
+        //管道关闭时退出;
+
+        if (n == EOF) {
+            return NULL;
+            break;
+        }
+        else{
+            process_message(req,logger);
+            atomic_fetch_add(&pmd->status, 1);
+        }
+    }
+}
+
+int start_pool(netm  *self)
+{
+    for(int i = 0;i<MAX_POOL;i++)
+    {
+        //为线程开辟管道
+        pipe(self->pool[i].fifo_fd);
+        //启动线程
+        args arg;
+        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<MAX_POOL;i++)
+    {
+        close(self->pool[i].fifo_fd[0]);
+    }
+}
+
+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);
+    }
+    char iss_buf[256];
+    int http_fd = init_network(port);
+    struct epoll_event events;
+    for(;;)
+    {
+        int nf = epoll_wait(epfd,&events,1,-1);
+        if (nf == -1) { 
+            perror("epoll_wait"); 
+            break; 
+        }
+        if(events.data.fd ==http_fd)
+        {
+            sprintf(iss_buf,"s/%d/e",accept4(http_fd,NULL,NULL,SOCK_NONBLOCK | SOCK_CLOEXEC));
+            self->iss_work(self,iss_buf);
+        }
+        if(events.data.fd == fifo_fd)
+        {
+            char command;
+            while(read(fifo_fd,&command,1)==1)
+            {
+                switch(command){
+                    case 'q':
+                    //退出逻辑
+                        break;
+                    case 'u':
+                    //插件更新逻辑
+                        break;
+                }
+            }
+        }
+    }
+}
+
+void *run_network(void *self_d)
+{
+    netm *self = (netm*)self_d;
+    self->start_pool(self);
+    server_run(self->port,self->fifo_fd[1],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->logmanager = logmanager;
+    self->port = port;
+}

c/network/network.h

@@ -0,0 +1,49 @@
+#ifndef NETWORK
+#define NETWORK
+
+#define MAX_POOL 24
+#define MAX_MESSAGE_BUF 10240
+#include <pthread.h>
+#include<tools/log/log.h>
+#include <stdatomic.h>
+//单个线程模型
+typedef struct pthread_module
+{
+    pthread_t pthread_id;
+    int fifo_fd[2];
+    atomic_int status;
+}pth_m;
+
+typedef struct args
+{
+    log_manager *log;
+    pth_m *pth;
+}args;
+
+typedef struct network_manager
+{
+    void *(*run_network)(void*);
+    int (*start_pool)(struct network_manager*);
+    int (*shutdown_pool)(struct network_manager*);
+    int (*iss_work)(struct network_manager*,char *);
+    pth_m pool[MAX_POOL];
+    int fifo_fd[2];
+    log_manager *logmanager;
+    int last_alc;
+    int port;
+}netm;
+
+typedef struct rebot_message
+{
+    char gid[32];
+    char uid[32];
+    char nickname[64];
+    char raw_message[MAX_MESSAGE_BUF];
+    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,34 @@
+#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 "network.h"
+
+int make_swap(void *message)
+{
+    rbt_msg *msg = (rbt_msg*)message;
+            printf("gid=%s uid=%s nick=%s raw=%s type=%c\n",
+               msg->gid, msg->uid, msg->nickname,
+               msg->raw_message, msg->message_type);
+}
+
+int create_swap(const char *name)
+{
+   int fd = memfd_create(name,0);
+   //申请共享内存
+   ftruncate(fd, sizeof(rbt_msg));
+   //调整大小
+   rbt_msg *init_msg = (rbt_msg*)mmap(NULL, sizeof(rbt_msg), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
+   char buf[MAX_MESSAGE_BUF] = {'\0'};
+   memcpy(init_msg->raw_message,buf,MAX_MESSAGE_BUF);
+   memcpy(init_msg->nickname,buf,64);
+   munmap((void*)init_msg,sizeof(rbt_msg));
+   //初始化
+   return fd;
+}

c/network/swap.h

@@ -0,0 +1,7 @@
+#ifndef SWAP
+#define SWAP
+
+int make_swap(void *);
+int create_swap(const char *name);
+
+#endif

c/run_pluginmanager/run_pluginmanager.c

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

c/tem/ctl.c

@@ -0,0 +1,280 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stddef.h>
+#include <string.h>
+#include <termios.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);
+    }
+}
+
+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 = HISTORY_BUF-1;
+
+    }
+    else if(toward == 0)
+    {
+        if(*currant_index <HISTORY_BUF-1)
+            (*currant_index)++;
+        else
+            *currant_index = 0;
+    }
+
+    if(self->history[*currant_index] == NULL){
+        *length = *length-2;
+        return 0;
+    }
+    replace_chars(sizeof(PROMPT)-1,*length,self->history[*currant_index]);
+    memcpy(buf,self->history[*currant_index],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(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(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<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(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(PROMPT)+length)
+                            {
+                                break;
+                            }
+                            write(STDOUT_FILENO, "\x1b[C", 3);
+                            break;
+                        case 0x44:
+                            get_cursor(&cursor_index);
+                            length = length -2;
+                            if(cursor_index == sizeof(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>=MAX_BUF)
+    {
+        perror("SYS:input pass edge");
+    }
+
+}
+
+int infifo(Ctl *self,const char *cmd)
+{
+    if(self->history[self->index]!=NULL){
+        memcpy(self->history[self->index],cmd,MAX_BUF);
+    }
+    else{
+        self->history[self->index] = (char*)malloc(MAX_BUF*sizeof(char));
+        memcpy(self->history[self->index],cmd,MAX_BUF);
+    }
+    //存储命令历史s
+    if(self->index<HISTORY_BUF){
+        self->index++;
+    }
+    else{
+        self->index = 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[MAX_BUF] = {'\0'};
+    ctx *command = (ctx*)malloc(sizeof(ctx));
+    Cmd cmd_dir[10];
+    init_interpreter(cmd_dir,command,fifo);//初始化解释器
+    //创建线程用于定期清理日志
+    pthread_create(&self->logwathcher,NULL,self->logmanager->clear_log,self->logmanager);
+    command->statue = 0;
+    do
+    {   //设置缓冲区，接收用户输入
+        write(STDOUT_FILENO,PROMPT,sizeof(PROMPT));
+        command->line = read_line(input,self);
+        if(command->line == -1)
+            perror("sys error");
+        //将用户输入入队
+        infifo(self,input);
+        memcpy(command->command,input,sizeof(input));        
+        interpret(SIG_MOD,command,cmd_dir);
+        const char fexp[256] = {'\0'};
+        memcpy(&input,&fexp,MAX_BUF);
+    }while(command->statue == 0);
+    close(fifo[0]);
+    close(fifo[1]);
+    free_history(self);
+    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;
+    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,24 @@
+#ifndef CTL
+#define CTL
+
+#include <pthread.h>
+#include "tools/log/log.h"
+
+#define MAX_BUF 256
+#define HISTORY_BUF 256
+#define PROMPT "chatbot$$ "
+
+
+typedef struct Ctl
+{
+    int (*run)(struct Ctl*,int *);
+    int (*infifo)(struct Ctl*,const char*);
+    int index;
+    char *history[HISTORY_BUF];
+    pthread_t logwathcher;
+    log_manager *logmanager;
+}Ctl;
+
+Ctl *init_tem(log_manager *logmanager);
+
+#endif

c/tools/log/log.c

@@ -0,0 +1,73 @@
+#include "log.h"
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+int in_log(logs *log,log_manager *self)
+{
+    sem_wait(&self->log_sem);//加锁
+    logs *buf = self->rear;
+    if(self->log == NULL){
+        self->log = log;
+        self->rear = log;
+        return 0;
+    }
+    self->count++;
+    buf->next = log;
+    log->next = NULL;
+    self->rear = log;
+    sem_post(&self->log_sem);
+    return self->count;
+}
+
+logs *out_log(log_manager *self)
+{
+    sem_wait(&self->log_sem);
+    logs *buf = self->log;
+    if(self->log->next ==NULL)
+        self->log = self->rear = NULL;
+    self->count--;
+    sem_post(&self->log_sem);
+    buf->next =NULL;
+    return buf;
+}
+
+//定期清理函数
+void *clear_log(void *self_p)
+{
+    log_manager *self = (log_manager*)self_p;
+    for(;;)
+    {
+        sleep(1000);
+        sem_wait(&self->log_sem);
+        if(self->count<256){
+            sem_post(&self->log_sem);
+            continue;
+        }
+        logs* buf = self->log;
+        self->log = self->rear =NULL;
+        sem_post(&self->log_sem);
+        logs* tobeclear;
+        while(buf->next !=NULL)
+        {
+            tobeclear = buf;
+            buf = buf->next;
+            free(tobeclear);
+        }
+    }
+}
+
+int init_loger(log_manager *self)
+{
+    if(self == NULL)
+    {
+        perror("NULL\n");
+        return -1;
+    }
+    sem_init(&self->log_sem, 0,1);
+    self->in_log = in_log;
+    self->out_log = out_log;
+    self->clear_log = clear_log;
+    self->log = NULL;
+}

c/tools/log/log.h

@@ -0,0 +1,27 @@
+#ifndef LOG
+#define LOG
+
+#include <semaphore.h>
+
+#define MAX_LOG 256
+
+typedef struct logs
+{
+    char log[1024];
+    struct logs *next;
+}logs;
+
+typedef struct log_manager
+{
+    int (*in_log)(logs *,struct log_manager*);
+    logs* (*out_log)(struct log_manager*);
+    void *(*clear_log)(void*);
+    sem_t log_sem;
+    logs *log;
+    logs *rear;
+    int count;
+}log_manager;
+
+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,7 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+void *quit_all(void *self_d)
+{
+
+}

c/tools/quit/quit.h

@@ -0,0 +1,6 @@
+#ifndef QUIT
+#define QUIT
+
+void *quitall(int status,void *arg);
+
+#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 */