diff --git a/build/build.sh b/build/build.sh index 178e2e7ab459179d336fde0a09d341a21d46d6f4..8689b67e8481bdf4bda44b647b884297ebe98769 100755 --- a/build/build.sh +++ b/build/build.sh @@ -12,7 +12,7 @@ BPFTOOL_FOLDER=${PROJECT_FOLDER}/src/probes/extends/ebpf.probe/tools VMLINUX_DIR=${PROJECT_FOLDER}/src/probes/extends/ebpf.probe/src/include EXT_PROBE_BUILD_LIST=`find ${EXT_PROBE_FOLDER} -maxdepth 2 | grep "\"` DEP_LIST=(cmake git librdkafka-devel libmicrohttpd-devel libconfig-devel uthash-devel log4cplus-devel\ - libbpf-devel clang llvm java-1.8.0-openjdk-devel cjson-devel gnutls-devel libcurl-devel) + libbpf-devel clang llvm java-1.8.0-openjdk-devel jsoncpp-devel gnutls-devel libcurl-devel) PROBES_LIST="" PROBES_C_LIST="" PROBES_META_LIST="" diff --git a/gala-gopher.spec b/gala-gopher.spec index eb6ba84e20acca0cda56c7da06805f51f80e94f0..4737d6a88b95d3d8cf33be63530decae2b330de3 100644 --- a/gala-gopher.spec +++ b/gala-gopher.spec @@ -35,7 +35,7 @@ BuildRoot: %{_builddir}/%{name}-%{version} BuildRequires: systemd cmake gcc-c++ elfutils-devel (clang >= 10.0.1 or clang12) llvm BuildRequires: libconfig-devel librdkafka-devel libmicrohttpd-devel BuildRequires: libbpf-devel >= 2:0.3 uthash-devel log4cplus-devel -BuildRequires: cjson-devel gnutls-devel git +BuildRequires: jsoncpp-devel gnutls-devel git %if !0%{?without_flamegraph} BuildRequires: libcurl-devel %endif @@ -43,12 +43,12 @@ BuildRequires: libcurl-devel BuildRequires: java-1.8.0-openjdk-devel %endif %if !0%{?without_l7} -BuildRequires: cjson-devel java-1.8.0-openjdk-devel +BuildRequires: jsoncpp-devel java-1.8.0-openjdk-devel %endif Requires: bash glibc elfutils bpftool libbpf >= 2:0.3 Requires: log4cplus librdkafka libmicrohttpd libconfig -Requires: iproute cjson gnutls +Requires: iproute jsoncpp gnutls %if !0%{?without_systeminfo} Requires: ethtool systemd iproute %endif @@ -77,7 +77,7 @@ Requires: iproute Requires: iproute %endif %if !0%{?without_l7} -Requires: cjson conntrack-tools +Requires: jsoncpp conntrack-tools %endif %if !0%{?without_tprofiling} Requires: lsof diff --git a/src/common/json_tool.cpp b/src/common/json_tool.cpp new file mode 100644 index 0000000000000000000000000000000000000000..8473fc80c24930d5c25bb6efc5b0fca1762eaf5e --- /dev/null +++ b/src/common/json_tool.cpp @@ -0,0 +1,278 @@ +#include "json_tool.h" +#include +#include +#include +#include +#include + +using std::string; + +/*** + * this root point ptr should release, after use. +***/ +void* Json_Parse(const char *probe_content) +{ + Json::Reader reader; + auto *root = new Json::Value(); + std::string str(probe_content); + if (reader.parse(str, *root)) { + return (void*)(root); + } else { + return nullptr; + } +} + +void *Json_GetObjectItem(const void *jsonObj, const char *keyStr) +{ + if (!jsonObj) { + return nullptr; + } + const std::string &keyString = std::string(keyStr); + auto *jsObj = static_cast(jsonObj); + if (jsObj->isMember(keyString)) { + return (void*)&((*jsObj)[keyString]); + } else { + return nullptr; + } +} + +unsigned char Json_IsObjString(const void *jsonObj) +{ + auto *jsObj = static_cast(jsonObj); + bool ret = jsObj->isString(); + return ret; +} + +unsigned char Json_IsObjNumeric(const void *jsonObj) +{ + auto *jsObj = static_cast(jsonObj); + bool ret = jsObj->isNumeric(); + return ret; +} + +unsigned char Json_IsObject(const void *jsonObj) +{ + auto *jsObj = static_cast(jsonObj); + bool ret = jsObj->isObject(); + return ret; +} + +unsigned char Json_IsArray(const void *jsonObj) +{ + auto *jsObj = static_cast(jsonObj); + bool ret = jsObj->isArray(); + return ret; +} + +int Json_Type(const void *jsonObj) +{ + auto *jsObj = static_cast(jsonObj); + int type = static_cast(jsObj->type()); + if (type == Json::ValueType::stringValue) { + return Json_String; + } else if (type == Json::ValueType::arrayValue) { + return Json_Array; + } else if ((type == Json::ValueType::intValue) | (type == Json::ValueType::uintValue) | + (type == Json::ValueType::realValue) | (type == Json::ValueType::booleanValue)) { + return Json_Number; + } else { + return Json_Other; + } +} + +unsigned char Json_IsEmptyString(const void *jsonObj) +{ + auto *jsObj = static_cast(jsonObj); + const std::string strValue = jsObj->asString(); + return !strValue.empty(); +} + +const char *Json_GetListValueString(const void *jsonObj) +{ + auto *jsObj = static_cast(jsonObj); + const char *begin; + const char *end; + jsObj->getString(&begin, &end); + return begin; +} + +const char *Json_GetKeyValueString(const void *jsonObj) +{ + auto *jsObj = static_cast(jsonObj); + const Json::Value *value; + const auto &members = jsObj->getMemberNames(); + for (const auto & nameKey : members) { + value = &(*jsObj)[nameKey]; + } + const char *begin; + const char *end; + value->getString(&begin, &end); + return begin; +} + +char *Json_GetKeyString(const void *jsonObj) +{ + auto *jsObj = static_cast(jsonObj); + const char *value; + const auto &members = jsObj->getMemberNames(); + for (const auto & nameKey : members) { + value = nameKey.c_str(); + } + char *ret = (char *)malloc(sizeof(value)); + if (ret == nullptr) { + return nullptr; + } + strcpy(ret, value); + return ret; +} + +unsigned int Json_GetArraySize(const void *jsonObj) +{ + auto *jsObj = static_cast(jsonObj); + return jsObj->size(); +} + +void *Json_GetArrayItem(const void *jsonObj, int i) +{ + auto *jsObj = static_cast(jsonObj); + if (!jsObj->isArray()) { + return nullptr; + } + return (void*)(&(*jsObj)[i]); +} + +int Json_GetArrayItemMethod2(const void *jsonObj, void **ret, int i) +{ + auto *newObj = new Json::Value(); // should delete in function out. + auto *jsObj = static_cast(jsonObj); + if (jsObj->isArray()) { + (*newObj) = (*jsObj)[i]; + *ret = (void*)(newObj); + } else if (jsObj->isObject()) { + const auto &numKeyNameVec = jsObj->getMemberNames(); + if (i > numKeyNameVec.size() - 1) { + return i; + } + const auto &nameSelectedKey = numKeyNameVec[i]; + (*newObj)[nameSelectedKey] = (*jsObj)[nameSelectedKey]; + *ret = (void*)(newObj); + } else { + return -1; // will break to for loop + } + return i; +} + +int Json_GetValueInt(const void *jsonObj) +{ + auto *jsObj = static_cast(jsonObj); + return jsObj->asInt(); +} + +void *Json_CreateArray() +{ + auto *root = new Json::Value(); + return (void *)root; +} + +void *Json_CreateObject() +{ + auto *root = new Json::Value(); + return (void *)root; +} + +void* Json_AddStringToObject(void *jsonObj, const char *nameCStr, const char *valCStr) +{ + const std::string &nameStr = std::string(nameCStr); + const std::string &valueStr = std::string(valCStr); + auto *jsObj = static_cast(jsonObj); + (*jsObj)[nameStr] = valueStr; + return (void*)jsObj; +} + +void* Json_AddItemToArray(void *jsonObj, void *item, unsigned char freeItem) +{ + auto *jsObj = static_cast(jsonObj); + auto *itemObj = static_cast(item); + jsObj->append((*itemObj)); + if (freeItem) { + delete itemObj; + } + return (void*)jsObj; +} + +void* Json_AddStringItemToArray(void *jsonObj, const char *valCStr) +{ + const std::string &valueStr = std::string(valCStr); + auto *jsObj = static_cast(jsonObj); + jsObj->append(valueStr); + return (void*)jsObj; +} + +void* Json_AddIntItemToArray(void *jsonObj, int valInt) +{ + auto *jsObj = static_cast(jsonObj); + jsObj->append(valInt); + return (void*)jsObj; +} + +void* Json_AddUIntItemToArray(void *jsonObj, unsigned int valInt) +{ + auto *jsObj = static_cast(jsonObj); + jsObj->append(valInt); + return (void*)jsObj; +} + +void* Json_AddNumberToObject(void *jsonObj, const char *nameCStr, double valDouble) +{ + auto *jsObj = static_cast(jsonObj); + const std::string &nameStr = std::string(nameCStr); + (*jsObj)[nameStr] = valDouble; + return (void*)jsObj; +} + +void* Json_AddUIntItemToObject(void *jsonObj, const char *nameCStr, unsigned int valInt) +{ + auto *jsObj = static_cast(jsonObj); + const std::string &nameStr = std::string(nameCStr); + (*jsObj)[nameStr] = valInt; + return (void*)jsObj; +} + +void* Json_AddCharItemToObject(void *jsonObj, const char *nameCStr, char valChar) +{ + auto *jsObj = static_cast(jsonObj); + const std::string &nameStr = std::string(nameCStr); + (*jsObj)[nameStr] = valChar; + return (void*)jsObj; +} + +void* Json_AddItemToObject(void *jsonObj, const char *nameCStr, void *item, unsigned char freeItem) +{ + const std::string &nameStr = std::string(nameCStr); + auto *jsObj = static_cast(jsonObj); + auto *itemObj = static_cast(item); + (*jsObj)[nameStr] = (*itemObj); + if (freeItem) { + delete itemObj; + } + return (void*)jsObj; +} + +unsigned char Json_Delete(void *jsonObj) +{ + auto *jsObj = static_cast(jsonObj); + if (!jsObj) { + return 0; // do not need to delete + } + delete jsObj; + return 1; // delete success +} + +char *Json_PrintUnformatted(void *jsonObj) +{ + auto *jsObj = static_cast(jsonObj); + Json::FastWriter writer; + std::string strJson = writer.write(*jsObj); + char *res = strdup(strJson.c_str()); + return res; +} \ No newline at end of file diff --git a/src/common/json_tool.h b/src/common/json_tool.h new file mode 100644 index 0000000000000000000000000000000000000000..089bad6bcdb2a612f35770343a49074364e2e0eb --- /dev/null +++ b/src/common/json_tool.h @@ -0,0 +1,118 @@ +/****************************************************************************** + * Copyright (c) Huawei Technologies Co., Ltd. 2022. All rights reserved. + * gala-gopher licensed under the Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR + * PURPOSE. + * See the Mulan PSL v2 for more details. + * Author: yangyongguang + * Create: 2023-10-13 + * Description: gopher json tool + ******************************************************************************/ + +#ifndef GOPHER_JSON_TOOL_H +#define GOPHER_JSON_TOOL_H + +#ifdef __cplusplus +extern "C" { +#endif + +#define Json_Other (1 << 0) +#define Json_Number (1 << 1) +#define Json_String (1 << 2) +#define Json_Array (1 << 3) + +void* Json_Parse(const char *probe_content); +void *Json_GetObjectItem(const void *jsonObj, const char *keyStr); + +/* string relative */ +unsigned char Json_IsEmptyString(const void *jsonObj); +const char *Json_GetListValueString(const void *jsonObj); +const char *Json_GetKeyValueString(const void *jsonObj); +char *Json_GetKeyString(const void *jsonObj); + + +/* array relative */ +unsigned int Json_GetArraySize(const void *jsonObj); +void *Json_GetArrayItem(const void *jsonObj, int i); +int Json_GetArrayItemMethod2(const void *jsonObj, void **ret, int i); + +/* type function */ +unsigned char Json_IsObjString(const void *jsonObj); +unsigned char Json_IsObjNumeric(const void *jsonObj); +unsigned char Json_IsObject(const void *jsonObj); +unsigned char Json_IsArray(const void *jsonObj); + +/*** + * compare type c json and cpp json value type + JSON_Number + JSON_Array + JSON_String + ***/ +unsigned char Json_IsTypeEqual(const void *jsonObj); + +/*** + * brief return Number, Array, String, Other. + ***/ +int Json_Type(const void *jsonObj); + +/* get value */ +int Json_GetValueInt(const void *jsonObj); + +/*** + * write json data relative +***/ +/* as the same as create object */ +void* Json_CreateArray(); + +void* Json_CreateObject(); + +void* Json_AddStringToObject(void *jsonObj, const char *nameCStr, const char *valCStr); + +void* Json_AddItemToArray(void *jsonObj, void *item, unsigned char freeItem); + +void* Json_AddStringItemToArray(void *jsonObj, const char *valCStr); + +void* Json_AddIntItemToArray(void *jsonObj, int valInt); + +void* Json_AddUIntItemToArray(void *jsonObj, unsigned int valInt); + +void* Json_AddNumberToObject(void *jsonObj, const char *nameCStr, double valDouble); + +void* Json_AddUIntItemToObject(void *jsonObj, const char *nameCStr, unsigned int valInt); + +void* Json_AddCharItemToObject(void *jsonObj, const char *nameCStr, char valChar); + +/*** + * if freeItem is true, free item mem, if not need free by manual. + ***/ +void* Json_AddItemToObject(void *jsonObj, const char *nameCStr, void *item, unsigned char freeItem); + +/*** + * json mem delete + ***/ + unsigned char Json_Delete(void *jsonObj); + +/*** special function ***/ +/*** + * For each function for iter object or array of which has at least one element. + * element is new object, so it should be release by hand, using Json_Delete function. + ***/ +#define Json_ArrayForEach(element, array) for (int value_idx = Json_GetArrayItemMethod2(array, \ +element, 0); (value_idx < Json_GetArraySize(array)) && (value_idx >= 0); ++value_idx, Json_GetArrayItemMethod2(array,\ +element, value_idx)) + +#define Json_AddKeyValToObject(jsObj, nameCStr, val) do {} + +char *Json_PrintUnformatted(void *jsonObj); + + + +#ifdef __cplusplus +} +#endif + +#endif // GOPHER_JSON_TOOL_H \ No newline at end of file diff --git a/src/common/logs.cpp b/src/common/logs.cpp index 8c76648c2ba69808a34908e640447bf5551a1a66..d957d92383b3b55e21d6aeb365d9b1cabefb5951 100644 --- a/src/common/logs.cpp +++ b/src/common/logs.cpp @@ -30,7 +30,6 @@ #define IS_VALID_FILE_ID(id) ((id) != INVALID_FILE_ID) #if !defined(UTEST) -#define METRICS_LOGS_FILESIZE_MAX (1024 * 1024 * 1024) #define METRICS_LOGS_FILESIZE (100 * 1024 * 1024) #define EVENT_LOGS_FILESIZE (100 * 1024 * 1024) #define DEBUG_LOGS_FILESIZE (100 * 1024 * 1024) @@ -52,41 +51,17 @@ #define DEBUG_LOGS_FILE_NAME "gopher_debug.log" #define META_LOGS_FILE_NAME "gopher_meta.log" -#define RM_COMMAND "/usr/bin/rm -rf %s && /usr/bin/rm -rf %s.1" -#define RM_DIR_COMMAND "/usr/bin/rm -rf %s" +#define RM_COMMAND "/usr/bin/rm -rf %s" static struct log_mgr_s *local = NULL; -// RollingFileAppender may generate a backup file with the suffix ".1" (even if maxBackupIndex is set to 0), -// which needs to be deleted together. void rm_log_file(char full_path[]) { FILE *fp = NULL; char command[COMMAND_LEN]; - if (full_path == NULL || full_path[0] == 0) { - return; - } command[0] = 0; - (void)snprintf(command, COMMAND_LEN, RM_COMMAND, full_path, full_path); - fp = popen(command, "r"); - if (fp != NULL) { - (void)pclose(fp); - fp = NULL; - } - return; -} - -void clear_log_dir(char full_path[]) -{ - FILE *fp = NULL; - char command[COMMAND_LEN]; - if (full_path == NULL || full_path[0] == 0) { - return; - } - - command[0] = 0; - (void)snprintf(command, COMMAND_LEN, RM_DIR_COMMAND, full_path); + (void)snprintf(command, COMMAND_LEN, RM_COMMAND, full_path); fp = popen(command, "r"); if (fp != NULL) { (void)pclose(fp); @@ -432,7 +407,7 @@ static int append_metrics_logger(struct log_mgr_s * mgr) g_metrics_logger.removeAllAppenders(); rm_log_file(full_path); - SharedAppenderPtr append(new RollingFileAppender(full_path, mgr->metrics_logs_filesize, 1, true, true)); + SharedAppenderPtr append(new RollingFileAppender(full_path, METRICS_LOGS_FILESIZE, 1, true, true)); log4cplus::tstring pattern = LOG4CPLUS_TEXT("%m"); append->setLayout(std::unique_ptr(new log4cplus::PatternLayout(pattern))); g_metrics_logger.addAppender(append); @@ -521,19 +496,8 @@ static void set_debug_log_level(char *logLevel) int init_log_mgr(struct log_mgr_s* mgr, int is_meta_out_log, char *logLevel) { - clear_log_dir(mgr->metrics_path); init_all_logger(); - if (mgr->metrics_logs_filesize <= 0) { - mgr->metrics_logs_filesize = METRICS_LOGS_FILESIZE; - (void)fprintf(stderr, "metric_total_size is invalid. metrics_logs_filesize will reset to 100MB.\n"); - } - - if (mgr->metrics_logs_filesize > METRICS_LOGS_FILESIZE_MAX) { - mgr->metrics_logs_filesize = METRICS_LOGS_FILESIZE_MAX; - (void)fprintf(stderr, "metric_total_size is too large. metrics_logs_filesize will reset to 1GB.\n"); - } - if ((mgr->debug_path[0] != 0) && append_debug_logger(mgr)) { (void)fprintf(stderr, "Append debug logger failed.\n"); return -1; diff --git a/src/common/logs.h b/src/common/logs.h index 7c9fabaeda11b8ece47c8a5350a3e5961e67a367..bd54e51cc8ec56e487b3ba3734dee1882c3a4d37 100644 --- a/src/common/logs.h +++ b/src/common/logs.h @@ -53,7 +53,6 @@ typedef struct log_mgr_s { char is_metric_out_log; char is_event_out_log; char is_meta_out_log; - long metrics_logs_filesize; } LogsMgr; void wr_raw_logs(const char* format, ...); diff --git a/src/daemon/CMakeLists.txt b/src/daemon/CMakeLists.txt index 156e5af4ea2d87ffa24f2d218cc2c3e19a61fe97..284f88ad30b33229efd045be36d4f1bb71e5d0b9 100644 --- a/src/daemon/CMakeLists.txt +++ b/src/daemon/CMakeLists.txt @@ -41,6 +41,13 @@ SET(CMAKE_C_FLAGS "-rdynamic -std=gnu11 -g -Wl,-z,relro,-z,now -DNATIVE_PROBE_FP ) SET(CMAKE_CXX_FLAGS "-rdynamic -std=c++11 -g -Wl,-z,relro,-z,now -DNATIVE_PROBE_FPRINTF") +find_package(jsoncpp REQUIRED) +get_target_property(JSON_INC_PATH jsoncpp_lib INTERFACE_INCLUDE_DIRECTORIES) +include_directories(${JSON_INC_PATH}) +include_directories(${JSON_INC_PATH}"/json") + +link_libraries(${JSONCPP_LIBRARIES}) + SET(SOURCES main.c daemon.c ${RESOURCE_DIR}/resource.c ${CONFIG_DIR}/config.c @@ -72,6 +79,7 @@ SET(SOURCES main.c daemon.c ${COMMON_DIR}/object.c ${COMMON_DIR}/event.c ${COMMON_DIR}/logs.cpp + ${COMMON_DIR}/json_tool.cpp ${COMMON_DIR}/gopher_elf.c ${COMMON_DIR}/event_config.c ${COMMON_DIR}/kern_symb.c @@ -129,7 +137,6 @@ TARGET_INCLUDE_DIRECTORIES(${EXECUTABLE_TARGET} PRIVATE ${EBPF_PROBE_DIR}/src/include ) -TARGET_LINK_LIBRARIES(${EXECUTABLE_TARGET} PRIVATE config pthread rt dl bpf rdkafka microhttpd elf log4cplus gnutls -cjson) +TARGET_LINK_LIBRARIES(${EXECUTABLE_TARGET} PRIVATE config pthread rt dl bpf rdkafka microhttpd elf log4cplus gnutls jsoncpp_lib) diff --git a/src/lib/imdb/container_cache.c b/src/lib/imdb/container_cache.c index abf96b8f6922ced7a47fc83223681a05beead524..e127ad78e824c223934f181c45d800fc12efd700 100644 --- a/src/lib/imdb/container_cache.c +++ b/src/lib/imdb/container_cache.c @@ -14,10 +14,9 @@ ******************************************************************************/ #include -#include - #include "container.h" #include "container_cache.h" +#include "json_tool.h" #define __MAX_CACHE_POD_NUM 100 #define __MAX_CACHE_POD_LABEL_NUM 100 @@ -127,7 +126,7 @@ struct pod_cache *lkup_pod_cache(struct pod_cache *caches, const char *pod_id) static void fill_pod_info(struct pod_cache *pod_cache, const char *container_id) { char pod_labels_buf[POD_LABELS_BUF_SIZE]; - cJSON *pod_labels_json, *elem; + void *pod_labels_json, *elem; char *label_val; struct pod_label_cache *pod_label_cache; int ret; @@ -139,41 +138,43 @@ static void fill_pod_info(struct pod_cache *pod_cache, const char *container_id) return; } - pod_labels_json = cJSON_Parse(pod_labels_buf); + pod_labels_json = Json_Parse(pod_labels_buf); if (!pod_labels_json) { return; } - if (!cJSON_IsObject(pod_labels_json)) { - cJSON_free(pod_labels_json); + if (!Json_IsObject(pod_labels_json)) { + Json_Delete(pod_labels_json); return; } - cJSON_ArrayForEach(elem, pod_labels_json) { - label_val = cJSON_GetStringValue(elem); + Json_ArrayForEach(&elem, pod_labels_json) { + label_val = (char *) Json_GetKeyValueString(elem); if (!label_val) { + Json_Delete(elem); continue; } - if (strcmp(elem->string, __KW_POD_NAME) == 0) { + if (strcmp(Json_GetKeyString(elem), __KW_POD_NAME) == 0) { (void)snprintf(pod_cache->pod_name, sizeof(pod_cache->pod_name), label_val); - } else if (strcmp(elem->string, __KW_POD_NAMESPACE) == 0) { + } else if (strcmp(Json_GetKeyString(elem), __KW_POD_NAMESPACE) == 0) { (void)snprintf(pod_cache->pod_namespace, sizeof(pod_cache->pod_namespace), label_val); } pod_label_cache = (struct pod_label_cache *)calloc(1, sizeof(struct pod_label_cache)); if (!pod_label_cache) { + Json_Delete(elem); continue; } - (void)snprintf(pod_label_cache->key, sizeof(pod_label_cache->key), "%s", elem->string); + (void)snprintf(pod_label_cache->key, sizeof(pod_label_cache->key), + "%s", Json_GetKeyString(elem)); (void)snprintf(pod_label_cache->val, sizeof(pod_label_cache->val), "%s", label_val); if (H_COUNT(pod_cache->pod_labels) < __MAX_CACHE_POD_LABEL_NUM) { H_ADD_S(pod_cache->pod_labels, key, pod_label_cache); } else { free(pod_label_cache); } + Json_Delete(elem); } - - cJSON_free(pod_labels_json); - return; + Json_Delete(pod_labels_json); } struct pod_cache *create_pod_cache(struct pod_cache **caches_ptr, const char *pod_id, const char *container_id) diff --git a/src/lib/probe/probe_mng.c b/src/lib/probe/probe_mng.c index fe3e1fab6491aeedee183a431d103f2f558bf460..ec21d858642353038b65cc4afcdd47c1f32afd99 100644 --- a/src/lib/probe/probe_mng.c +++ b/src/lib/probe/probe_mng.c @@ -23,7 +23,6 @@ #include #include #include -#include #include #include #include @@ -33,6 +32,7 @@ #include "pod_mng.h" #include "snooper.h" #include "probe_params_parser.h" +#include "json_tool.h" static int set_probe_bin(struct probe_s *probe, const char *bin); @@ -626,67 +626,66 @@ static struct probe_s *get_probe_by_name(const char *probe_name) return g_probe_mng->probes[probe_type]; } -static void probe_printer_cmd(struct probe_s *probe, cJSON *json) +static void probe_printer_cmd(struct probe_s *probe, void *json) { - cJSON *range; - cJSON_AddStringToObject(json, "bin", probe->bin ? :""); - cJSON_AddStringToObject(json, "check_cmd", probe->chk_cmd ? :""); + void *range; + Json_AddStringToObject(json, "bin", probe->bin ? :""); + Json_AddStringToObject(json, "check_cmd", probe->chk_cmd ? :""); size_t size = sizeof(probe_range_define) / sizeof(struct probe_range_define_s); - range = cJSON_CreateArray(); + range = Json_CreateArray(); for (int i = 0; i < size; i++) { if (probe->probe_type == probe_range_define[i].probe_type) { if (probe->probe_range_flags & probe_range_define[i].flags) { - cJSON_AddItemToArray(range, cJSON_CreateString(probe_range_define[i].desc)); + Json_AddStringItemToArray(range, probe_range_define[i].desc); } } } - cJSON_AddItemToObject(json, "probe", range); + Json_AddItemToObject(json, "probe", range, 1); } /* {"probe":["XX","YY"]} , XX must be string but unsupported probe range will be ignored */ -static int probe_parser_range(struct probe_s *probe, const cJSON *probe_item) +static int probe_parser_range(struct probe_s *probe, void *probe_item) { int range; - cJSON *object; + void *object; probe->probe_range_flags = 0; - size_t size = cJSON_GetArraySize(probe_item); + size_t size = Json_GetArraySize(probe_item); for (int i = 0; i < size; i++) { - object = cJSON_GetArrayItem(probe_item, i); - if (object->type != cJSON_String) { + object = Json_GetArrayItem(probe_item, i); + if (!Json_IsObjString(object)) { PARSE_ERR("invalid probe range: must be string"); return -1; } - range = get_probe_range(probe->probe_type, (const char*)object->valuestring); + range = get_probe_range(probe->probe_type, (const char*) Json_GetListValueString(object)); probe->probe_range_flags |= (u32)range; } return 0; } -static int probe_parser_cmd(struct probe_s *probe, const cJSON *item) +static int probe_parser_cmd(struct probe_s *probe, const void *item) { int ret = 0; - cJSON *bin_object, *chkcmd_object, *probe_object; + void *bin_object, *chkcmd_object, *probe_object; const char *bin_string = NULL; - - bin_object = cJSON_GetObjectItem(item, "bin"); - if ((bin_object != NULL) && (bin_object->type == cJSON_String) && (bin_object->valuestring[0] != 0)) { - bin_string = (const char *)bin_object->valuestring; + bin_object = Json_GetObjectItem(item, "bin"); + if ((bin_object != NULL) && Json_IsObjString(bin_object) && Json_IsEmptyString(bin_object)) { + bin_string = (const char*) Json_GetListValueString(bin_object); if (set_probe_bin(probe, bin_string)) { return -1; } } - chkcmd_object = cJSON_GetObjectItem(item, "check_cmd"); - if ((chkcmd_object != NULL) && (chkcmd_object->type == cJSON_String)) { - set_probe_chk_cmd(probe, (const char *)chkcmd_object->valuestring); + chkcmd_object = Json_GetObjectItem(item, "check_cmd"); + if ((chkcmd_object != NULL) && (Json_IsObjString(chkcmd_object))) { + set_probe_chk_cmd(probe, (const char *) Json_GetListValueString(chkcmd_object)); } - probe_object = cJSON_GetObjectItem(item, "probe"); + probe_object = Json_GetObjectItem(item, "probe"); if (probe_object != NULL) { ret = probe_parser_range(probe, probe_object); } @@ -726,26 +725,26 @@ static void probe_rollback_cmd(struct probe_s *probe, struct probe_s *probe_back } -static int probe_parser_state(struct probe_s *probe, const cJSON *item) +static int probe_parser_state(struct probe_s *probe, const void *item) { - if (item->type != cJSON_String) { + if (Json_Type(item) != Json_String) { PARSE_ERR("invalid state: must be string"); return -1; } - if (!strcasecmp(PROBE_STATE_RUNNING, (const char *)item->valuestring)) { + if (!strcasecmp(PROBE_STATE_RUNNING, (const char *) Json_GetListValueString(item))) { return start_probe(probe); } - if (!strcasecmp(PROBE_STATE_STOPPED, (const char *)item->valuestring)) { + if (!strcasecmp(PROBE_STATE_STOPPED, (const char *)Json_GetListValueString(item))) { return stop_probe(probe); } - PARSE_ERR("invalid state %s: must be running or stopped", (const char *)item->valuestring); + PARSE_ERR("invalid state %s: must be running or stopped", (const char *)Json_GetListValueString(item)); return -1; } -static void print_state(struct probe_s *probe, cJSON *json) +static void print_state(struct probe_s *probe, void *json) { char *state; @@ -756,15 +755,15 @@ static void print_state(struct probe_s *probe, cJSON *json) } else { state = PROBE_STATE_RUNNING; } - cJSON_AddStringToObject(json, "state", state); + Json_AddStringToObject(json, "state", state); } -static int probe_parser_params(struct probe_s *probe, const cJSON *item) +static int probe_parser_params(struct probe_s *probe, const void *item) { return parse_params(probe, item); } -static void print_params(struct probe_s *probe, cJSON *json) +static void print_params(struct probe_s *probe, void *json) { probe_params_to_json(probe, json); } @@ -779,8 +778,8 @@ static void probe_rollback_params(struct probe_s *probe, struct probe_s *probe_b memcpy(&probe->probe_param, &probe_backup->probe_param, sizeof(struct probe_params)); } -typedef int (*probe_json_parser)(struct probe_s *, const cJSON *); -typedef void (*probe_json_printer)(struct probe_s *, cJSON *); +typedef int (*probe_json_parser)(struct probe_s *, const void *); +typedef void (*probe_json_printer)(struct probe_s *, void *); typedef void (*probe_backuper)(struct probe_s *, struct probe_s *); typedef void (*probe_rollbacker)(struct probe_s *, struct probe_s *); struct probe_parser_s { @@ -988,7 +987,9 @@ int parse_probe_json(const char *probe_name, const char *probe_content) u32 parse_flag = 0; struct probe_parser_s *parser; struct probe_s *probe_backup = NULL; - cJSON *json = NULL, *item; + + void *jsonObj = NULL; + void *itemObj = NULL; get_probemng_lock(); @@ -997,9 +998,9 @@ int parse_probe_json(const char *probe_name, const char *probe_content) if (probe == NULL) { goto end; } + jsonObj = Json_Parse(probe_content); - json = cJSON_Parse(probe_content); - if (json == NULL) { + if (jsonObj == NULL) { PARSE_ERR("invalid json format"); goto end; } @@ -1013,8 +1014,10 @@ int parse_probe_json(const char *probe_name, const char *probe_content) size_t size = sizeof(probe_parsers) / sizeof(struct probe_parser_s); for (int i = 0; i < size; i++) { parser = &(probe_parsers[i]); - item = cJSON_GetObjectItem(json, parser->item); - if (item == NULL) { + + itemObj = Json_GetObjectItem(jsonObj, parser->item); + + if (itemObj == NULL) { continue; } @@ -1022,7 +1025,7 @@ int parse_probe_json(const char *probe_name, const char *probe_content) if (parser->backuper) { parser->backuper(probe, probe_backup); } - ret = parser->parser(probe, item); + ret = parser->parser(probe, itemObj); if (ret) { rollback_probe(probe, probe_backup, parse_flag); break; @@ -1046,15 +1049,15 @@ int parse_probe_json(const char *probe_name, const char *probe_content) destroy_probe(probe_backup); end: put_probemng_lock(); - if (json) { - cJSON_Delete(json); + if (jsonObj) { + Json_Delete(jsonObj); } return ret; } char *get_probe_json(const char *probe_name) { - cJSON *res = NULL, *item; + void *res = NULL, *item; char *buf = NULL; struct probe_s *probe; struct probe_parser_s *parser; @@ -1066,7 +1069,7 @@ char *get_probe_json(const char *probe_name) goto end; } - res = cJSON_CreateObject(); + res = Json_CreateObject(); probe = g_probe_mng->probes[probe_type]; if (probe == NULL) { goto end; @@ -1079,17 +1082,17 @@ char *get_probe_json(const char *probe_name) if (strcmp(parser->item, "state") == 0) { parser->printer(probe, res); } else { - item = cJSON_CreateObject(); + item = Json_CreateObject(); parser->printer(probe, item); - cJSON_AddItemToObject(res, parser->item, item); + Json_AddItemToObject(res, parser->item, item, 1); } } } end: if (res) { - buf = cJSON_PrintUnformatted(res); - cJSON_Delete(res); + buf = Json_PrintUnformatted(res); + Json_Delete(res); } put_probemng_lock(); return buf; diff --git a/src/lib/probe/probe_mng.h b/src/lib/probe/probe_mng.h index d9534b6cb33ed9a37e1bf228a842e4ae45f061b1..68022032083801dc1a74765a4aaa5d7a2d0e4094 100644 --- a/src/lib/probe/probe_mng.h +++ b/src/lib/probe/probe_mng.h @@ -25,6 +25,7 @@ #include "ext_label.h" #include "args.h" +#include "json_tool.h" #define PROBE_FLAGS_STARTED 0x00000001 // probe has been tried to start by user #define PROBE_FLAGS_STOPPED 0x00000002 // probe is in stopped state diff --git a/src/lib/probe/probe_params_parser.c b/src/lib/probe/probe_params_parser.c index 53948357d70f1ef2734baf5e18ca516b143a2541..c16be2a920cd55923340adcecf8a10518672a0b0 100644 --- a/src/lib/probe/probe_params_parser.c +++ b/src/lib/probe/probe_params_parser.c @@ -18,7 +18,6 @@ #include #include - #include "args.h" #include "probe_mng.h" #include "probe_params_parser.h" @@ -60,7 +59,7 @@ static int __get_params_flags(struct param_flags_s param_flags[], size_t size, c } struct param_key_s; struct param_val_s; -typedef int (*parser_param_key)(struct probe_s *, struct param_key_s *, const cJSON *); +typedef int (*parser_param_key)(struct probe_s *, struct param_key_s *, const void *); typedef void (*parser_param_default)(struct probe_params *, struct param_val_s *); #define __PROBE_PARAM_DEFAULT_STRLEN 64 @@ -77,9 +76,9 @@ struct param_key_s { int key_type; }; -static int parser_sample_peirod(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_sample_peirod(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - int value = (int)key_item->valueint; + int value = (int) Json_GetValueInt(key_item); if (value < param_key->v.min || value > param_key->v.max) { PARSE_ERR("params.%s invalid value, must be in [%d, %d]", param_key->key, param_key->v.min, param_key->v.max); @@ -90,9 +89,9 @@ static int parser_sample_peirod(struct probe_s *probe, struct param_key_s *param return 0; } -static int parser_report_peirod(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_report_peirod(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - int value = (int)key_item->valueint; + int value = (int) Json_GetValueInt(key_item); if (value < param_key->v.min || value > param_key->v.max) { PARSE_ERR("params.%s invalid value, must be in [%d, %d]", param_key->key, param_key->v.min, param_key->v.max); @@ -103,9 +102,9 @@ static int parser_report_peirod(struct probe_s *probe, struct param_key_s *param return 0; } -static int parser_latency_thr(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_latency_thr(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - int value = (int)key_item->valueint; + int value = (int) Json_GetValueInt(key_item); if (value < param_key->v.min || value > param_key->v.max) { PARSE_ERR("params.%s invalid value, must be in [%d, %d]", param_key->key, param_key->v.min, param_key->v.max); @@ -116,9 +115,9 @@ static int parser_latency_thr(struct probe_s *probe, struct param_key_s *param_k return 0; } -static int parser_offline_thr(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_offline_thr(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - int value = (int)key_item->valueint; + int value = (int) Json_GetValueInt(key_item); if (value < param_key->v.min || value > param_key->v.max) { PARSE_ERR("params.%s invalid value, must be in [%d, %d]", param_key->key, param_key->v.min, param_key->v.max); @@ -129,9 +128,9 @@ static int parser_offline_thr(struct probe_s *probe, struct param_key_s *param_k return 0; } -static int parser_drops_thr(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_drops_thr(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - int value = (int)key_item->valueint; + int value = (int) Json_GetValueInt(key_item); if (value < param_key->v.min || value > param_key->v.max) { PARSE_ERR("params.%s invalid value, must be in [%d, %d]", param_key->key, param_key->v.min, param_key->v.max); @@ -142,9 +141,9 @@ static int parser_drops_thr(struct probe_s *probe, struct param_key_s *param_key return 0; } -static int parser_res_lower_thr(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_res_lower_thr(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - int value = (int)key_item->valueint; + int value = (int) Json_GetValueInt(key_item); if (value < param_key->v.min || value > param_key->v.max) { PARSE_ERR("params.%s invalid value, must be in [%d, %d]", param_key->key, param_key->v.min, param_key->v.max); @@ -155,9 +154,9 @@ static int parser_res_lower_thr(struct probe_s *probe, struct param_key_s *param return 0; } -static int parser_res_upper_thr(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_res_upper_thr(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - int value = (int)key_item->valueint; + int value = (int) Json_GetValueInt(key_item); if (value < param_key->v.min || value > param_key->v.max) { PARSE_ERR("params.%s invalid value, must be in [%d, %d]", param_key->key, param_key->v.min, param_key->v.max); @@ -169,16 +168,15 @@ static int parser_res_upper_thr(struct probe_s *probe, struct param_key_s *param } #if 0 -static int parse_host_ip_fields(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parse_host_ip_fields(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { char *p = NULL; int index = 0; - - if (key_item->type != cJSON_String) { + if (Json_Type(key_item) != Json_String) { return -1; } - char *value = key_item->valuestring; + char *value = (char *)Json_GetKeyValueString(key_item); p = strtok(value, ","); while (p != NULL && index < MAX_IP_NUM) { (void)snprintf(probe->probe_param.host_ip_list[index++], MAX_IP_LEN, "%s", p); @@ -188,9 +186,9 @@ static int parse_host_ip_fields(struct probe_s *probe, struct param_key_s *param } #endif -static int parser_report_event(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_report_event(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - int value = (int)key_item->valueint; + int value = (int) Json_GetValueInt(key_item); if (value < param_key->v.min || value > param_key->v.max) { PARSE_ERR("params.%s invalid value, must be in [%d, %d]", param_key->key, param_key->v.min, param_key->v.max); @@ -201,18 +199,18 @@ static int parser_report_event(struct probe_s *probe, struct param_key_s *param_ return 0; } -static int parser_metrics_type(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_metrics_type(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - cJSON *object; + void *object; u32 metrics_flags; - size_t size = cJSON_GetArraySize(key_item); + size_t size = Json_GetArraySize(key_item); for (int i = 0; i < size; i++) { - object = cJSON_GetArrayItem(key_item, i); - if (object->type != cJSON_String) { + object = Json_GetArrayItem(key_item, i); + if (Json_Type(object) != Json_String) { return -1; } - const char* value = (const char *)object->valuestring; + const char* value = (const char *) Json_GetListValueString(object); metrics_flags = __get_params_flags(param_metrics_flags, sizeof(param_metrics_flags)/sizeof(struct param_flags_s), value); if (metrics_flags == 0) { @@ -227,18 +225,18 @@ static int parser_metrics_type(struct probe_s *probe, struct param_key_s *param_ return 0; } -static int parser_work_env(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_work_env(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - cJSON *object; + void *object; u32 env_flags; - size_t size = cJSON_GetArraySize(key_item); + size_t size = Json_GetArraySize(key_item); for (int i = 0; i < size; i++) { - object = cJSON_GetArrayItem(key_item, i); - if (object->type != cJSON_String) { + object = Json_GetArrayItem(key_item, i); + if (Json_Type(object) != Json_String) { return -1; } - const char* value = (const char *)object->valuestring; + const char* value = (const char *) Json_GetListValueString(object); env_flags = __get_params_flags(param_env_flags, sizeof(param_env_flags)/sizeof(struct param_flags_s), value); @@ -254,18 +252,18 @@ static int parser_work_env(struct probe_s *probe, struct param_key_s *param_key, return 0; } -static int parser_l7pro(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_l7pro(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - cJSON *object; + void *object; u32 l7pro_flags; - size_t size = cJSON_GetArraySize(key_item); + size_t size = Json_GetArraySize(key_item); for (int i = 0; i < size; i++) { - object = cJSON_GetArrayItem(key_item, i); - if (object->type != cJSON_String) { + object = Json_GetArrayItem(key_item, i); + if (Json_Type(object) != Json_String) { return -1; } - const char* value = (const char *)object->valuestring; + const char* value = (const char *) Json_GetListValueString(object); l7pro_flags = __get_params_flags(param_l7pro_flags, sizeof(param_l7pro_flags)/sizeof(struct param_flags_s), value); @@ -281,9 +279,9 @@ static int parser_l7pro(struct probe_s *probe, struct param_key_s *param_key, co return 0; } -static int parser_support_ssl(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_support_ssl(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - int value = (int)key_item->valueint; + int value = (int) Json_GetValueInt(key_item); if (value < param_key->v.min || value > param_key->v.max) { PARSE_ERR("params.%s invalid value, must be in [%d, %d]", param_key->key, param_key->v.min, param_key->v.max); @@ -294,11 +292,11 @@ static int parser_support_ssl(struct probe_s *probe, struct param_key_s *param_k return 0; } -static int parser_svg_dir(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_svg_dir(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - const char *value = (const char*)key_item->valuestring; + const char *value = (const char*) Json_GetListValueString(key_item); - if (key_item->type != cJSON_String) { + if (Json_Type(key_item) != Json_String) { return -1; } @@ -306,11 +304,11 @@ static int parser_svg_dir(struct probe_s *probe, struct param_key_s *param_key, return 0; } -static int parser_flame_dir(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_flame_dir(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - const char *value = (const char*)key_item->valuestring; + const char *value = (const char*) Json_GetListValueString(key_item); - if (key_item->type != cJSON_String) { + if (Json_Type(key_item) != Json_String) { return -1; } @@ -318,11 +316,11 @@ static int parser_flame_dir(struct probe_s *probe, struct param_key_s *param_key return 0; } -static int parser_pyscope_server(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_pyscope_server(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - const char *value = (const char*)key_item->valuestring; + const char *value = (const char*) Json_GetListValueString(key_item); - if (key_item->type != cJSON_String) { + if (Json_Type(key_item) != Json_String) { return -1; } @@ -340,9 +338,9 @@ static int parser_pyscope_server(struct probe_s *probe, struct param_key_s *para return 0; } -static int parser_svg_period(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_svg_period(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - int value = (int)key_item->valueint; + int value = (int) Json_GetValueInt(key_item); if (value == 0) { value = param_key->v.default_int; } else if (value < param_key->v.min || value > param_key->v.max) { @@ -355,9 +353,9 @@ static int parser_svg_period(struct probe_s *probe, struct param_key_s *param_ke return 0; } -static int parser_perf_sample_period(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_perf_sample_period(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - int value = (int)key_item->valueint; + int value = Json_GetValueInt(key_item); if (value == 0) { value = param_key->v.default_int; } else if (value < param_key->v.min || value > param_key->v.max) { @@ -370,9 +368,9 @@ static int parser_perf_sample_period(struct probe_s *probe, struct param_key_s * return 0; } -static int parser_multi_instance(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_multi_instance(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - int value = (int)key_item->valueint; + int value = Json_GetValueInt(key_item); if (value < param_key->v.min || value > param_key->v.max) { PARSE_ERR("params.%s invalid value, must be in [%d, %d]", param_key->key, param_key->v.min, param_key->v.max); @@ -383,9 +381,9 @@ static int parser_multi_instance(struct probe_s *probe, struct param_key_s *para return 0; } -static int parser_native_stack(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_native_stack(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - int value = (int)key_item->valueint; + int value = Json_GetValueInt(key_item); if (value < param_key->v.min || value > param_key->v.max) { PARSE_ERR("params.%s invalid value, must be in [%d, %d]", param_key->key, param_key->v.min, param_key->v.max); @@ -396,9 +394,9 @@ static int parser_native_stack(struct probe_s *probe, struct param_key_s *param_ return 0; } -static int parser_cluster_ip_backend_flag(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_cluster_ip_backend_flag(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - int value = (int)key_item->valueint; + int value = Json_GetValueInt(key_item); if (value < param_key->v.min || value > param_key->v.max) { PARSE_ERR("params.%s invalid value, must be in [%d, %d]", param_key->key, param_key->v.min, param_key->v.max); @@ -411,11 +409,11 @@ static int parser_cluster_ip_backend_flag(struct probe_s *probe, struct param_ke #if 0 -static int parser_sysdebuging_dir(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_sysdebuging_dir(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - const char *value = (const char*)key_item->valuestring; + const char *value = (const char*) Json_GetListValueString(key_item); - if (key_item->type != cJSON_String) { + if (Json_Type(key_item) != Json_String) { return -1; } @@ -424,16 +422,16 @@ static int parser_sysdebuging_dir(struct probe_s *probe, struct param_key_s *par } #endif -static int parser_dev_name(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_dev_name(struct probe_s *probe, struct param_key_s *param_key, const void* key_item) { - const char *value = (const char*)key_item->valuestring; + const char *value = (const char*) Json_GetListValueString(key_item); - if (key_item->type != cJSON_String) { + if (Json_Type(key_item) != Json_String) { return -1; } if (strlen(value) >= sizeof(probe->probe_param.target_dev)) { - PARSE_ERR("params.%s value is too long, len must be less than %d", + PARSE_ERR("params.%s value is too long, len must be less than %lu", param_key->key, sizeof(probe->probe_param.target_dev)); return -1; } @@ -442,9 +440,9 @@ static int parser_dev_name(struct probe_s *probe, struct param_key_s *param_key, return 0; } -static int parser_kafka_port(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_kafka_port(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - int value = (int)key_item->valueint; + int value = Json_GetValueInt(key_item); if (value < param_key->v.min || value > param_key->v.max) { PARSE_ERR("params.%s invalid value, must be in [%d, %d]", param_key->key, param_key->v.min, param_key->v.max); @@ -455,9 +453,9 @@ static int parser_kafka_port(struct probe_s *probe, struct param_key_s *param_ke return 0; } -static int parser_continuous_sampling(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_continuous_sampling(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - int value = (int)key_item->valueint; + int value = Json_GetValueInt(key_item); if (value < param_key->v.min || value > param_key->v.max) { PARSE_ERR("params.%s invalid value, must be in [%d, %d]", param_key->key, param_key->v.min, param_key->v.max); @@ -468,11 +466,11 @@ static int parser_continuous_sampling(struct probe_s *probe, struct param_key_s return 0; } -static int parser_elf_path(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_elf_path(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - const char *value = (const char*)key_item->valuestring; + const char *value = (const char*) Json_GetListValueString(key_item); - if (key_item->type != cJSON_String) { + if (Json_Type(key_item) != Json_String) { return -1; } @@ -480,9 +478,9 @@ static int parser_elf_path(struct probe_s *probe, struct param_key_s *param_key, return 0; } -static int parser_cadvisor_port(struct probe_s *probe, struct param_key_s *param_key, const cJSON *key_item) +static int parser_cadvisor_port(struct probe_s *probe, struct param_key_s *param_key, const void *key_item) { - int value = (int)key_item->valueint; + int value = Json_GetValueInt(key_item); if (value < param_key->v.min || value > param_key->v.max) { PARSE_ERR("params.%s invalid value, must be in [%d, %d]", param_key->key, param_key->v.min, param_key->v.max); @@ -572,35 +570,35 @@ SET_DEFAULT_PARAMS_STR(flame_dir); #define CADVISOR_PORT "cadvisor_port" struct param_key_s param_keys[] = { - {SAMPLE_PERIOD, {DEFAULT_SAMPLE_PERIOD, 100, 10000, ""}, parser_sample_peirod, set_default_params_inter_sample_period, cJSON_Number}, - {REPORT_PERIOD, {DEFAULT_PERIOD, 5, 600, ""}, parser_report_peirod, set_default_params_inter_period, cJSON_Number}, - {LATENCY_THR, {0, 10, 100000, ""}, parser_latency_thr, set_default_params_inter_latency_thr, cJSON_Number}, - {OFFLINE_THR, {0, 10, 100000, ""}, parser_offline_thr, set_default_params_inter_offline_thr, cJSON_Number}, - {DROPS_THR, {0, 10, 100000, ""}, parser_drops_thr, set_default_params_inter_drops_count_thr, cJSON_Number}, - {RES_LOWER_THR, {0, 0, 100, ""}, parser_res_lower_thr, set_default_params_char_res_percent_lower, cJSON_Number}, - {RES_UPPER_THR, {0, 0, 100, ""}, parser_res_upper_thr, set_default_params_char_res_percent_upper, cJSON_Number}, - {REPORT_EVENT, {0, 0, 1, ""}, parser_report_event, set_default_params_char_logs, cJSON_Number}, - {METRICS_TYPE, {SUPPORT_METRICS_RAW | SUPPORT_METRICS_TELEM, 0, 0, "raw"}, parser_metrics_type, set_default_params_char_metrics_flags, cJSON_Array}, - {ENV, {SUPPORT_NODE_ENV, 0, 0, "node"}, parser_work_env, set_default_params_char_env_flags, cJSON_Array}, - {L7_PROTOCOL, {L7PROBE_TRACING_HTTP, 0, 0, "http"}, parser_l7pro, set_default_params_inter_l7_probe_proto_flags, cJSON_Array}, - {SUPPORT_SSL, {0, 0, 1, ""}, parser_support_ssl, set_default_params_char_support_ssl, cJSON_Number}, - {PYROSCOPE_SERVER, {0, 0, 0, "localhost:4040"}, parser_pyscope_server, set_default_params_str_pyroscope_server, cJSON_String}, - {SVG_PERIOD, {180, 30, 600, ""}, parser_svg_period, set_default_params_inter_svg_period, cJSON_Number}, - {PERF_SAMPLE_PERIOD, {10, 10, 1000, ""}, parser_perf_sample_period, set_default_params_inter_perf_sample_period, cJSON_Number}, - {MULTI_INSTANCE, {0, 0, 1, ""}, parser_multi_instance, set_default_params_char_multi_instance_flag, cJSON_Number}, - {NATIVE_STACK, {0, 0, 1, ""}, parser_native_stack, set_default_params_char_native_stack_flag, cJSON_Number}, - {CLUSTER_IP_BACKEND, {0, 0, 1, ""}, parser_cluster_ip_backend_flag, set_default_params_char_cluster_ip_backend, cJSON_Number}, - {SVG_DIR, {0, 0, 0, "/var/log/gala-gopher/stacktrace"}, parser_svg_dir, set_default_params_str_svg_dir, cJSON_String}, - {FLAME_DIR, {0, 0, 0, "/var/log/gala-gopher/flamegraph"}, parser_flame_dir, set_default_params_str_flame_dir, cJSON_String}, + {SAMPLE_PERIOD, {DEFAULT_SAMPLE_PERIOD, 100, 10000, ""}, parser_sample_peirod, set_default_params_inter_sample_period, Json_Number}, + {REPORT_PERIOD, {DEFAULT_PERIOD, 5, 600, ""}, parser_report_peirod, set_default_params_inter_period, Json_Number}, + {LATENCY_THR, {0, 10, 100000, ""}, parser_latency_thr, set_default_params_inter_latency_thr, Json_Number}, + {OFFLINE_THR, {0, 10, 100000, ""}, parser_offline_thr, set_default_params_inter_offline_thr, Json_Number}, + {DROPS_THR, {0, 10, 100000, ""}, parser_drops_thr, set_default_params_inter_drops_count_thr, Json_Number}, + {RES_LOWER_THR, {0, 0, 100, ""}, parser_res_lower_thr, set_default_params_char_res_percent_lower, Json_Number}, + {RES_UPPER_THR, {0, 0, 100, ""}, parser_res_upper_thr, set_default_params_char_res_percent_upper, Json_Number}, + {REPORT_EVENT, {0, 0, 1, ""}, parser_report_event, set_default_params_char_logs, Json_Number}, + {METRICS_TYPE, {SUPPORT_METRICS_RAW | SUPPORT_METRICS_TELEM, 0, 0, "raw"}, parser_metrics_type, set_default_params_char_metrics_flags, Json_Array}, + {ENV, {SUPPORT_NODE_ENV, 0, 0, "node"}, parser_work_env, set_default_params_char_env_flags, Json_Array}, + {L7_PROTOCOL, {L7PROBE_TRACING_HTTP, 0, 0, "http"}, parser_l7pro, set_default_params_inter_l7_probe_proto_flags, Json_Array}, + {SUPPORT_SSL, {0, 0, 1, ""}, parser_support_ssl, set_default_params_char_support_ssl, Json_Number}, + {PYROSCOPE_SERVER, {0, 0, 0, "localhost:4040"}, parser_pyscope_server, set_default_params_str_pyroscope_server, Json_String}, + {SVG_PERIOD, {180, 30, 600, ""}, parser_svg_period, set_default_params_inter_svg_period, Json_Number}, + {PERF_SAMPLE_PERIOD, {10, 10, 1000, ""}, parser_perf_sample_period, set_default_params_inter_perf_sample_period, Json_Number}, + {MULTI_INSTANCE, {0, 0, 1, ""}, parser_multi_instance, set_default_params_char_multi_instance_flag, Json_Number}, + {NATIVE_STACK, {0, 0, 1, ""}, parser_native_stack, set_default_params_char_native_stack_flag, Json_Number}, + {CLUSTER_IP_BACKEND, {0, 0, 1, ""}, parser_cluster_ip_backend_flag, set_default_params_char_cluster_ip_backend, Json_Number}, + {SVG_DIR, {0, 0, 0, "/var/log/gala-gopher/stacktrace"}, parser_svg_dir, set_default_params_str_svg_dir, Json_String}, + {FLAME_DIR, {0, 0, 0, "/var/log/gala-gopher/flamegraph"}, parser_flame_dir, set_default_params_str_flame_dir, Json_String}, #if 0 - {DEBUGGING_DIR, {0, 0, 0, ""}, parser_sysdebuging_dir, set_default_params_str_sys_debuging_dir, cJSON_String}, - {HOST_IP_FIELDS, {0, 0, 0, ""}, parse_host_ip_fields, NULL, cJSON_String}, + {DEBUGGING_DIR, {0, 0, 0, ""}, parser_sysdebuging_dir, set_default_params_str_sys_debuging_dir, Json_String}, + {HOST_IP_FIELDS, {0, 0, 0, ""}, parse_host_ip_fields, NULL, Json_String}, #endif - {DEV_NAME_KEY, {0, 0, 0, ""}, parser_dev_name, NULL, cJSON_String}, - {CONTINUOUS_SAMPLING, {0, 0, 1, ""}, parser_continuous_sampling, set_default_params_char_continuous_sampling_flag, cJSON_Number}, - {ELF_PATH, {0, 0, 0, ""}, parser_elf_path, NULL, cJSON_String}, - {KAFKA_PORT, {DEFAULT_KAFKA_PORT, 1, 65535, ""}, parser_kafka_port, set_default_params_inter_kafka_port, cJSON_Number}, - {CADVISOR_PORT, {DEFAULT_CADVISOR_PORT, 1, 65535, ""}, parser_cadvisor_port, set_default_params_inter_cadvisor_port, cJSON_Number} + {DEV_NAME_KEY, {0, 0, 0, ""}, parser_dev_name, NULL, Json_String}, + {CONTINUOUS_SAMPLING, {0, 0, 1, ""}, parser_continuous_sampling, set_default_params_char_continuous_sampling_flag, Json_Number}, + {ELF_PATH, {0, 0, 0, ""}, parser_elf_path, NULL, Json_String}, + {KAFKA_PORT, {DEFAULT_KAFKA_PORT, 1, 65535, ""}, parser_kafka_port, set_default_params_inter_kafka_port, Json_Number}, + {CADVISOR_PORT, {DEFAULT_CADVISOR_PORT, 1, 65535, ""}, parser_cadvisor_port, set_default_params_inter_cadvisor_port, Json_Number} }; void set_default_params(struct probe_s *probe) @@ -619,21 +617,21 @@ void set_default_params(struct probe_s *probe) } } -int parse_params(struct probe_s *probe, const cJSON *params_json) +int parse_params(struct probe_s *probe, const void *params_json) { int ret = -1; - cJSON *key_item, *object; + void *key_item, *object; struct param_key_s *param_key; size_t size = sizeof(param_keys) / sizeof(struct param_key_s); for (int i = 0; i < size; i++) { param_key = &(param_keys[i]); - key_item = cJSON_GetObjectItem(params_json, param_key->key); + key_item = Json_GetObjectItem(params_json, param_key->key); if (key_item == NULL) { continue; } - - if (key_item->type != param_key->key_type) { + // key_item has String, number, array, object etc. + if (Json_Type(key_item) != param_key->key_type) { PARSE_ERR("params.%s invalid data type", param_key->key); return -1; } @@ -647,77 +645,77 @@ int parse_params(struct probe_s *probe, const cJSON *params_json) return ret; } -static cJSON *param_flags_to_json(unsigned int flags, struct param_flags_s param_flags[], size_t size) +static void *param_flags_to_json(unsigned int flags, struct param_flags_s param_flags[], size_t size) { - cJSON *arr = cJSON_CreateArray(); + void *arr = Json_CreateArray(); int i; for (i = 0; i < size; i++) { if (flags & param_flags[i].flags) { - cJSON_AddItemToArray(arr, cJSON_CreateString(param_flags[i].desc)); + Json_AddStringItemToArray(arr, param_flags[i].desc); } } return arr; } -void probe_params_to_json(struct probe_s *probe, cJSON *params) +void probe_params_to_json(struct probe_s *probe, void *params) { struct probe_params *probe_param = &probe->probe_param; enum probe_type_e probe_type = probe->probe_type; - cJSON *flags_arr; + void *flags_arr; size_t flags_size; - cJSON_AddItemToObject(params, SAMPLE_PERIOD, cJSON_CreateNumber(probe_param->sample_period)); - cJSON_AddItemToObject(params, REPORT_PERIOD, cJSON_CreateNumber(probe_param->period)); - cJSON_AddItemToObject(params, LATENCY_THR, cJSON_CreateNumber(probe_param->latency_thr)); - cJSON_AddItemToObject(params, OFFLINE_THR, cJSON_CreateNumber(probe_param->offline_thr)); - cJSON_AddItemToObject(params, DROPS_THR, cJSON_CreateNumber(probe_param->drops_count_thr)); - cJSON_AddItemToObject(params, RES_LOWER_THR, cJSON_CreateNumber(probe_param->res_percent_lower)); - cJSON_AddItemToObject(params, RES_UPPER_THR, cJSON_CreateNumber(probe_param->res_percent_upper)); - cJSON_AddItemToObject(params, REPORT_EVENT, cJSON_CreateNumber(probe_param->logs)); + Json_AddUIntItemToObject(params, SAMPLE_PERIOD, probe_param->sample_period); + Json_AddUIntItemToObject(params, REPORT_PERIOD, probe_param->period); + Json_AddUIntItemToObject(params, LATENCY_THR, probe_param->latency_thr); + Json_AddUIntItemToObject(params, OFFLINE_THR, probe_param->offline_thr); + Json_AddUIntItemToObject(params, DROPS_THR, probe_param->drops_count_thr); + Json_AddCharItemToObject(params, RES_LOWER_THR, probe_param->res_percent_lower); + Json_AddCharItemToObject(params, RES_UPPER_THR, probe_param->res_percent_upper); + Json_AddCharItemToObject(params, REPORT_EVENT, probe_param->logs); flags_size = sizeof(param_metrics_flags) / sizeof(param_metrics_flags[0]); flags_arr = param_flags_to_json(probe_param->metrics_flags, param_metrics_flags, flags_size); - cJSON_AddItemToObject(params, METRICS_TYPE, flags_arr); + Json_AddItemToObject(params, METRICS_TYPE, flags_arr, 1); flags_size = sizeof(param_env_flags) / sizeof(param_env_flags[0]); flags_arr = param_flags_to_json(probe_param->env_flags, param_env_flags, flags_size); - cJSON_AddItemToObject(params, ENV, flags_arr); + Json_AddItemToObject(params, ENV, flags_arr, 1); if (probe_type == PROBE_L7) { flags_size = sizeof(param_l7pro_flags) / sizeof(param_l7pro_flags[0]); flags_arr = param_flags_to_json(probe_param->l7_probe_proto_flags, param_l7pro_flags, flags_size); - cJSON_AddItemToObject(params, L7_PROTOCOL, flags_arr); + Json_AddItemToObject(params, L7_PROTOCOL, flags_arr, 1); - cJSON_AddItemToObject(params, SUPPORT_SSL, cJSON_CreateNumber(probe_param->support_ssl)); + Json_AddCharItemToObject(params, SUPPORT_SSL, probe_param->support_ssl); } if (probe_type == PROBE_L7 || probe_type == PROBE_TCP) { - cJSON_AddItemToObject(params, CLUSTER_IP_BACKEND, cJSON_CreateNumber(probe_param->cluster_ip_backend)); + Json_AddCharItemToObject(params, CLUSTER_IP_BACKEND, probe_param->cluster_ip_backend); } if (probe_type == PROBE_FG) { - cJSON_AddStringToObject(params, PYROSCOPE_SERVER, probe_param->pyroscope_server); - cJSON_AddItemToObject(params, SVG_PERIOD, cJSON_CreateNumber(probe_param->svg_period)); - cJSON_AddItemToObject(params, PERF_SAMPLE_PERIOD, cJSON_CreateNumber(probe_param->perf_sample_period)); - cJSON_AddItemToObject(params, MULTI_INSTANCE, cJSON_CreateNumber(probe_param->multi_instance_flag)); - cJSON_AddItemToObject(params, NATIVE_STACK, cJSON_CreateNumber(probe_param->native_stack_flag)); - cJSON_AddStringToObject(params, SVG_DIR, probe_param->svg_dir); - cJSON_AddStringToObject(params, FLAME_DIR, probe_param->flame_dir); + Json_AddStringToObject(params, PYROSCOPE_SERVER, probe_param->pyroscope_server); + Json_AddUIntItemToObject(params, SVG_PERIOD,probe_param->svg_period); + Json_AddUIntItemToObject(params, PERF_SAMPLE_PERIOD, probe_param->perf_sample_period); + Json_AddCharItemToObject(params, MULTI_INSTANCE, probe_param->multi_instance_flag); + Json_AddCharItemToObject(params, NATIVE_STACK, probe_param->native_stack_flag); + Json_AddStringToObject(params, SVG_DIR, probe_param->svg_dir); + Json_AddStringToObject(params, FLAME_DIR, probe_param->flame_dir); } if (probe_type == PROBE_IO || probe_type == PROBE_KAFKA || probe_type == PROBE_KSLI || probe_type == PROBE_POSTGRE_SLI || probe_type == PROBE_BASEINFO || probe_type == PROBE_TCP) { - cJSON_AddStringToObject(params, DEV_NAME_KEY, probe_param->target_dev); + Json_AddStringToObject(params, DEV_NAME_KEY, probe_param->target_dev); } if (probe_type == PROBE_KSLI) { - cJSON_AddItemToObject(params, CONTINUOUS_SAMPLING, cJSON_CreateNumber(probe_param->continuous_sampling_flag)); + Json_AddCharItemToObject(params, CONTINUOUS_SAMPLING, probe_param->continuous_sampling_flag); } if (probe_type == PROBE_NGINX || probe_type == PROBE_HAPROXY || probe_type == PROBE_DNSMASQ) { - cJSON_AddStringToObject(params, ELF_PATH, probe_param->elf_path); + Json_AddStringToObject(params, ELF_PATH, probe_param->elf_path); } if (probe_type == PROBE_KAFKA) { - cJSON_AddItemToObject(params, KAFKA_PORT, cJSON_CreateNumber(probe_param->kafka_port)); + Json_AddUIntItemToObject(params, KAFKA_PORT, probe_param->kafka_port); } if (probe_type == PROBE_CONTAINER) { - cJSON_AddItemToObject(params, CADVISOR_PORT, cJSON_CreateNumber(probe_param->cadvisor_port)); + Json_AddUIntItemToObject(params, CADVISOR_PORT, probe_param->cadvisor_port); } } \ No newline at end of file diff --git a/src/lib/probe/probe_params_parser.h b/src/lib/probe/probe_params_parser.h index 66b4e6a100cdbb650f340b7baf17ccf6c68d6847..ed0a96feac96876568f580a804fb8906e1aadcf6 100644 --- a/src/lib/probe/probe_params_parser.h +++ b/src/lib/probe/probe_params_parser.h @@ -15,12 +15,11 @@ #ifndef __PROBE_PARAMS_PARSER__ #define __PROBE_PARAMS_PARSER__ -#include -int parse_params(struct probe_s *probe, const cJSON *params_json); +int parse_params(struct probe_s *probe, const void *params_json); void set_default_params(struct probe_s *probe); -void probe_params_to_json(struct probe_s *probe, cJSON *json); +void probe_params_to_json(struct probe_s *probe, void *json); #endif diff --git a/src/lib/probe/snooper.c b/src/lib/probe/snooper.c index f0fd4fea1257a1d04d8eb23564b95cff8540dc3d..0cbd7659a109d60845f0f53a9127da189a7cd82d 100644 --- a/src/lib/probe/snooper.c +++ b/src/lib/probe/snooper.c @@ -24,7 +24,6 @@ #include #include #include -#include #include "bpf.h" #include "container.h" @@ -294,41 +293,41 @@ static int add_snooper_conf_gaussdb(struct probe_s *probe, char *ip, char *dbnam return 0; } -static void print_snooper_procid(struct probe_s *probe, cJSON *json) +static void print_snooper_procid(struct probe_s *probe, void *json) { - cJSON *procid_item; + void *procid_item; struct snooper_conf_s *snooper_conf; - procid_item = cJSON_CreateArray(); + procid_item = Json_CreateArray(); for (int i = 0; i < probe->snooper_conf_num; i++) { snooper_conf = probe->snooper_confs[i]; if (snooper_conf->type != SNOOPER_CONF_PROC_ID) { continue; } - cJSON_AddItemToArray(procid_item, cJSON_CreateNumber(snooper_conf->conf.proc_id)); + Json_AddUIntItemToArray(procid_item, snooper_conf->conf.proc_id); } - cJSON_AddItemToObject(json, SNOOPER_OBJNAME_PROCID, procid_item); + Json_AddItemToObject(json, SNOOPER_OBJNAME_PROCID, procid_item, 1); } -static int parse_snooper_procid(struct probe_s *probe, const cJSON *json) +static int parse_snooper_procid(struct probe_s *probe, const void *json) { int ret; - cJSON *procid_item, *object; + void *procid_item, *object; - procid_item = cJSON_GetObjectItem(json, SNOOPER_OBJNAME_PROCID); + procid_item = Json_GetObjectItem(json, SNOOPER_OBJNAME_PROCID); if (procid_item == NULL) { return 0; } - size_t size = cJSON_GetArraySize(procid_item); + size_t size = Json_GetArraySize(procid_item); for (int i = 0; i < size; i++) { - object = cJSON_GetArrayItem(procid_item, i); - if (object->type != cJSON_Number) { + object = Json_GetArrayItem(procid_item, i); + if (!Json_IsObjNumeric(object)) { return -1; } - ret = add_snooper_conf_procid(probe, (u32)object->valueint); + ret = add_snooper_conf_procid(probe, (u32) Json_GetValueInt(object)); if (ret != 0) { return -1; } @@ -337,10 +336,10 @@ static int parse_snooper_procid(struct probe_s *probe, const cJSON *json) return 0; } -static struct custom_label_elem *dup_custom_labels_from_json(const cJSON *labelItems, int num) +static struct custom_label_elem *dup_custom_labels_from_json(const void *labelItems, int num) { struct custom_label_elem *custom_labels; - cJSON *labelItem; + void *labelItem; char *labelVal; int i; @@ -350,40 +349,47 @@ static struct custom_label_elem *dup_custom_labels_from_json(const cJSON *labelI } i = 0; - cJSON_ArrayForEach(labelItem, labelItems) { - labelVal = cJSON_GetStringValue(labelItem); + Json_ArrayForEach(&labelItem, labelItems) { + labelVal = (char *) Json_GetKeyValueString(labelItem); if (!labelVal) { free_custom_labels(custom_labels, num); + Json_Delete(labelItem); return NULL; } - custom_labels[i].key = strdup(labelItem->string); + char* keyChar = Json_GetKeyString(labelItem); + if (!keyChar) { + Json_Delete(labelItem); + return NULL; + } + custom_labels[i].key = strdup(keyChar); custom_labels[i].val = strdup(labelVal); if (!custom_labels[i].key || !custom_labels[i].val) { free_custom_labels(custom_labels, num); + Json_Delete(labelItem); return NULL; } i++; + Json_Delete(labelItem); } - return custom_labels; } -static int parse_snooper_custom_labels(struct probe_s *probe, const cJSON *json) +static int parse_snooper_custom_labels(struct probe_s *probe, const void *json) { int ret; - cJSON *labelItems; + void *labelItems; int custom_label_num; struct custom_label_elem *custom_labels; - labelItems = cJSON_GetObjectItem(json, SNOOPER_OBJNAME_CUSTOM_LABELS); + labelItems = Json_GetObjectItem(json, SNOOPER_OBJNAME_CUSTOM_LABELS); if (!labelItems) { return 0; } - if (!cJSON_IsObject(labelItems)) { + if (!Json_IsObject(labelItems)) { return -1; } - custom_label_num = cJSON_GetArraySize(labelItems); + custom_label_num = (int)Json_GetArraySize(labelItems); if (custom_label_num == 0) { return 0; } @@ -396,10 +402,10 @@ static int parse_snooper_custom_labels(struct probe_s *probe, const cJSON *json) return 0; } -static struct pod_label_elem *dup_pod_labels_from_json(const cJSON *labelItems, int num) +static struct pod_label_elem *dup_pod_labels_from_json(const void *labelItems, int num) { struct pod_label_elem *pod_labels; - cJSON *labelItem; + void *labelItem; char *labelKey; int i; @@ -409,39 +415,42 @@ static struct pod_label_elem *dup_pod_labels_from_json(const cJSON *labelItems, } i = 0; - cJSON_ArrayForEach(labelItem, labelItems) { - labelKey = cJSON_GetStringValue(labelItem); + Json_ArrayForEach(&labelItem, labelItems) { + labelKey = (char *) Json_GetListValueString(labelItem); if (!labelKey) { free_pod_labels(pod_labels, num); + Json_Delete(labelItem); return NULL; } pod_labels[i].key = strdup(labelKey); if (!pod_labels[i].key) { free_pod_labels(pod_labels, num); + Json_Delete(labelItem); return NULL; } + Json_Delete(labelItem); i++; } return pod_labels; } -static int parse_snooper_pod_labels(struct probe_s *probe, const cJSON *json) +static int parse_snooper_pod_labels(struct probe_s *probe, const void *json) { int ret; - cJSON *labelItems; + void *labelItems; int pod_label_num; struct pod_label_elem *pod_labels; - labelItems = cJSON_GetObjectItem(json, SNOOPER_OBJNAME_POD_LABELS); + labelItems = Json_GetObjectItem(json, SNOOPER_OBJNAME_POD_LABELS); if (!labelItems) { return 0; } - if (!cJSON_IsArray(labelItems)) { + if (!Json_IsArray(labelItems)) { return -1; } - pod_label_num = cJSON_GetArraySize(labelItems); + pod_label_num = (int)Json_GetArraySize(labelItems); if (pod_label_num == 0) { return 0; } @@ -454,60 +463,60 @@ static int parse_snooper_pod_labels(struct probe_s *probe, const cJSON *json) return 0; } -static void print_snooper_procname(struct probe_s *probe, cJSON *json) +static void print_snooper_procname(struct probe_s *probe, void *json) { - cJSON *procname_item, *object; + void *procname_item, *object; struct snooper_conf_s *snooper_conf; - procname_item = cJSON_CreateArray(); + procname_item = Json_CreateArray(); for (int i = 0; i < probe->snooper_conf_num; i++) { snooper_conf = probe->snooper_confs[i]; if (snooper_conf->type != SNOOPER_CONF_APP) { continue; } - object = cJSON_CreateObject(); - cJSON_AddStringToObject(object, SNOOPER_OBJNAME_COMM, snooper_conf->conf.app.comm); - cJSON_AddStringToObject(object, SNOOPER_OBJNAME_CMDLINE, snooper_conf->conf.app.cmdline?:""); - cJSON_AddStringToObject(object, SNOOPER_OBJNAME_DBGDIR, snooper_conf->conf.app.debuging_dir?:""); - cJSON_AddItemToArray(procname_item, object); + object = Json_CreateObject(); + Json_AddStringToObject(object, SNOOPER_OBJNAME_COMM, snooper_conf->conf.app.comm); + Json_AddStringToObject(object, SNOOPER_OBJNAME_CMDLINE, snooper_conf->conf.app.cmdline?:""); + Json_AddStringToObject(object, SNOOPER_OBJNAME_DBGDIR, snooper_conf->conf.app.debuging_dir?:""); + Json_AddItemToArray(procname_item, object, 1); } - cJSON_AddItemToObject(json, SNOOPER_OBJNAME_PROCNAME, procname_item); + Json_AddItemToObject(json, SNOOPER_OBJNAME_PROCNAME, procname_item, 1); } -static int parse_snooper_procname(struct probe_s *probe, const cJSON *json) +static int parse_snooper_procname(struct probe_s *probe, const void *json) { int ret; - cJSON *procname_item, *comm_item, *cmdline_item, *dbgdir_item, *object; + void *procname_item, *comm_item, *cmdline_item, *dbgdir_item, *object; char *comm, *cmdline, *dbgdir; - procname_item = cJSON_GetObjectItem(json, SNOOPER_OBJNAME_PROCNAME); + procname_item = Json_GetObjectItem(json, SNOOPER_OBJNAME_PROCNAME); if (procname_item == NULL) { return 0; } - size_t size = cJSON_GetArraySize(procname_item); + size_t size = Json_GetArraySize(procname_item); for (int i = 0; i < size; i++) { - object = cJSON_GetArrayItem(procname_item, i); + object = Json_GetArrayItem(procname_item, i); - comm_item = cJSON_GetObjectItem(object, SNOOPER_OBJNAME_COMM); - cmdline_item = cJSON_GetObjectItem(object, SNOOPER_OBJNAME_CMDLINE); - dbgdir_item = cJSON_GetObjectItem(object, SNOOPER_OBJNAME_DBGDIR); + comm_item = Json_GetObjectItem(object, SNOOPER_OBJNAME_COMM); + cmdline_item = Json_GetObjectItem(object, SNOOPER_OBJNAME_CMDLINE); + dbgdir_item = Json_GetObjectItem(object, SNOOPER_OBJNAME_DBGDIR); - if ((comm_item == NULL) || (comm_item->type != cJSON_String)) { + if ((comm_item == NULL) || (!Json_IsObjString(comm_item))) { return -1; } - if (cmdline_item && (cmdline_item->type != cJSON_String)) { + if (cmdline_item && (!Json_IsObjString(cmdline_item))) { return -1; } - if (dbgdir_item && (dbgdir_item->type != cJSON_String)) { + if (dbgdir_item && (!Json_IsObjString(dbgdir_item))) { return -1; } - comm = (char *)comm_item->valuestring; - cmdline = (cmdline_item != NULL) ? (char *)cmdline_item->valuestring : NULL; - dbgdir = (dbgdir_item != NULL) ? (char *)dbgdir_item->valuestring : NULL; + comm = (char *) Json_GetListValueString(comm_item); + cmdline = (cmdline_item != NULL) ? (char *) Json_GetListValueString(cmdline_item) : NULL; + dbgdir = (dbgdir_item != NULL) ? (char *) Json_GetListValueString(dbgdir_item) : NULL; ret = add_snooper_conf_procname(probe, (const char *)comm, (const char *)cmdline, (const char *)dbgdir); if (ret != 0) { return -1; @@ -518,54 +527,54 @@ static int parse_snooper_procname(struct probe_s *probe, const cJSON *json) } -static void print_snooper_pod_container(struct probe_s *probe, cJSON *json) +static void print_snooper_pod_container(struct probe_s *probe, void *json) { - cJSON *pod_item, *cntr_item; + void *pod_item, *cntr_item; struct snooper_conf_s *snooper_conf; - pod_item = cJSON_CreateArray(); - cntr_item = cJSON_CreateArray(); + pod_item = Json_CreateArray(); + cntr_item = Json_CreateArray(); for (int i = 0; i < probe->snooper_conf_num; i++) { snooper_conf = probe->snooper_confs[i]; if (snooper_conf->type == SNOOPER_CONF_POD_ID) { - cJSON_AddItemToArray(pod_item, cJSON_CreateString(snooper_conf->conf.pod_id)); + Json_AddStringItemToArray(pod_item, snooper_conf->conf.pod_id); continue; } if (snooper_conf->type == SNOOPER_CONF_CONTAINER_ID) { - cJSON_AddItemToArray(cntr_item, cJSON_CreateString(snooper_conf->conf.container_id)); + Json_AddStringItemToArray(cntr_item,snooper_conf->conf.container_id); continue; } } - cJSON_AddItemToObject(json, SNOOPER_OBJNAME_PODID, pod_item); - cJSON_AddItemToObject(json, SNOOPER_OBJNAME_CONTAINERID, cntr_item); + Json_AddItemToObject(json, SNOOPER_OBJNAME_PODID, pod_item, 1); + Json_AddItemToObject(json, SNOOPER_OBJNAME_CONTAINERID, cntr_item, 1); } -static int parse_snooper_pod_container(struct probe_s *probe, const cJSON *json, const char *item_name) +static int parse_snooper_pod_container(struct probe_s *probe, const void *json, const char *item_name) { int ret; - cJSON *item, *object; + void *item, *object; int pod_flag = 0; if (!strcasecmp(item_name, SNOOPER_OBJNAME_PODID)) { pod_flag = 1; } - item = cJSON_GetObjectItem(json, item_name); + item = Json_GetObjectItem(json, item_name); if (item == NULL) { return 0; } - size_t size = cJSON_GetArraySize(item); + size_t size = Json_GetArraySize(item); for (int i = 0; i < size; i++) { - object = cJSON_GetArrayItem(item, i); - if (object->type != cJSON_String) { + object = Json_GetArrayItem(item, i); + if (!Json_IsObjString(object)) { return -1; } if (pod_flag) { - ret = add_snooper_conf_pod(probe, (const char *)object->valuestring); + ret = add_snooper_conf_pod(probe, (const char *) Json_GetListValueString(object)); } else { - ret = add_snooper_conf_container(probe, (const char *)object->valuestring); + ret = add_snooper_conf_container(probe, (const char *) Json_GetListValueString(object)); } if (ret != 0) { return -1; @@ -575,71 +584,71 @@ static int parse_snooper_pod_container(struct probe_s *probe, const cJSON *json, return 0; } -static void print_snooper_gaussdb(struct probe_s *probe, cJSON *json) +static void print_snooper_gaussdb(struct probe_s *probe, void *json) { - cJSON *gaussdb_item, *object; + void *gaussdb_item, *object; struct snooper_conf_s *snooper_conf; - gaussdb_item = cJSON_CreateArray(); + gaussdb_item = Json_CreateArray(); for (int i = 0; i < probe->snooper_conf_num; i++) { snooper_conf = probe->snooper_confs[i]; if (snooper_conf->type != SNOOPER_CONF_GAUSSDB) { continue; } - object = cJSON_CreateObject(); - cJSON_AddStringToObject(object, SNOOPER_OBJNAME_DBIP, snooper_conf->conf.gaussdb.ip?:""); - cJSON_AddNumberToObject(object, SNOOPER_OBJNAME_DBPORT, snooper_conf->conf.gaussdb.port); - cJSON_AddStringToObject(object, SNOOPER_OBJNAME_DBNAME, snooper_conf->conf.gaussdb.dbname?:""); - cJSON_AddStringToObject(object, SNOOPER_OBJNAME_DBUSER, snooper_conf->conf.gaussdb.usr?:""); - cJSON_AddStringToObject(object, SNOOPER_OBJNAME_DBPASS, snooper_conf->conf.gaussdb.pass?:""); - cJSON_AddItemToArray(gaussdb_item, object); + object = Json_CreateObject(); + Json_AddStringToObject(object, SNOOPER_OBJNAME_DBIP, snooper_conf->conf.gaussdb.ip?:""); + Json_AddUIntItemToObject(object, SNOOPER_OBJNAME_DBPORT, snooper_conf->conf.gaussdb.port); + Json_AddStringToObject(object, SNOOPER_OBJNAME_DBNAME, snooper_conf->conf.gaussdb.dbname?:""); + Json_AddStringToObject(object, SNOOPER_OBJNAME_DBUSER, snooper_conf->conf.gaussdb.usr?:""); + Json_AddStringToObject(object, SNOOPER_OBJNAME_DBPASS, snooper_conf->conf.gaussdb.pass?:""); + Json_AddItemToArray(gaussdb_item, object, 1); } - cJSON_AddItemToObject(json, SNOOPER_OBJNAME_GAUSSDB, gaussdb_item); + Json_AddItemToObject(json, SNOOPER_OBJNAME_GAUSSDB, gaussdb_item, 1); } -static int parse_snooper_gaussdb(struct probe_s *probe, const cJSON *json) +static int parse_snooper_gaussdb(struct probe_s *probe, const void *json) { int ret; - cJSON *gaussdb_item, *ip_item, *dbname_item, *usr_item, *pass_item, *port_item, *object; + void *gaussdb_item, *ip_item, *dbname_item, *usr_item, *pass_item, *port_item, *object; char *ip, *dbname, *usr, *pass; - gaussdb_item = cJSON_GetObjectItem(json, SNOOPER_OBJNAME_GAUSSDB); + gaussdb_item = Json_GetObjectItem(json, SNOOPER_OBJNAME_GAUSSDB); if (gaussdb_item == NULL) { return 0; } - size_t size = cJSON_GetArraySize(gaussdb_item); + size_t size = Json_GetArraySize(gaussdb_item); for (int i = 0; i < size; i++) { - object = cJSON_GetArrayItem(gaussdb_item, i); + object = Json_GetArrayItem(gaussdb_item, i); - ip_item = cJSON_GetObjectItem(object, SNOOPER_OBJNAME_DBIP); - dbname_item = cJSON_GetObjectItem(object, SNOOPER_OBJNAME_DBNAME); - usr_item = cJSON_GetObjectItem(object, SNOOPER_OBJNAME_DBUSER); - pass_item = cJSON_GetObjectItem(object, SNOOPER_OBJNAME_DBPASS); - port_item = cJSON_GetObjectItem(object, SNOOPER_OBJNAME_DBPORT); + ip_item = Json_GetObjectItem(object, SNOOPER_OBJNAME_DBIP); + dbname_item = Json_GetObjectItem(object, SNOOPER_OBJNAME_DBNAME); + usr_item = Json_GetObjectItem(object, SNOOPER_OBJNAME_DBUSER); + pass_item = Json_GetObjectItem(object, SNOOPER_OBJNAME_DBPASS); + port_item = Json_GetObjectItem(object, SNOOPER_OBJNAME_DBPORT); - if ((ip_item == NULL) || (ip_item->type != cJSON_String)) { + if ((ip_item == NULL) || (!Json_IsObjString(ip_item))) { return -1; } - if ((dbname_item == NULL) || (dbname_item->type != cJSON_String)) { + if ((dbname_item == NULL) || (!Json_IsObjString(dbname_item))) { return -1; } - if ((usr_item == NULL) || (usr_item->type != cJSON_String)) { + if ((usr_item == NULL) || (!Json_IsObjString(usr_item))) { return -1; } - if ((pass_item == NULL) || (pass_item->type != cJSON_String)) { + if ((pass_item == NULL) || (!Json_IsObjString(pass_item))) { return -1; } - if ((port_item == NULL) || (port_item->type != cJSON_Number)) { + if ((port_item == NULL) || (!Json_IsObjNumeric(port_item))) { return -1; } - ip = (char *)ip_item->valuestring; - dbname = (char *)dbname_item->valuestring; - usr = (char *)usr_item->valuestring; - pass = (char *)pass_item->valuestring; - ret = add_snooper_conf_gaussdb(probe, ip, dbname, usr, pass, (u32)port_item->valueint); + ip = (char *) Json_GetListValueString(ip_item); + dbname = (char *) Json_GetListValueString(dbname_item); + usr = (char *) Json_GetListValueString(usr_item); + pass = (char *) Json_GetListValueString(pass_item); + ret = add_snooper_conf_gaussdb(probe, ip, dbname, usr, pass, (u32) Json_GetValueInt(port_item)); if (ret != 0) { return -1; } @@ -648,7 +657,7 @@ static int parse_snooper_gaussdb(struct probe_s *probe, const cJSON *json) return 0; } -void print_snooper(struct probe_s *probe, cJSON *json) +void print_snooper(struct probe_s *probe, void *json) { print_snooper_procid(probe, json); print_snooper_procname(probe, json); @@ -698,7 +707,7 @@ int send_snooper_obj(struct probe_s *probe) return send_ipc_msg(__probe_mng_snooper->msq_id, (long)probe->probe_type, &ipc_body); } -int parse_snooper(struct probe_s *probe, const cJSON *json) +int parse_snooper(struct probe_s *probe, const void *json) { int i; diff --git a/src/lib/probe/snooper.h b/src/lib/probe/snooper.h index 46a740b893dd1f09e29dfc698f495786608d727e..a3d502f50ba18e2d2427cf974b26a2afdd466d60 100644 --- a/src/lib/probe/snooper.h +++ b/src/lib/probe/snooper.h @@ -50,8 +50,8 @@ struct snooper_conf_s { } conf; }; -void print_snooper(struct probe_s *probe, cJSON *json); -int parse_snooper(struct probe_s *probe, const cJSON *json); +void print_snooper(struct probe_s *probe, void *json); +int parse_snooper(struct probe_s *probe, const void *json); void free_snooper_conf(struct snooper_conf_s* snooper_conf); void free_snooper_obj(struct snooper_obj_s* snooper_obj); int load_snooper_bpf(struct probe_mng_s *probe_mng); diff --git a/src/probes/extends/ebpf.probe/src/l7probe/Makefile b/src/probes/extends/ebpf.probe/src/l7probe/Makefile index 14239960592fc93d6fa0fd7ef0afed543fded072..e2f708c10e0469119e892b9823539fe2af15fc8e 100644 --- a/src/probes/extends/ebpf.probe/src/l7probe/Makefile +++ b/src/probes/extends/ebpf.probe/src/l7probe/Makefile @@ -3,7 +3,6 @@ INCLUDES = $(BASE_INC) INCLUDES += -I$(ROOT_DIR)/../l7probe INCLUDES += -I$(ROOT_DIR)/../l7probe/3rd_party/pico INSTALL_DIR=/opt/gala-gopher/extend_probes -LINK_TARGET += -lcjson APP := l7probe SRC_CPLUS := $(wildcard *.cpp) SRC_CPLUS += $(CPLUSFILES) diff --git a/src/probes/extends/ebpf.probe/src/l7probe/protocol/redis/format.c b/src/probes/extends/ebpf.probe/src/l7probe/protocol/redis/format.c index 04851ae2ade22db05a5e142a3f130be5d715abb6..f04b9860218f4c74b09d4f49c635298c7f708964 100644 --- a/src/probes/extends/ebpf.probe/src/l7probe/protocol/redis/format.c +++ b/src/probes/extends/ebpf.probe/src/l7probe/protocol/redis/format.c @@ -15,7 +15,7 @@ #include #include -#include +#include #include "../utils/string_utils.h" #include "common.h" #include "format.h" @@ -310,13 +310,13 @@ const char *cmd[] = { // Returns a JSON string that formats the input arguments as a JSON array. static char *format_as_json_array(UT_array *args) { - cJSON *json_array = cJSON_CreateArray(); + void *json_array = Json_CreateArray(); for (int i = 0; i < utarray_len(args); i++) { char *str = *(char **) utarray_eltptr(args, i); - cJSON_AddItemToArray(json_array, cJSON_CreateString(str)); + Json_AddStringItemToArray(json_array, str); } - char *json_str = cJSON_PrintUnformatted(json_array); - cJSON_Delete(json_array); + char *json_str = Json_PrintUnformatted(json_array); + Json_Delete(json_array); return json_str; } diff --git a/src/probes/extends/ebpf.probe/src/mk/var.mk b/src/probes/extends/ebpf.probe/src/mk/var.mk index 5c83e968dd47940f885e2fa95fabf65672bfdb9c..c9a373f88c4a03e4ffacd78d8b2106f4aa4773b6 100644 --- a/src/probes/extends/ebpf.probe/src/mk/var.mk +++ b/src/probes/extends/ebpf.probe/src/mk/var.mk @@ -53,7 +53,7 @@ endif BTF_ENABLE = $(shell if [ -f /sys/kernel/btf/vmlinux ]; then echo "ON" ; else echo "OFF"; fi) -LINK_TARGET ?= -lpthread -lbpf -lelf -llog4cplus -lz -lconfig +LINK_TARGET ?= -lpthread -lbpf -lelf -llog4cplus -lz -lconfig -ljsoncpp EXTRA_CFLAGS ?= -g -O2 -Wall -fPIC -std=gnu11 EXTRA_CDEFINE ?= -D__TARGET_ARCH_$(TYPE) EXTRA_CDEFINE += -D__BTF_ENABLE_$(BTF_ENABLE)