diff --git a/CMakeLists.txt b/CMakeLists.txt index f6dc6355..b63bed48 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -74,6 +74,7 @@ set(NEURON_BASE_SOURCES src/base/tag_sort.c src/base/group.c src/base/metrics.c + src/base/msg.c src/base/template.c src/connection/connection.c src/connection/connection_eth.c diff --git a/include/neuron/msg.h b/include/neuron/msg.h index 9dbfb32b..0ce592b4 100644 --- a/include/neuron/msg.h +++ b/include/neuron/msg.h @@ -1135,7 +1135,6 @@ typedef struct neu_req_update_log_level { } neu_req_update_log_level_t; void neu_msg_gen(neu_reqresp_head_t *header, void *data); -void * neu_trans_data_gen(neu_reqresp_head_t *header, void *data); neu_reqresp_head_t *neu_msg_dup(neu_reqresp_head_t *header); inline static void neu_msg_exchange(neu_reqresp_head_t *header) diff --git a/src/adapter/adapter.c b/src/adapter/adapter.c index ae95ee0c..c2545fd4 100644 --- a/src/adapter/adapter.c +++ b/src/adapter/adapter.c @@ -1618,300 +1618,3 @@ inline static void notify_monitor(neu_adapter_t * adapter, errno); } } - -void neu_msg_gen(neu_reqresp_head_t *header, void *data) -{ - size_t data_size = 0; - - switch (header->type) { - case NEU_REQRESP_TRANS_DATA: - data_size = sizeof(neu_reqresp_trans_data_t); - break; - case NEU_REQ_NODE_INIT: - case NEU_REQ_NODE_UNINIT: - case NEU_RESP_NODE_UNINIT: - data_size = sizeof(neu_req_node_init_t); - break; - case NEU_RESP_ERROR: - data_size = sizeof(neu_resp_error_t); - break; - case NEU_REQ_ADD_PLUGIN: - data_size = sizeof(neu_req_add_plugin_t); - break; - case NEU_REQ_DEL_PLUGIN: - data_size = sizeof(neu_req_del_plugin_t); - break; - case NEU_REQ_UPDATE_PLUGIN: - data_size = sizeof(neu_req_update_plugin_t); - break; - case NEU_REQ_GET_PLUGIN: - data_size = sizeof(neu_req_get_plugin_t); - break; - case NEU_RESP_GET_PLUGIN: - data_size = sizeof(neu_resp_get_plugin_t); - break; - case NEU_REQ_ADD_TEMPLATE: - data_size = sizeof(neu_req_add_template_t); - break; - case NEU_REQ_DEL_TEMPLATE: - data_size = sizeof(neu_req_del_template_t); - break; - case NEU_REQ_GET_TEMPLATE: - data_size = sizeof(neu_req_get_template_t); - break; - case NEU_RESP_GET_TEMPLATE: - data_size = sizeof(neu_resp_get_template_t); - break; - case NEU_REQ_GET_TEMPLATES: - data_size = sizeof(neu_req_get_templates_t); - break; - case NEU_RESP_GET_TEMPLATES: - data_size = sizeof(neu_resp_get_templates_t); - break; - case NEU_REQ_ADD_TEMPLATE_GROUP: - data_size = sizeof(neu_req_add_template_group_t); - break; - case NEU_REQ_DEL_TEMPLATE_GROUP: - data_size = sizeof(neu_req_del_template_group_t); - break; - case NEU_REQ_UPDATE_TEMPLATE_GROUP: - data_size = sizeof(neu_req_update_template_group_t); - break; - case NEU_REQ_GET_TEMPLATE_GROUP: - data_size = sizeof(neu_req_get_template_group_t); - break; - case NEU_REQ_ADD_TEMPLATE_TAG: - data_size = sizeof(neu_req_add_template_tag_t); - break; - case NEU_REQ_DEL_TEMPLATE_TAG: - data_size = sizeof(neu_req_del_template_tag_t); - break; - case NEU_REQ_UPDATE_TEMPLATE_TAG: - data_size = sizeof(neu_req_update_template_tag_t); - break; - case NEU_REQ_GET_TEMPLATE_TAG: - data_size = sizeof(neu_req_get_template_tag_t); - break; - case NEU_REQ_INST_TEMPLATE: - data_size = sizeof(neu_req_inst_template_t); - break; - case NEU_REQ_INST_TEMPLATES: - data_size = sizeof(neu_req_inst_templates_t); - break; - case NEU_REQ_ADD_NODE: - case NEU_REQ_ADD_NODE_EVENT: - data_size = sizeof(neu_req_add_node_t); - break; - case NEU_REQ_UPDATE_NODE: - data_size = sizeof(neu_req_update_node_t); - break; - case NEU_REQ_DEL_NODE: - case NEU_REQ_DEL_NODE_EVENT: - data_size = sizeof(neu_req_del_node_t); - break; - case NEU_REQ_GET_NODE: - data_size = sizeof(neu_req_get_node_t); - break; - case NEU_RESP_GET_NODE: - data_size = sizeof(neu_resp_get_node_t); - break; - case NEU_REQ_ADD_GROUP: - case NEU_REQ_ADD_GROUP_EVENT: - data_size = sizeof(neu_req_add_group_t); - break; - case NEU_REQ_UPDATE_GROUP: - case NEU_REQ_UPDATE_DRIVER_GROUP: - case NEU_REQ_UPDATE_GROUP_EVENT: - data_size = sizeof(neu_req_update_group_t); - break; - case NEU_RESP_UPDATE_DRIVER_GROUP: - data_size = sizeof(neu_resp_update_group_t); - break; - case NEU_REQ_DEL_GROUP: - case NEU_REQ_DEL_GROUP_EVENT: - data_size = sizeof(neu_req_del_group_t); - break; - case NEU_REQ_GET_DRIVER_GROUP: - case NEU_REQ_GET_GROUP: - data_size = sizeof(neu_req_get_group_t); - break; - case NEU_RESP_GET_GROUP: - data_size = sizeof(neu_resp_get_group_t); - break; - case NEU_REQ_ADD_TAG: - case NEU_REQ_ADD_TAG_EVENT: - data_size = sizeof(neu_req_add_tag_t); - break; - case NEU_RESP_ADD_TAG: - case NEU_RESP_ADD_GTAG: - case NEU_RESP_ADD_TEMPLATE_TAG: - data_size = sizeof(neu_resp_add_tag_t); - break; - case NEU_REQ_ADD_GTAG: - data_size = sizeof(neu_req_add_gtag_t); - break; - case NEU_RESP_UPDATE_TAG: - case NEU_RESP_UPDATE_TEMPLATE_TAG: - data_size = sizeof(neu_resp_update_tag_t); - break; - case NEU_REQ_UPDATE_TAG: - case NEU_REQ_UPDATE_TAG_EVENT: - data_size = sizeof(neu_req_update_tag_t); - break; - case NEU_REQ_DEL_TAG: - case NEU_REQ_DEL_TAG_EVENT: - data_size = sizeof(neu_req_del_tag_t); - break; - case NEU_REQ_GET_TAG: - data_size = sizeof(neu_req_get_tag_t); - break; - case NEU_RESP_GET_TAG: - case NEU_RESP_GET_TEMPLATE_TAG: - data_size = sizeof(neu_resp_get_tag_t); - break; - case NEU_REQ_SUBSCRIBE_GROUP: - case NEU_REQ_UPDATE_SUBSCRIBE_GROUP: - data_size = sizeof(neu_req_subscribe_t); - break; - case NEU_REQ_UNSUBSCRIBE_GROUP: - data_size = sizeof(neu_req_unsubscribe_t); - break; - case NEU_REQ_SUBSCRIBE_GROUPS: - data_size = sizeof(neu_req_subscribe_groups_t); - break; - case NEU_REQ_GET_SUBSCRIBE_GROUP: - case NEU_REQ_GET_SUB_DRIVER_TAGS: - data_size = sizeof(neu_req_get_subscribe_group_t); - break; - case NEU_RESP_GET_SUB_DRIVER_TAGS: - data_size = sizeof(neu_resp_get_sub_driver_tags_t); - break; - case NEU_RESP_GET_SUBSCRIBE_GROUP: - data_size = sizeof(neu_resp_get_subscribe_group_t); - break; - case NEU_REQ_NODE_SETTING: - case NEU_REQ_NODE_SETTING_EVENT: - data_size = sizeof(neu_req_node_setting_t); - break; - case NEU_REQ_GET_NODE_SETTING: - data_size = sizeof(neu_req_get_node_setting_t); - break; - case NEU_RESP_GET_NODE_SETTING: - data_size = sizeof(neu_resp_get_node_setting_t); - break; - case NEU_REQ_NODE_CTL: - case NEU_REQ_NODE_CTL_EVENT: - data_size = sizeof(neu_req_node_ctl_t); - break; - case NEU_REQ_NODE_RENAME: - data_size = sizeof(neu_req_node_rename_t); - break; - case NEU_RESP_NODE_RENAME: - data_size = sizeof(neu_resp_node_rename_t); - break; - case NEU_REQ_GET_NODE_STATE: - data_size = sizeof(neu_req_get_node_state_t); - break; - case NEU_RESP_GET_NODE_STATE: - data_size = sizeof(neu_resp_get_node_state_t); - break; - case NEU_REQ_GET_NODES_STATE: - data_size = sizeof(neu_req_get_nodes_state_t); - break; - case NEU_REQRESP_NODES_STATE: - case NEU_RESP_GET_NODES_STATE: - data_size = sizeof(neu_resp_get_nodes_state_t); - break; - case NEU_REQ_READ_GROUP: - data_size = sizeof(neu_req_read_group_t); - break; - case NEU_REQ_WRITE_TAG: - data_size = sizeof(neu_req_write_tag_t); - break; - case NEU_REQ_WRITE_TAGS: - data_size = sizeof(neu_req_write_tags_t); - break; - case NEU_REQ_WRITE_GTAGS: - data_size = sizeof(neu_req_write_gtags_t); - break; - case NEU_RESP_READ_GROUP: - data_size = sizeof(neu_resp_read_group_t); - break; - case NEU_REQRESP_NODE_DELETED: - data_size = sizeof(neu_reqresp_node_deleted_t); - break; - case NEU_RESP_GET_DRIVER_GROUP: - data_size = sizeof(neu_resp_get_driver_group_t); - break; - case NEU_REQ_ADD_NDRIVER_MAP: - case NEU_REQ_DEL_NDRIVER_MAP: - data_size = sizeof(neu_req_ndriver_map_t); - break; - case NEU_REQ_GET_NDRIVER_MAPS: - data_size = sizeof(neu_req_get_ndriver_maps_t); - break; - case NEU_RESP_GET_NDRIVER_MAPS: - data_size = sizeof(neu_resp_get_ndriver_maps_t); - break; - case NEU_REQ_UPDATE_NDRIVER_TAG_PARAM: - data_size = sizeof(neu_req_update_ndriver_tag_param_t); - break; - case NEU_REQ_UPDATE_NDRIVER_TAG_INFO: - data_size = sizeof(neu_req_update_ndriver_tag_info_t); - break; - case NEU_REQ_GET_NDRIVER_TAGS: - data_size = sizeof(neu_req_get_ndriver_tags_t); - break; - case NEU_RESP_GET_NDRIVER_TAGS: - data_size = sizeof(neu_resp_get_ndriver_tags_t); - break; - case NEU_REQ_UPDATE_LOG_LEVEL: - data_size = sizeof(neu_req_update_log_level_t); - break; - default: - assert(false); - break; - } - - assert(NEU_MSG_MAX_SIZE >= sizeof(neu_reqresp_head_t) + data_size); - memcpy((uint8_t *) &header[1], data, data_size); - header->len = sizeof(neu_reqresp_head_t) + data_size; -} - -neu_reqresp_head_t *neu_msg_dup(neu_reqresp_head_t *header) -{ - neu_reqresp_head_t *new_header = calloc(1, header->len); - - *new_header = *header; - switch (new_header->type) { - case NEU_REQ_WRITE_TAG: { - neu_req_write_tag_t *wt = (neu_req_write_tag_t *) &header[1]; - neu_req_write_tag_t *new_wt = (neu_req_write_tag_t *) &new_header[1]; - - *new_wt = *wt; - break; - } - case NEU_REQ_WRITE_TAGS: { - neu_req_write_tags_t *wts = (neu_req_write_tags_t *) &header[1]; - neu_req_write_tags_t *new_wts = (neu_req_write_tags_t *) &new_header[1]; - - *new_wts = *wts; - break; - } - case NEU_REQ_WRITE_GTAGS: { - neu_req_write_gtags_t *wgts = (neu_req_write_gtags_t *) &header[1]; - neu_req_write_gtags_t *new_wgts = - (neu_req_write_gtags_t *) &new_header[1]; - - *new_wgts = *wgts; - break; - } - default: - nlog_warn("unsupport msg type %d", new_header->type); - assert(false); - } - - memcpy(&new_header[1], &header[1], header->len - sizeof(*header)); - - return new_header; -} \ No newline at end of file diff --git a/src/base/msg.c b/src/base/msg.c new file mode 100644 index 00000000..0dcf948c --- /dev/null +++ b/src/base/msg.c @@ -0,0 +1,69 @@ +/** + * NEURON IIoT System for Industry 4.0 + * Copyright (C) 2020-2023 EMQ Technologies Co., Ltd All rights reserved. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + **/ + +#include "msg.h" +#include "utils/log.h" + +#include "msg_internal.h" + +void neu_msg_gen(neu_reqresp_head_t *header, void *data) +{ + size_t data_size = neu_reqresp_size(header->type); + assert(NEU_MSG_MAX_SIZE >= sizeof(neu_reqresp_head_t) + data_size); + memcpy((uint8_t *) &header[1], data, data_size); + header->len = sizeof(neu_reqresp_head_t) + data_size; +} + +neu_reqresp_head_t *neu_msg_dup(neu_reqresp_head_t *header) +{ + neu_reqresp_head_t *new_header = calloc(1, header->len); + + *new_header = *header; + switch (new_header->type) { + case NEU_REQ_WRITE_TAG: { + neu_req_write_tag_t *wt = (neu_req_write_tag_t *) &header[1]; + neu_req_write_tag_t *new_wt = (neu_req_write_tag_t *) &new_header[1]; + + *new_wt = *wt; + break; + } + case NEU_REQ_WRITE_TAGS: { + neu_req_write_tags_t *wts = (neu_req_write_tags_t *) &header[1]; + neu_req_write_tags_t *new_wts = (neu_req_write_tags_t *) &new_header[1]; + + *new_wts = *wts; + break; + } + case NEU_REQ_WRITE_GTAGS: { + neu_req_write_gtags_t *wgts = (neu_req_write_gtags_t *) &header[1]; + neu_req_write_gtags_t *new_wgts = + (neu_req_write_gtags_t *) &new_header[1]; + + *new_wgts = *wgts; + break; + } + default: + nlog_warn("unsupport msg type %d", new_header->type); + assert(false); + } + + memcpy(&new_header[1], &header[1], header->len - sizeof(*header)); + + return new_header; +} diff --git a/src/base/msg_internal.h b/src/base/msg_internal.h new file mode 100644 index 00000000..583d47b6 --- /dev/null +++ b/src/base/msg_internal.h @@ -0,0 +1,215 @@ +/** + * NEURON IIoT System for Industry 4.0 + * Copyright (C) 2020-2023 EMQ Technologies Co., Ltd All rights reserved. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + **/ + +#ifndef NEURON_MSG_INTERNAL_H +#define NEURON_MSG_INTERNAL_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "msg.h" + +#define NEU_REQRESP_TYPE_MAP(XX) \ + XX(NEU_RESP_ERROR, neu_resp_error_t) \ + XX(NEU_REQ_READ_GROUP, neu_req_read_group_t) \ + XX(NEU_RESP_READ_GROUP, neu_resp_read_group_t) \ + XX(NEU_REQ_WRITE_TAG, neu_req_write_tag_t) \ + XX(NEU_REQ_WRITE_TAGS, neu_req_write_tags_t) \ + XX(NEU_REQ_WRITE_GTAGS, neu_req_write_gtags_t) \ + XX(NEU_REQ_SUBSCRIBE_GROUP, neu_req_subscribe_t) \ + XX(NEU_REQ_UNSUBSCRIBE_GROUP, neu_req_unsubscribe_t) \ + XX(NEU_REQ_UPDATE_SUBSCRIBE_GROUP, neu_req_subscribe_t) \ + XX(NEU_REQ_SUBSCRIBE_GROUPS, neu_req_subscribe_groups_t) \ + XX(NEU_REQ_GET_SUBSCRIBE_GROUP, neu_req_get_subscribe_group_t) \ + XX(NEU_RESP_GET_SUBSCRIBE_GROUP, neu_resp_get_subscribe_group_t) \ + XX(NEU_REQ_GET_SUB_DRIVER_TAGS, neu_req_get_sub_driver_tags_t) \ + XX(NEU_RESP_GET_SUB_DRIVER_TAGS, neu_resp_get_sub_driver_tags_t) \ + XX(NEU_REQ_NODE_INIT, neu_req_node_init_t) \ + XX(NEU_REQ_NODE_UNINIT, neu_req_node_uninit_t) \ + XX(NEU_RESP_NODE_UNINIT, neu_resp_node_uninit_t) \ + XX(NEU_REQ_ADD_NODE, neu_req_add_node_t) \ + XX(NEU_REQ_UPDATE_NODE, neu_req_update_node_t) \ + XX(NEU_REQ_DEL_NODE, neu_req_del_node_t) \ + XX(NEU_REQ_GET_NODE, neu_req_get_node_t) \ + XX(NEU_RESP_GET_NODE, neu_resp_get_node_t) \ + XX(NEU_REQ_NODE_SETTING, neu_req_node_setting_t) \ + XX(NEU_REQ_GET_NODE_SETTING, neu_req_get_node_setting_t) \ + XX(NEU_RESP_GET_NODE_SETTING, neu_resp_get_node_setting_t) \ + XX(NEU_REQ_GET_NODE_STATE, neu_req_get_node_state_t) \ + XX(NEU_RESP_GET_NODE_STATE, neu_resp_get_node_state_t) \ + XX(NEU_REQ_GET_NODES_STATE, neu_req_get_nodes_state_t) \ + XX(NEU_RESP_GET_NODES_STATE, neu_resp_get_nodes_state_t) \ + XX(NEU_REQ_NODE_CTL, neu_req_node_ctl_t) \ + XX(NEU_REQ_NODE_RENAME, neu_req_node_rename_t) \ + XX(NEU_RESP_NODE_RENAME, neu_resp_node_rename_t) \ + XX(NEU_REQ_ADD_GROUP, neu_req_add_group_t) \ + XX(NEU_REQ_DEL_GROUP, neu_req_del_group_t) \ + XX(NEU_REQ_UPDATE_GROUP, neu_req_update_group_t) \ + XX(NEU_REQ_UPDATE_DRIVER_GROUP, neu_req_update_group_t) \ + XX(NEU_RESP_UPDATE_DRIVER_GROUP, neu_resp_update_group_t) \ + XX(NEU_REQ_GET_GROUP, neu_req_get_group_t) \ + XX(NEU_RESP_GET_GROUP, neu_resp_get_group_t) \ + XX(NEU_REQ_GET_DRIVER_GROUP, neu_req_get_group_t) \ + XX(NEU_RESP_GET_DRIVER_GROUP, neu_resp_get_driver_group_t) \ + XX(NEU_REQ_ADD_TAG, neu_req_add_tag_t) \ + XX(NEU_RESP_ADD_TAG, neu_resp_add_tag_t) \ + XX(NEU_REQ_ADD_GTAG, neu_req_add_gtag_t) \ + XX(NEU_RESP_ADD_GTAG, neu_resp_add_tag_t) \ + XX(NEU_REQ_DEL_TAG, neu_req_del_tag_t) \ + XX(NEU_REQ_UPDATE_TAG, neu_req_update_tag_t) \ + XX(NEU_RESP_UPDATE_TAG, neu_resp_update_tag_t) \ + XX(NEU_REQ_GET_TAG, neu_req_get_tag_t) \ + XX(NEU_RESP_GET_TAG, neu_resp_get_tag_t) \ + XX(NEU_REQ_ADD_PLUGIN, neu_req_add_plugin_t) \ + XX(NEU_REQ_DEL_PLUGIN, neu_req_del_plugin_t) \ + XX(NEU_REQ_UPDATE_PLUGIN, neu_req_update_plugin_t) \ + XX(NEU_REQ_GET_PLUGIN, neu_req_get_plugin_t) \ + XX(NEU_RESP_GET_PLUGIN, neu_resp_get_plugin_t) \ + XX(NEU_REQ_ADD_TEMPLATE, neu_req_add_template_t) \ + XX(NEU_REQ_DEL_TEMPLATE, neu_req_del_template_t) \ + XX(NEU_REQ_GET_TEMPLATE, neu_req_get_template_t) \ + XX(NEU_RESP_GET_TEMPLATE, neu_resp_get_template_t) \ + XX(NEU_REQ_GET_TEMPLATES, neu_req_get_templates_t) \ + XX(NEU_RESP_GET_TEMPLATES, neu_resp_get_templates_t) \ + XX(NEU_REQ_ADD_TEMPLATE_GROUP, neu_req_add_template_group_t) \ + XX(NEU_REQ_DEL_TEMPLATE_GROUP, neu_req_del_template_group_t) \ + XX(NEU_REQ_UPDATE_TEMPLATE_GROUP, neu_req_update_template_group_t) \ + XX(NEU_REQ_GET_TEMPLATE_GROUP, neu_req_get_template_group_t) \ + XX(NEU_REQ_ADD_TEMPLATE_TAG, neu_req_add_template_tag_t) \ + XX(NEU_RESP_ADD_TEMPLATE_TAG, neu_resp_add_tag_t) \ + XX(NEU_REQ_DEL_TEMPLATE_TAG, neu_req_del_template_tag_t) \ + XX(NEU_REQ_UPDATE_TEMPLATE_TAG, neu_req_update_template_tag_t) \ + XX(NEU_RESP_UPDATE_TEMPLATE_TAG, neu_resp_update_tag_t) \ + XX(NEU_REQ_GET_TEMPLATE_TAG, neu_req_get_template_tag_t) \ + XX(NEU_RESP_GET_TEMPLATE_TAG, neu_resp_get_tag_t) \ + XX(NEU_REQ_INST_TEMPLATE, neu_req_inst_template_t) \ + XX(NEU_REQ_INST_TEMPLATES, neu_req_inst_templates_t) \ + XX(NEU_REQRESP_TRANS_DATA, neu_reqresp_trans_data_t) \ + XX(NEU_REQRESP_NODES_STATE, neu_reqresp_nodes_state_t) \ + XX(NEU_REQRESP_NODE_DELETED, neu_reqresp_node_deleted_t) \ + XX(NEU_REQ_ADD_NDRIVER_MAP, neu_req_ndriver_map_t) \ + XX(NEU_REQ_DEL_NDRIVER_MAP, neu_req_ndriver_map_t) \ + XX(NEU_REQ_GET_NDRIVER_MAPS, neu_req_get_ndriver_maps_t) \ + XX(NEU_RESP_GET_NDRIVER_MAPS, neu_resp_get_ndriver_maps_t) \ + XX(NEU_REQ_UPDATE_NDRIVER_TAG_PARAM, neu_req_update_ndriver_tag_param_t) \ + XX(NEU_REQ_UPDATE_NDRIVER_TAG_INFO, neu_req_update_ndriver_tag_info_t) \ + XX(NEU_REQ_GET_NDRIVER_TAGS, neu_req_get_ndriver_tags_t) \ + XX(NEU_RESP_GET_NDRIVER_TAGS, neu_resp_get_ndriver_tags_t) \ + XX(NEU_REQ_UPDATE_LOG_LEVEL, neu_req_update_log_level_t) \ + XX(NEU_REQ_ADD_NODE_EVENT, neu_req_add_node_t) \ + XX(NEU_REQ_DEL_NODE_EVENT, neu_req_del_node_t) \ + XX(NEU_REQ_NODE_CTL_EVENT, neu_req_node_ctl_t) \ + XX(NEU_REQ_NODE_SETTING_EVENT, neu_req_node_setting_t) \ + XX(NEU_REQ_ADD_GROUP_EVENT, neu_req_add_group_t) \ + XX(NEU_REQ_DEL_GROUP_EVENT, neu_req_del_group_t) \ + XX(NEU_REQ_UPDATE_GROUP_EVENT, neu_req_update_group_t) \ + XX(NEU_REQ_ADD_TAG_EVENT, neu_req_add_tag_t) \ + XX(NEU_REQ_DEL_TAG_EVENT, neu_req_del_tag_t) \ + XX(NEU_REQ_UPDATE_TAG_EVENT, neu_req_update_tag_t) + +static inline size_t neu_reqresp_size(neu_reqresp_type_e t) +{ + switch (t) { +#define XX(type, structure) \ + case type: \ + return sizeof(structure); + NEU_REQRESP_TYPE_MAP(XX) +#undef XX + default: + assert(false); + } + + return 0; +} + +#define XX(type, structure) structure type##_data; +union neu_reqresp_u { + NEU_REQRESP_TYPE_MAP(XX) +}; +#define NEU_REQRESP_MAX_SIZE sizeof(union neu_reqresp_u) +#undef XX + +struct neu_msg_s { + neu_reqresp_head_t head; + // NOTE: we keep the data layout intact only to save refactor efforts. + // FIXME: potential alignment problem here. + neu_reqresp_head_t body[]; +}; + +typedef struct neu_msg_s neu_msg_t; + +static inline neu_msg_t *neu_msg_new(neu_reqresp_type_e t, void *ctx, + void *data) +{ + size_t data_size = neu_reqresp_size(t); + size_t total = sizeof(neu_msg_t) + data_size; + neu_msg_t *msg = calloc(1, total); + if (msg) { + msg->head.type = t; + msg->head.len = total; + msg->head.ctx = ctx; + if (data) { + memcpy(msg->body, data, data_size); + } + } + return msg; +} + +static inline neu_msg_t *neu_msg_copy(const neu_msg_t *other) +{ + neu_msg_t *msg = calloc(1, other->head.len); + if (msg) { + memcpy(msg, other, other->head.len); + } + return msg; +} + +static inline void neu_msg_free(neu_msg_t *msg) +{ + if (msg) { + free(msg); + } +} + +static inline size_t neu_msg_size(neu_msg_t *msg) +{ + return msg->head.len; +} + +static inline size_t neu_msg_body_size(neu_msg_t *msg) +{ + return msg->head.len - sizeof(msg->head); +} + +static inline void *neu_msg_get_header(neu_msg_t *msg) +{ + return &msg->head; +} + +static inline void *neu_msg_get_body(neu_msg_t *msg) +{ + return &msg->body; +} + +#ifdef __cplusplus +} +#endif + +#endif