GithubStar/neuron
1
0
Fork 0
mirror of https://github.com/emqx/neuron.git synced 2026-10-27 21:41:01 +08:00
Code Issues Packages Projects Releases Wiki Activity

replace strcpy with snprintf

Browse Source
This commit is contained in:
fengzero
2026-07-01 06:04:28 +00:00
parent 6827a07e27
commit 178d77639a
6 changed files with 254 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/adapter/adapter.c
+105 -65
View File
@@ -317,7 +317,7 @@ neu_adapter_t *neu_adapter_create(neu_adapter_info_t *info, bool load)
common->adapter_callbacks = &adapter->cb_funs;
common->link_state = NEU_NODE_LINK_STATE_DISCONNECTED;
common->log = get_log_category(adapter->name);
strcpy(common->name, adapter->name);
snprintf(common->name, sizeof(common->name), "%s", adapter->name);
zlog_level_switch(common->log, default_log_level);
@@ -402,7 +402,7 @@ int neu_adapter_rename(neu_adapter_t *adapter, const char *new_name)
// fix log
neu_plugin_common_t *common = neu_plugin_to_plugin_common(adapter->plugin);
common->log = log;
strcpy(common->name, adapter->name);
snprintf(common->name, sizeof(common->name), "%s", adapter->name);
zlog_level_switch(common->log, default_log_level);
if (NEU_NA_TYPE_DRIVER == adapter->module->type) {
@@ -419,7 +419,7 @@ void neu_adapter_init(neu_adapter_t *adapter, neu_node_running_state_e state)
{
neu_req_node_init_t init = { 0 };
init.state = state;
strcpy(init.node, adapter->name);
snprintf(init.node, sizeof(init.node), "%s", adapter->name);
neu_msg_t *msg = neu_msg_new(NEU_REQ_NODE_INIT, NULL, &init);
if (NULL == msg) {
@@ -427,8 +427,8 @@ void neu_adapter_init(neu_adapter_t *adapter, neu_node_running_state_e state)
return;
}
neu_reqresp_head_t *header = neu_msg_get_header(msg);
strcpy(header->sender, adapter->name);
strcpy(header->receiver, "manager");
snprintf(header->sender, sizeof(header->sender), "%s", adapter->name);
snprintf(header->receiver, sizeof(header->receiver), "%s", "manager");
int ret = neu_send_msg(adapter->control_fd, msg);
if (0 != ret) {
@@ -491,76 +491,89 @@ static int adapter_command(neu_adapter_t *adapter, neu_reqresp_head_t header,
}
neu_reqresp_head_t *pheader = neu_msg_get_header(msg);
strcpy(pheader->sender, adapter->name);
snprintf(pheader->sender, sizeof(pheader->sender), "%s", adapter->name);
switch (pheader->type) {
case NEU_REQ_DRIVER_DIRECTORY: {
neu_req_driver_directory_t *cmd = (neu_req_driver_directory_t *) data;
strcpy(pheader->receiver, cmd->driver);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->driver);
break;
}
case NEU_REQ_FUP_OPEN: {
neu_req_fup_open_t *cmd = (neu_req_fup_open_t *) data;
strcpy(pheader->receiver, cmd->driver);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->driver);
break;
}
case NEU_REQ_FUP_DATA: {
neu_req_fup_data_t *cmd = (neu_req_fup_data_t *) data;
strcpy(pheader->receiver, cmd->driver);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->driver);
break;
}
case NEU_REQ_FDOWN_OPEN: {
neu_req_fdown_open_t *cmd = (neu_req_fdown_open_t *) data;
strcpy(pheader->receiver, cmd->driver);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->driver);
break;
}
case NEU_REQ_FDOWN_DATA: {
strcpy(pheader->receiver, header.receiver);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
header.receiver);
break;
}
case NEU_RESP_FDOWN_DATA: {
neu_resp_fdown_data_t *cmd = (neu_resp_fdown_data_t *) data;
strcpy(pheader->receiver, cmd->driver);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->driver);
break;
}
case NEU_REQ_DRIVER_ACTION: {
neu_req_driver_action_t *cmd = (neu_req_driver_action_t *) data;
strcpy(pheader->receiver, cmd->driver);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->driver);
break;
}
case NEU_REQ_READ_GROUP: {
neu_req_read_group_t *cmd = (neu_req_read_group_t *) data;
strcpy(pheader->receiver, cmd->driver);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->driver);
break;
}
case NEU_REQ_READ_GROUP_PAGINATE: {
neu_req_read_group_paginate_t *cmd =
(neu_req_read_group_paginate_t *) data;
strcpy(pheader->receiver, cmd->driver);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->driver);
break;
}
case NEU_REQ_TEST_READ_TAG: {
neu_req_test_read_tag_t *cmd = (neu_req_test_read_tag_t *) data;
strcpy(pheader->receiver, cmd->driver);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->driver);
break;
}
case NEU_REQ_WRITE_TAG: {
neu_req_write_tag_t *cmd = (neu_req_write_tag_t *) data;
strcpy(pheader->receiver, cmd->driver);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->driver);
break;
}
case NEU_REQ_WRITE_TAGS: {
neu_req_write_tags_t *cmd = (neu_req_write_tags_t *) data;
strcpy(pheader->receiver, cmd->driver);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->driver);
break;
}
case NEU_REQ_WRITE_GTAGS: {
neu_req_write_gtags_t *cmd = (neu_req_write_gtags_t *) data;
strcpy(pheader->receiver, cmd->driver);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->driver);
break;
}
case NEU_REQ_DEL_NODE: {
neu_req_del_node_t *cmd = (neu_req_del_node_t *) data;
strcpy(pheader->receiver, cmd->node);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s", cmd->node);
break;
}
case NEU_REQ_UPDATE_GROUP:
@@ -568,7 +581,8 @@ static int adapter_command(neu_adapter_t *adapter, neu_reqresp_head_t header,
case NEU_REQ_DEL_GROUP:
case NEU_REQ_ADD_GROUP: {
neu_req_add_group_t *cmd = (neu_req_add_group_t *) data;
strcpy(pheader->receiver, cmd->driver);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->driver);
break;
}
case NEU_REQ_GET_TAG:
@@ -576,22 +590,25 @@ static int adapter_command(neu_adapter_t *adapter, neu_reqresp_head_t header,
case NEU_REQ_DEL_TAG:
case NEU_REQ_ADD_TAG: {
neu_req_add_tag_t *cmd = (neu_req_add_tag_t *) data;
strcpy(pheader->receiver, cmd->driver);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->driver);
break;
}
case NEU_REQ_RENAME_TAG: {
neu_req_rename_tag_t *cmd = (neu_req_rename_tag_t *) data;
strcpy(pheader->receiver, cmd->driver);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->driver);
break;
}
case NEU_REQ_IMPORT_TAGS: {
neu_req_import_tags_t *cmd = (neu_req_import_tags_t *) data;
strcpy(pheader->receiver, cmd->node);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s", cmd->node);
break;
}
case NEU_REQ_ADD_GTAG: {
neu_req_add_gtag_t *cmd = (neu_req_add_gtag_t *) data;
strcpy(pheader->receiver, cmd->driver);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->driver);
break;
}
case NEU_REQ_UPDATE_NODE:
@@ -600,134 +617,154 @@ static int adapter_command(neu_adapter_t *adapter, neu_reqresp_head_t header,
case NEU_REQ_GET_NODE_SETTING:
case NEU_REQ_NODE_SETTING: {
neu_req_node_setting_t *cmd = (neu_req_node_setting_t *) data;
strcpy(pheader->receiver, cmd->node);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s", cmd->node);
break;
}
case NEU_REQ_CHECK_SCHEMA:
case NEU_REQ_GET_DRIVER_GROUP:
case NEU_REQ_GET_SUB_DRIVER_TAGS: {
strcpy(pheader->receiver, "manager");
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s", "manager");
break;
}
case NEU_REQRESP_NODE_DELETED: {
neu_reqresp_node_deleted_t *cmd = (neu_reqresp_node_deleted_t *) data;
strcpy(pheader->receiver, cmd->node);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s", cmd->node);
break;
}
case NEU_REQ_UPDATE_LOG_LEVEL: {
neu_req_update_log_level_t *cmd = (neu_req_update_log_level_t *) data;
strcpy(pheader->receiver, cmd->node);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s", cmd->node);
break;
}
case NEU_REQ_PRGFILE_UPLOAD: {
neu_req_prgfile_upload_t *cmd = (neu_req_prgfile_upload_t *) data;
strcpy(pheader->receiver, cmd->driver);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->driver);
break;
}
case NEU_REQ_PRGFILE_PROCESS: {
neu_req_prgfile_process_t *cmd = (neu_req_prgfile_process_t *) data;
strcpy(pheader->receiver, cmd->driver);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->driver);
break;
}
case NEU_RESP_PRGFILE_PROCESS: {
strcpy(pheader->receiver, header.sender);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
header.sender);
break;
}
case NEU_REQ_SCAN_TAGS: {
neu_req_scan_tags_t *cmd = (neu_req_scan_tags_t *) data;
strcpy(pheader->receiver, cmd->driver);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->driver);
break;
}
case NEU_REQ_SERVER_CERT_SELF_SIGN: {
neu_req_server_cert_self_sign_t *cmd =
(neu_req_server_cert_self_sign_t *) data;
strcpy(pheader->receiver, cmd->app_name);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->app_name);
break;
}
case NEU_REQ_SERVER_CERT_UPLOAD: {
neu_req_server_cert_upload_t *cmd =
(neu_req_server_cert_upload_t *) data;
strcpy(pheader->receiver, cmd->app_name);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->app_name);
break;
}
case NEU_REQ_CLIENT_CERT_DELETE: {
neu_req_client_cert_del_t *cmd = (neu_req_client_cert_del_t *) data;
strcpy(pheader->receiver, cmd->app_name);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->app_name);
break;
}
case NEU_REQ_CLIENT_CERT_TRUST: {
neu_req_client_cert_trust_t *cmd = (neu_req_client_cert_trust_t *) data;
strcpy(pheader->receiver, cmd->app_name);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->app_name);
break;
}
case NEU_REQ_SERVER_CERT_INFO: {
neu_req_server_cert_data_t *cmd = (neu_req_server_cert_data_t *) data;
strcpy(pheader->receiver, cmd->app_name);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->app_name);
break;
}
case NEU_REQ_CLIENT_CERT_INFO: {
neu_req_client_cert_data_t *cmd = (neu_req_client_cert_data_t *) data;
strcpy(pheader->receiver, cmd->app_name);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->app_name);
break;
}
case NEU_REQ_SERVER_AUTH_SWITCH: {
neu_req_server_auth_switch_t *cmd =
(neu_req_server_auth_switch_t *) data;
strcpy(pheader->receiver, cmd->app_name);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->app_name);
break;
}
case NEU_REQ_SERVER_AUTH_SWITCH_STATUS: {
neu_req_server_auth_switch_status_t *cmd =
(neu_req_server_auth_switch_status_t *) data;
strcpy(pheader->receiver, cmd->app_name);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->app_name);
break;
}
case NEU_REQ_SERVER_AUTH_USER_ADD: {
neu_req_server_auth_user_add_t *cmd =
(neu_req_server_auth_user_add_t *) data;
strcpy(pheader->receiver, cmd->app_name);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->app_name);
break;
}
case NEU_REQ_SERVER_AUTH_USER_DELETE: {
neu_req_server_auth_user_del_t *cmd =
(neu_req_server_auth_user_del_t *) data;
strcpy(pheader->receiver, cmd->app_name);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->app_name);
break;
}
case NEU_REQ_SERVER_AUTH_USER_UPDATE_PWD: {
neu_req_server_auth_user_update_t *cmd =
(neu_req_server_auth_user_update_t *) data;
strcpy(pheader->receiver, cmd->app_name);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->app_name);
break;
}
case NEU_REQ_SERVER_AUTH_USER_INFO: {
neu_req_server_auth_users_info_t *cmd =
(neu_req_server_auth_users_info_t *) data;
strcpy(pheader->receiver, cmd->app_name);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->app_name);
break;
}
case NEU_REQ_SERVER_SECURITY_POLICY: {
neu_req_server_security_policy_t *cmd =
(neu_req_server_security_policy_t *) data;
strcpy(pheader->receiver, cmd->app_name);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->app_name);
break;
}
case NEU_REQ_SERVER_SECURITY_POLICY_STATUS: {
neu_req_server_security_policy_status_t *cmd =
(neu_req_server_security_policy_status_t *) data;
strcpy(pheader->receiver, cmd->app_name);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->app_name);
break;
}
case NEU_REQ_SERVER_CERT_EXPORT: {
neu_req_server_cert_export_t *cmd =
(neu_req_server_cert_export_t *) data;
strcpy(pheader->receiver, cmd->app_name);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->app_name);
break;
}
case NEU_REQ_CLIENT_CERT_UPLOAD: {
neu_req_client_cert_upload_t *cmd =
(neu_req_client_cert_upload_t *) data;
strcpy(pheader->receiver, cmd->app_name);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
cmd->app_name);
break;
}
case NEU_RESP_ERROR:
@@ -737,7 +774,8 @@ static int adapter_command(neu_adapter_t *adapter, neu_reqresp_head_t header,
case NEU_RESP_SERVER_CERT_EXPORT:
case NEU_RESP_CLIENT_CERT_INFO:
case NEU_RESP_SERVER_CERT_INFO: {
strcpy(pheader->receiver, header.sender);
snprintf(pheader->receiver, sizeof(pheader->receiver), "%s",
header.sender);
break;
}
default:
@@ -788,7 +826,7 @@ static int adapter_responseto(neu_adapter_t * adapter,
return NEU_ERR_EINTERNAL;
}
neu_reqresp_head_t *pheader = neu_msg_get_header(msg);
strcpy(pheader->sender, adapter->name);
snprintf(pheader->sender, sizeof(pheader->sender), "%s", adapter->name);
int ret = neu_send_msg_to(adapter->control_fd, &dst, msg);
if (0 != ret) {
@@ -1372,7 +1410,7 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
reply(adapter, header, &error);
} else {
header->type = NEU_RESP_GET_NODE_SETTING;
strcpy(resp.node, adapter->name);
snprintf(resp.node, sizeof(resp.node), "%s", adapter->name);
reply(adapter, header, &resp);
}
break;
@@ -1491,9 +1529,9 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
}
}
strcpy(resp.driver, cmd->driver);
strcpy(resp.group, cmd->group);
strcpy(resp.new_name, cmd->new_name);
snprintf(resp.driver, sizeof(resp.driver), "%s", cmd->driver);
snprintf(resp.group, sizeof(resp.group), "%s", cmd->group);
snprintf(resp.new_name, sizeof(resp.new_name), "%s", cmd->new_name);
header->type = NEU_RESP_UPDATE_DRIVER_GROUP;
neu_msg_exchange(header);
reply(adapter, header, &resp);
@@ -1551,10 +1589,11 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
neu_req_node_rename_t *cmd = (neu_req_node_rename_t *) &header[1];
neu_resp_node_rename_t resp = { 0 };
resp.error = neu_adapter_rename(adapter, cmd->new_name);
strcpy(header->receiver, header->sender);
strcpy(header->sender, cmd->new_name);
strcpy(resp.node, cmd->node);
strcpy(resp.new_name, cmd->new_name);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
snprintf(header->sender, sizeof(header->sender), "%s", cmd->new_name);
snprintf(resp.node, sizeof(resp.node), "%s", cmd->node);
snprintf(resp.new_name, sizeof(resp.new_name), "%s", cmd->new_name);
header->type = NEU_RESP_NODE_RENAME;
reply(adapter, header, &resp);
break;
@@ -1735,7 +1774,8 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
resp.error = NEU_ERR_LIBRARY_NOT_FOUND;
} else {
neu_req_add_gtag_t gtag_cmd = { 0 };
strcpy(gtag_cmd.driver, cmd->node);
snprintf(gtag_cmd.driver, sizeof(gtag_cmd.driver), "%s",
cmd->node);
if (neu_adapter_parse_json_to_gtags(json_file_path,
&gtag_cmd) == 0) {
@@ -1873,13 +1913,13 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
header->type = NEU_RESP_NODE_UNINIT;
neu_msg_exchange(header);
strcpy(header->sender, adapter->name);
strcpy(cmd->node, adapter->name);
snprintf(header->sender, sizeof(header->sender), "%s", adapter->name);
snprintf(cmd->node, sizeof(cmd->node), "%s", adapter->name);
neu_msg_gen(header, cmd);
strcpy(name, adapter->name);
strcpy(receiver, header->receiver);
snprintf(name, sizeof(name), "%s", adapter->name);
snprintf(receiver, sizeof(receiver), "%s", header->receiver);
int ret = neu_send_msg(adapter->control_fd, msg);
if (0 != ret) {
@@ -2428,7 +2468,7 @@ inline static void notify_monitor(neu_adapter_t * adapter,
return;
}
neu_reqresp_head_t *header = neu_msg_get_header(msg);
strcpy(header->receiver, "monitor");
snprintf(header->receiver, sizeof(header->receiver), "%s", "monitor");
strncpy(header->sender, adapter->name, NEU_NODE_NAME_LEN);
int ret = neu_send_msg(adapter->control_fd, msg);
if (0 != ret) {
src/adapter/driver/driver.c
+12 -12
View File
@@ -191,8 +191,8 @@ static void write_responses(neu_adapter_t *adapter, void *r,
neu_driver_write_responses_t *resp = &response[i];
neu_resp_write_tags_ele_t ele = { 0 };
strcpy(ele.group, resp->group);
strcpy(ele.tag, resp->name);
snprintf(ele.group, sizeof(ele.group), "%s", resp->group);
snprintf(ele.tag, sizeof(ele.tag), "%s", resp->name);
ele.error = resp->error;
nlog_notice(
@@ -371,7 +371,7 @@ static void directory_response(neu_adapter_t *adapter, void *r, int error,
neu_driver_file_info_t * info = &infos[i];
neu_resp_driver_directory_file_t file = { 0 };
strcpy(file.name, info->path);
snprintf(file.name, sizeof(file.name), "%s", info->path);
file.ftype = info->ftype;
file.size = info->size;
file.timestamp = info->mtime;
@@ -861,7 +861,7 @@ void neu_adapter_driver_read_group(neu_adapter_driver_t *driver,
utarray_foreach(tags, neu_datatag_t *, tag)
{
neu_resp_tag_value_meta_t tag_value = { 0 };
strcpy(tag_value.tag, tag->name);
snprintf(tag_value.tag, sizeof(tag_value.tag), "%s", tag->name);
tag_value.value.type = NEU_TYPE_ERROR;
tag_value.value.value.i32 = NEU_ERR_PLUGIN_NOT_RUNNING;
@@ -873,7 +873,7 @@ void neu_adapter_driver_read_group(neu_adapter_driver_t *driver,
utarray_foreach(tags, neu_datatag_t *, tag)
{
neu_resp_tag_value_meta_t tag_value = { 0 };
strcpy(tag_value.tag, tag->name);
snprintf(tag_value.tag, sizeof(tag_value.tag), "%s", tag->name);
tag_value.value.type = NEU_TYPE_ERROR;
tag_value.value.value.i32 =
NEU_ERR_PLUGIN_NOT_SUPPORT_READ_SYNC;
@@ -946,7 +946,7 @@ void neu_adapter_driver_read_group_paginate(neu_adapter_driver_t *driver,
utarray_foreach(tags, neu_datatag_t *, tag)
{
neu_resp_tag_value_meta_paginate_t tag_value = { 0 };
strcpy(tag_value.tag, tag->name);
snprintf(tag_value.tag, sizeof(tag_value.tag), "%s", tag->name);
tag_value.value.type = NEU_TYPE_ERROR;
tag_value.value.value.i32 = NEU_ERR_PLUGIN_NOT_RUNNING;
@@ -970,7 +970,7 @@ void neu_adapter_driver_read_group_paginate(neu_adapter_driver_t *driver,
utarray_foreach(tags, neu_datatag_t *, tag)
{
neu_resp_tag_value_meta_paginate_t tag_value = { 0 };
strcpy(tag_value.tag, tag->name);
snprintf(tag_value.tag, sizeof(tag_value.tag), "%s", tag->name);
tag_value.value.type = NEU_TYPE_ERROR;
tag_value.value.value.i32 =
NEU_ERR_PLUGIN_NOT_SUPPORT_READ_SYNC;
@@ -2834,7 +2834,7 @@ static void read_report_group(int64_t timestamp, int64_t timeout,
if (neu_driver_cache_meta_get(cache, group, tag->name, &value,
&tag_value.metas,
&tag_value.n_meta) != 0) {
strcpy(tag_value.tag, tag->name);
snprintf(tag_value.tag, sizeof(tag_value.tag), "%s", tag->name);
tag_value.value.type = NEU_TYPE_ERROR;
tag_value.value.value.i32 = NEU_ERR_PLUGIN_TAG_NOT_READY;
@@ -2842,7 +2842,7 @@ static void read_report_group(int64_t timestamp, int64_t timeout,
continue;
}
}
strcpy(tag_value.tag, tag->name);
snprintf(tag_value.tag, sizeof(tag_value.tag), "%s", tag->name);
tag_value.datatag = *tag;
tag_value.datatag.bias = tag->bias;
@@ -3022,7 +3022,7 @@ static void read_group(int64_t timestamp, int64_t timeout,
neu_resp_tag_value_meta_t tag_value = { 0 };
neu_driver_cache_value_t value = { 0 };
strcpy(tag_value.tag, tag->name);
snprintf(tag_value.tag, sizeof(tag_value.tag), "%s", tag->name);
tag_value.datatag = *tag;
tag_value.datatag.bias = tag->bias;
@@ -3201,7 +3201,7 @@ static void read_group_paginate(int64_t timestamp, int64_t timeout,
neu_resp_tag_value_meta_paginate_t tag_value = { 0 };
neu_driver_cache_value_t value = { 0 };
strcpy(tag_value.tag, tag->name);
snprintf(tag_value.tag, sizeof(tag_value.tag), "%s", tag->name);
tag_value.datatag.name = strdup(tag->name);
tag_value.datatag.address = strdup(tag->address);
@@ -3417,7 +3417,7 @@ void neu_adapter_driver_subscribe(neu_adapter_driver_t *driver,
}
}
strcpy(sub_app.app, req->app);
snprintf(sub_app.app, sizeof(sub_app.app), "%s", req->app);
sub_app.addr.sun_family = AF_UNIX;
snprintf(sub_app.addr.sun_path, sizeof(sub_app.addr.sun_path),
"%cneuron-%" PRIu16, '\0', req->port);
src/connection/mqtt_client.c
+1 -1
View File
@@ -193,7 +193,7 @@ static char *write_string_to_random_file(const char *str)
char *path = calloc(1, strlen(filename) + 1);
if (path) {
strcpy(path, filename);
memcpy(path, filename, strlen(filename) + 1);
}
return path;
src/core/manager.c
+118 -68
View File
@@ -190,7 +190,7 @@ void neu_manager_destroy(neu_manager_t *manager)
{
neu_msg_t *msg = neu_msg_new(NEU_REQ_NODE_UNINIT, NULL, &uninit);
neu_reqresp_head_t *header = neu_msg_get_header(msg);
strcpy(header->sender, "manager");
snprintf(header->sender, sizeof(header->sender), "%s", "manager");
if (0 != neu_send_msg_to(manager->server_fd, addr, msg)) {
nlog_error("manager -> %s uninit msg send fail",
&addr->sun_path[1]);
@@ -309,7 +309,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(cmd->schema_file);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_LIBRARY_NAME_NOT_CONFORM;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -320,7 +321,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(cmd->schema_file);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_LIBRARY_NAME_CONFLICT;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -333,7 +335,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(cmd->schema_file);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_BODY_IS_WRONG;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -364,7 +367,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(so_tmp_path);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_LIBRARY_MODULE_VERSION_NOT_MATCH;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -378,7 +382,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(so_tmp_path);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_LIBRARY_MODULE_ALREADY_EXIST;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -390,7 +395,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(so_tmp_path);
header->type = NEU_RESP_ERROR;
e.error = error;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -402,7 +408,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(so_tmp_path);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_LIBRARY_MODULE_KIND_NOT_SUPPORT;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -416,7 +423,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(so_tmp_path);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_BODY_IS_WRONG;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -429,7 +437,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(schema_tmp_path);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_LIBRARY_ADD_FAIL;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -442,7 +451,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(schema_tmp_path);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_LIBRARY_ADD_FAIL;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -460,7 +470,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(schema_tmp_path);
header->type = NEU_RESP_ERROR;
e.error = error;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -477,7 +488,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
utarray_free(nodes);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_LIBRARY_IN_USE;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -493,7 +505,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
}
header->type = NEU_RESP_ERROR;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -511,7 +524,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(cmd->schema_file);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_LIBRARY_NAME_NOT_CONFORM;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -522,7 +536,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(cmd->schema_file);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_LIBRARY_NOT_FOUND;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -535,7 +550,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(cmd->schema_file);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_BODY_IS_WRONG;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -565,7 +581,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(so_tmp_path);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_LIBRARY_MODULE_VERSION_NOT_MATCH;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -578,7 +595,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(so_tmp_path);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_LIBRARY_UPDATE_FAIL;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -592,7 +610,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(so_tmp_path);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_LIBRARY_UPDATE_FAIL;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -608,7 +627,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(so_tmp_path);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_LIBRARY_MODULE_NOT_EXISTS;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -620,7 +640,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(so_tmp_path);
header->type = NEU_RESP_ERROR;
e.error = error;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -632,7 +653,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(so_tmp_path);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_LIBRARY_MODULE_KIND_NOT_SUPPORT;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -646,7 +668,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(so_tmp_path);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_BODY_IS_WRONG;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -665,7 +688,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
nlog_warn("library %s is using", cmd->library);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_LIBRARY_IN_USE;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -681,7 +705,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(schema_tmp_path);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_LIBRARY_UPDATE_FAIL;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -694,7 +719,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(schema_tmp_path);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_LIBRARY_UPDATE_FAIL;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -707,7 +733,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(schema_tmp_path);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_LIBRARY_UPDATE_FAIL;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -721,7 +748,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(schema_tmp_path);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_LIBRARY_UPDATE_FAIL;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -732,7 +760,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
free(schema_tmp_path);
header->type = NEU_RESP_ERROR;
e.error = NEU_ERR_SUCCESS;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
@@ -742,18 +771,20 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
neu_resp_get_plugin_t resp = { .plugins = plugins };
header->type = NEU_RESP_GET_PLUGIN;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &resp);
break;
}
case NEU_REQ_CHECK_SCHEMA: {
neu_req_check_schema_t *cmd = (neu_req_check_schema_t *) &header[1];
neu_resp_check_schema_t resp = { 0 };
strcpy(resp.schema, cmd->schema);
snprintf(resp.schema, sizeof(resp.schema), "%s", cmd->schema);
resp.exist = neu_plugin_manager_schema_exist(manager->plugin_manager,
cmd->schema);
header->type = NEU_RESP_CHECK_SCHEMA;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &resp);
break;
}
@@ -776,7 +807,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
neu_req_add_node_fini(cmd);
header->type = NEU_RESP_ERROR;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -814,7 +846,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
bool single =
neu_node_manager_is_single(manager->node_manager, cmd->node);
strcpy(header->receiver, cmd->node);
snprintf(header->receiver, sizeof(header->receiver), "%s", cmd->node);
if (adapter == NULL) {
error.error = NEU_ERR_NODE_NOT_EXIST;
header->type = NEU_RESP_ERROR;
@@ -847,8 +879,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
break;
}
neu_reqresp_head_t *hd = neu_msg_get_header(msg);
strcpy(hd->receiver, sub->driver);
strcpy(hd->sender, "manager");
snprintf(hd->receiver, sizeof(hd->receiver), "%s", sub->driver);
snprintf(hd->sender, sizeof(hd->sender), "%s", "manager");
forward_msg(manager, hd, hd->receiver);
}
utarray_free(subscriptions);
@@ -856,14 +888,14 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
notify_monitor(manager, NEU_REQ_DEL_NODE_EVENT, cmd);
neu_reqresp_node_deleted_t resp = { 0 };
strcpy(resp.node, header->receiver);
snprintf(resp.node, sizeof(resp.node), "%s", header->receiver);
// notify MQTT about node removal
if (0 == strcmp(adapter->module->module_name, "MQTT")) {
msg = neu_msg_new(NEU_REQRESP_NODE_DELETED, NULL, &resp);
if (NULL != msg) {
neu_reqresp_head_t *hd = neu_msg_get_header(msg);
strcpy(hd->receiver, cmd->node);
strcpy(hd->sender, "manager");
snprintf(hd->receiver, sizeof(hd->receiver), "%s", cmd->node);
snprintf(hd->sender, sizeof(hd->sender), "%s", "manager");
reply(manager, hd, &resp);
}
}
@@ -881,8 +913,10 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
break;
}
header = neu_msg_get_header(msg);
strcpy(header->receiver, app->app_name);
strcpy(header->sender, "manager");
snprintf(header->receiver, sizeof(header->receiver), "%s",
app->app_name);
snprintf(header->sender, sizeof(header->sender), "%s",
"manager");
reply(manager, header, &resp);
}
utarray_free(apps);
@@ -913,7 +947,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
neu_resp_get_node_t resp = { .nodes = nodes };
header->type = NEU_RESP_GET_NODE;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &resp);
break;
}
@@ -942,7 +977,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
}
header->type = NEU_RESP_ERROR;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &error);
break;
}
@@ -977,7 +1013,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
neu_req_subscribe_groups_fini(cmd);
header->type = NEU_RESP_ERROR;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &error);
break;
}
@@ -1002,7 +1039,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
}
header->type = NEU_RESP_ERROR;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &error);
break;
}
@@ -1023,7 +1061,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
}
header->type = NEU_RESP_ERROR;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &error);
break;
}
@@ -1034,7 +1073,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
manager, cmd->app, cmd->driver, cmd->group);
neu_resp_get_subscribe_group_t resp = { .groups = groups };
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
header->type = NEU_RESP_GET_SUBSCRIBE_GROUP;
reply(manager, header, &resp);
break;
@@ -1046,7 +1086,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
neu_manager_get_driver_groups(manager, cmd->app, cmd->name);
neu_resp_get_subscribe_group_t resp = { .groups = groups };
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
header->type = NEU_RESP_GET_DRIVER_SUBSCRIBE_GROUP;
reply(manager, header, &resp);
break;
@@ -1065,8 +1106,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
neu_node_manager_find(manager->node_manager, info->driver);
assert(driver != NULL);
strcpy(in.driver, info->driver);
strcpy(in.group, info->group);
snprintf(in.driver, sizeof(in.driver), "%s", info->driver);
snprintf(in.group, sizeof(in.group), "%s", info->group);
neu_adapter_driver_get_value_tag((neu_adapter_driver_t *) driver,
info->group, &in.tags);
@@ -1074,7 +1115,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
}
utarray_free(groups);
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
header->type = NEU_RESP_GET_SUB_DRIVER_TAGS;
reply(manager, header, &resp);
@@ -1087,7 +1129,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
manager, cmd->app, cmd->driver, cmd->group);
neu_resp_get_subscribe_group_t resp = { .groups = groups };
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
header->type = NEU_RESP_GET_DATALAYERS_GROUPS;
reply(manager, header, &resp);
break;
@@ -1114,8 +1157,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
neu_node_manager_find(manager->node_manager, info->driver);
assert(driver != NULL);
strcpy(in.driver, info->driver);
strcpy(in.group, info->group);
snprintf(in.driver, sizeof(in.driver), "%s", info->driver);
snprintf(in.group, sizeof(in.group), "%s", info->group);
neu_adapter_driver_get_value_tag((neu_adapter_driver_t *) driver,
info->group, &in.tags);
@@ -1132,7 +1175,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
break;
}
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
header->type = NEU_RESP_GET_DATALAYERS_TAGS;
reply(manager, header, &resp);
@@ -1171,8 +1215,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
utarray_free(in.tags);
if (utarray_len(filtered_tags) > 0) {
strcpy(in.driver, info->driver);
strcpy(in.group, info->group);
snprintf(in.driver, sizeof(in.driver), "%s", info->driver);
snprintf(in.group, sizeof(in.group), "%s", info->group);
in.tags = filtered_tags;
utarray_push_back(resp.infos, &in);
found = true;
@@ -1193,7 +1237,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
break;
}
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
header->type = NEU_RESP_GET_DATALAYERS_TAG;
reply(manager, header, &resp);
@@ -1211,8 +1256,9 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
resp.states = utarray_clone(states);
resp.core_level = manager->log_level;
strcpy(header->receiver, header->sender);
strcpy(header->sender, "manager");
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
snprintf(header->sender, sizeof(header->sender), "%s", "manager");
header->type = NEU_RESP_GET_NODES_STATE;
reply(manager, header, &resp);
@@ -1224,8 +1270,9 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
resp.groups = neu_manager_get_driver_group(manager);
strcpy(header->receiver, header->sender);
strcpy(header->sender, "manager");
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
snprintf(header->sender, sizeof(header->sender), "%s", "manager");
header->type = NEU_RESP_GET_DRIVER_GROUP;
reply(manager, header, &resp);
@@ -1649,7 +1696,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
neu_req_driver_array_fini(cmd);
header->type = NEU_RESP_ERROR;
strcpy(header->receiver, header->sender);
snprintf(header->receiver, sizeof(header->receiver), "%s",
header->sender);
reply(manager, header, &e);
break;
}
@@ -1711,8 +1759,10 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
node_header.ctx = NULL;
node_header.otel_trace_type = header->otel_trace_type;
node_header.monitor = false;
strcpy(node_header.sender, "manager");
strcpy(node_header.receiver, node_info->node);
snprintf(node_header.sender, sizeof(node_header.sender), "%s",
"manager");
snprintf(node_header.receiver, sizeof(node_header.receiver),
"%s", node_info->node);
node_cmd.log_level = cmd->log_level;
@@ -2032,8 +2082,8 @@ inline static void notify_monitor(neu_manager_t * manager,
return;
}
neu_reqresp_head_t *header = neu_msg_get_header(msg);
strcpy(header->sender, "manager");
strcpy(header->receiver, "monitor");
snprintf(header->sender, sizeof(header->sender), "%s", "manager");
snprintf(header->receiver, sizeof(header->receiver), "%s", "monitor");
int ret = neu_send_msg_to(manager->server_fd, &addr, msg);
if (0 != ret) {
src/core/node_manager.c
+15 -9
View File
@@ -227,8 +227,9 @@ UT_array *neu_node_manager_get(neu_node_manager_t *mgr, int type)
if (!el->is_static && el->display) {
if (el->adapter->module->type & type) {
neu_resp_node_info_t info = { 0 };
strcpy(info.node, el->adapter->name);
strcpy(info.plugin, el->adapter->module->module_name);
snprintf(info.node, sizeof(info.node), "%s", el->adapter->name);
snprintf(info.plugin, sizeof(info.plugin), "%s",
el->adapter->module->module_name);
utarray_push_back(array, &info);
}
}
@@ -304,7 +305,9 @@ UT_array *neu_node_manager_filter(neu_node_manager_t *mgr, int type,
char tag_split_array[10][NEU_NODE_TAGS_LEN] = { 0 };
char * token = strtok(node_tmp, ",");
while (token != NULL && index < 10) {
strcpy(tag_split_array[index], token);
snprintf(tag_split_array[index],
sizeof(tag_split_array[index]), "%s",
token);
index++;
token = strtok(NULL, ",");
}
@@ -353,9 +356,11 @@ UT_array *neu_node_manager_filter(neu_node_manager_t *mgr, int type,
}
neu_resp_node_info_t info = { 0 };
strcpy(info.node, el->adapter->name);
strcpy(info.tags, el->tags ? el->tags : "");
strcpy(info.plugin, el->adapter->module->module_name);
snprintf(info.node, sizeof(info.node), "%s", el->adapter->name);
snprintf(info.tags, sizeof(info.tags), "%s",
el->tags ? el->tags : "");
snprintf(info.plugin, sizeof(info.plugin), "%s",
el->adapter->module->module_name);
if (sort_delay) {
neu_metric_entry_t *e = NULL;
if (NULL != el->adapter->metrics) {
@@ -389,8 +394,9 @@ UT_array *neu_node_manager_get_all(neu_node_manager_t *mgr)
HASH_ITER(hh, mgr->nodes, el, tmp)
{
neu_resp_node_info_t info = { 0 };
strcpy(info.node, el->adapter->name);
strcpy(info.plugin, el->adapter->module->module_name);
snprintf(info.node, sizeof(info.node), "%s", el->adapter->name);
snprintf(info.plugin, sizeof(info.plugin), "%s",
el->adapter->module->module_name);
utarray_push_back(array, &info);
}
@@ -537,7 +543,7 @@ UT_array *neu_node_manager_get_state(neu_node_manager_t *mgr)
neu_nodes_state_t state = { 0 };
if (!el->is_static && el->display) {
strcpy(state.node, el->adapter->name);
snprintf(state.node, sizeof(state.node), "%s", el->adapter->name);
state.state.running = el->adapter->state;
state.state.link =
neu_plugin_to_plugin_common(el->adapter->plugin)->link_state;
src/utils/tpy.c
+3 -2
View File
@@ -194,12 +194,13 @@ static neu_type_e to_neu_type(char *type)
void neu_tpy_to_msg(char *driver, tpy_t *tpy, neu_req_add_gtag_t *cmd)
{
strcpy(cmd->driver, driver);
snprintf(cmd->driver, sizeof(cmd->driver), "%s", driver);
cmd->n_group = tpy->n_statics;
cmd->groups = calloc(cmd->n_group, sizeof(neu_gdatatag_t));
for (int i = 0; i < cmd->n_group; i++) {
strcpy(cmd->groups[i].group, tpy->statics[i].name);
snprintf(cmd->groups[i].group, sizeof(cmd->groups[i].group), "%s",
tpy->statics[i].name);
cmd->groups[i].interval = 1000;
cmd->groups[i].n_tag = tpy->statics[i].n_vars;
cmd->groups[i].tags =