mirror of
https://github.com/emqx/neuron.git
synced 2026-10-21 16:55:53 +08:00
fengzero
535 lines
16 KiB
C
535 lines
16 KiB
C
/**
|
|
* NEURON IIoT System for Industry 4.0
|
|
* Copyright (C) 2020-2022 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 _NEU_ADAPTER_H_
|
|
#define _NEU_ADAPTER_H_
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <nng/nng.h>
|
|
|
|
#include "define.h"
|
|
#include "tag.h"
|
|
#include "type.h"
|
|
|
|
typedef struct {
|
|
neu_node_running_state_e running;
|
|
neu_node_link_state_e link;
|
|
} neu_node_state_t;
|
|
|
|
typedef enum neu_reqresp_type {
|
|
NEU_RESP_ERROR,
|
|
NEU_REQRESP_TRANS_DATA,
|
|
NEU_REQ_UPDATE_LICENSE,
|
|
|
|
NEU_REQ_READ_GROUP,
|
|
NEU_RESP_READ_GROUP,
|
|
NEU_REQ_WRITE_TAG,
|
|
|
|
NEU_REQ_SUBSCRIBE_GROUP,
|
|
NEU_REQ_UNSUBSCRIBE_GROUP,
|
|
NEU_REQ_GET_SUBSCRIBE_GROUP,
|
|
NEU_RESP_GET_SUBSCRIBE_GROUP,
|
|
|
|
NEU_REQ_APP_SUBSCRIBE_GROUP,
|
|
NEU_RESP_APP_SUBSCRIBE_GROUP,
|
|
NEU_REQ_APP_UNSUBSCRIBE_GROUP,
|
|
|
|
NEU_REQ_NODE_INIT,
|
|
NEU_REQ_NODE_UNINIT,
|
|
NEU_RESP_NODE_UNINIT,
|
|
NEU_REQ_ADD_NODE,
|
|
NEU_REQ_DEL_NODE,
|
|
NEU_REQ_GET_NODE,
|
|
NEU_RESP_GET_NODE,
|
|
NEU_REQ_NODE_SETTING,
|
|
NEU_REQ_GET_NODE_SETTING,
|
|
NEU_RESP_GET_NODE_SETTING,
|
|
NEU_REQ_GET_NODE_STATE,
|
|
NEU_RESP_GET_NODE_STATE,
|
|
NEU_REQ_NODE_CTL,
|
|
|
|
NEU_REQ_ADD_GROUP,
|
|
NEU_REQ_DEL_GROUP,
|
|
NEU_REQ_UPDATE_GROUP,
|
|
NEU_REQ_GET_GROUP,
|
|
NEU_RESP_GET_GROUP,
|
|
|
|
NEU_REQ_ADD_TAG,
|
|
NEU_RESP_ADD_TAG,
|
|
NEU_REQ_DEL_TAG,
|
|
NEU_REQ_UPDATE_TAG,
|
|
NEU_RESP_UPDATE_TAG,
|
|
NEU_REQ_GET_TAG,
|
|
NEU_RESP_GET_TAG,
|
|
|
|
NEU_REQ_ADD_PLUGIN,
|
|
NEU_REQ_DEL_PLUGIN,
|
|
NEU_REQ_GET_PLUGIN,
|
|
NEU_RESP_GET_PLUGIN,
|
|
} neu_reqresp_type_e;
|
|
|
|
static const char *neu_reqresp_type_string_t[] = {
|
|
[NEU_RESP_ERROR] = "NEU_RESP_ERROR",
|
|
[NEU_REQRESP_TRANS_DATA] = "NEU_REQRESP_TRANS_DATA",
|
|
[NEU_REQ_UPDATE_LICENSE] = "NEU_REQ_UPDATE_LICENSE",
|
|
|
|
[NEU_REQ_READ_GROUP] = "NEU_REQ_READ_GROUP",
|
|
[NEU_RESP_READ_GROUP] = "NEU_RESP_READ_GROUP",
|
|
[NEU_REQ_WRITE_TAG] = "NEU_REQ_WRITE_TAG",
|
|
|
|
[NEU_REQ_SUBSCRIBE_GROUP] = "NEU_REQ_SUBSCRIBE_GROUP",
|
|
[NEU_REQ_UNSUBSCRIBE_GROUP] = "NEU_REQ_UNSUBSCRIBE_GROUP",
|
|
[NEU_REQ_GET_SUBSCRIBE_GROUP] = "NEU_REQ_GET_SUBSCRIBE_GROUP",
|
|
[NEU_RESP_GET_SUBSCRIBE_GROUP] = "NEU_RESP_GET_SUBSCRIBE_GROUP",
|
|
|
|
[NEU_REQ_APP_SUBSCRIBE_GROUP] = "NEU_REQ_APP_SUBSCRIBE_GROUP",
|
|
[NEU_RESP_APP_SUBSCRIBE_GROUP] = "NEU_RESP_APP_SUBSCRIBE_GROUP",
|
|
[NEU_REQ_APP_UNSUBSCRIBE_GROUP] = "NEU_REQ_APP_UNSUBSCRIBE_GROUP",
|
|
|
|
[NEU_REQ_NODE_INIT] = "NEU_REQ_NODE_INIT",
|
|
[NEU_REQ_NODE_UNINIT] = "NEU_REQ_NODE_UNINIT",
|
|
[NEU_RESP_NODE_UNINIT] = "NEU_RESP_NODE_UNINIT",
|
|
[NEU_REQ_ADD_NODE] = "NEU_REQ_ADD_NODE",
|
|
[NEU_REQ_DEL_NODE] = "NEU_REQ_DEL_NODE",
|
|
[NEU_REQ_GET_NODE] = "NEU_REQ_GET_NODE",
|
|
[NEU_RESP_GET_NODE] = "NEU_RESP_GET_NODE",
|
|
[NEU_REQ_NODE_SETTING] = "NEU_REQ_NODE_SETTING",
|
|
[NEU_REQ_GET_NODE_SETTING] = "NEU_REQ_GET_NODE_SETTING",
|
|
[NEU_RESP_GET_NODE_SETTING] = "NEU_RESP_GET_NODE_SETTING",
|
|
[NEU_REQ_GET_NODE_STATE] = "NEU_REQ_GET_NODE_STATE",
|
|
[NEU_RESP_GET_NODE_STATE] = "NEU_RESP_GET_NODE_STATE",
|
|
[NEU_REQ_NODE_CTL] = "NEU_REQ_NODE_CTL",
|
|
|
|
[NEU_REQ_ADD_GROUP] = "NEU_REQ_ADD_GROUP",
|
|
[NEU_REQ_DEL_GROUP] = "NEU_REQ_DEL_GROUP",
|
|
[NEU_REQ_UPDATE_GROUP] = "NEU_REQ_UPDATE_GROUP",
|
|
[NEU_REQ_GET_GROUP] = "NEU_REQ_GET_GROUP",
|
|
[NEU_RESP_GET_GROUP] = "NEU_RESP_GET_GROUP",
|
|
|
|
[NEU_REQ_ADD_TAG] = "NEU_REQ_ADD_TAG",
|
|
[NEU_RESP_ADD_TAG] = "NEU_RESP_ADD_TAG",
|
|
[NEU_REQ_DEL_TAG] = "NEU_REQ_DEL_TAG",
|
|
[NEU_REQ_UPDATE_TAG] = "NEU_REQ_UPDATE_TAG",
|
|
[NEU_RESP_UPDATE_TAG] = "NEU_RESP_UPDATE_TAG",
|
|
[NEU_REQ_GET_TAG] = "NEU_REQ_GET_TAG",
|
|
[NEU_RESP_GET_TAG] = "NEU_RESP_GET_TAG",
|
|
|
|
[NEU_REQ_ADD_PLUGIN] = "NEU_REQ_ADD_PLUGIN",
|
|
[NEU_REQ_DEL_PLUGIN] = "NEU_REQ_DEL_PLUGIN",
|
|
[NEU_REQ_GET_PLUGIN] = "NEU_REQ_GET_PLUGIN",
|
|
[NEU_RESP_GET_PLUGIN] = "NEU_RESP_GET_PLUGIN",
|
|
};
|
|
|
|
inline static const char *neu_reqresp_type_string(neu_reqresp_type_e type)
|
|
{
|
|
return neu_reqresp_type_string_t[type];
|
|
}
|
|
|
|
typedef struct neu_reqresp_head {
|
|
neu_reqresp_type_e type;
|
|
void * ctx;
|
|
char sender[NEU_NODE_NAME_LEN];
|
|
char receiver[NEU_NODE_NAME_LEN];
|
|
} neu_reqresp_head_t;
|
|
|
|
typedef struct neu_resp_error {
|
|
int error;
|
|
} neu_resp_error_t;
|
|
|
|
typedef struct {
|
|
char node[NEU_NODE_NAME_LEN];
|
|
} neu_req_node_init_t, neu_req_node_uninit_t, neu_resp_node_uninit_t;
|
|
|
|
typedef struct neu_req_add_plugin {
|
|
char library[NEU_PLUGIN_LIBRARY_LEN];
|
|
} neu_req_add_plugin_t;
|
|
|
|
typedef struct neu_req_del_plugin {
|
|
char plugin[NEU_PLUGIN_NAME_LEN];
|
|
} neu_req_del_plugin_t;
|
|
|
|
typedef struct neu_req_get_plugin {
|
|
} neu_req_get_plugin_t;
|
|
|
|
typedef struct neu_resp_plugin_info {
|
|
char name[NEU_PLUGIN_NAME_LEN];
|
|
char description[NEU_PLUGIN_DESCRIPTION_LEN];
|
|
char library[NEU_PLUGIN_LIBRARY_LEN];
|
|
|
|
neu_plugin_kind_e kind;
|
|
neu_node_type_e type;
|
|
} neu_resp_plugin_info_t;
|
|
|
|
typedef struct neu_resp_get_plugin {
|
|
UT_array *plugins; // array neu_resp_plugin_info_t
|
|
} neu_resp_get_plugin_t;
|
|
|
|
typedef struct neu_req_add_node {
|
|
char node[NEU_NODE_NAME_LEN];
|
|
char plugin[NEU_PLUGIN_NAME_LEN];
|
|
} neu_req_add_node_t;
|
|
|
|
typedef struct neu_req_del_node {
|
|
char node[NEU_NODE_NAME_LEN];
|
|
} neu_req_del_node_t;
|
|
|
|
typedef struct neu_req_get_node {
|
|
neu_node_type_e type;
|
|
} neu_req_get_node_t;
|
|
|
|
typedef struct neu_resp_node_info {
|
|
char node[NEU_NODE_NAME_LEN];
|
|
char plugin[NEU_PLUGIN_NAME_LEN];
|
|
} neu_resp_node_info_t;
|
|
|
|
typedef struct neu_resp_get_node {
|
|
UT_array *nodes; // array neu_resp_node_info_t
|
|
} neu_resp_get_node_t;
|
|
|
|
typedef struct {
|
|
char driver[NEU_NODE_NAME_LEN];
|
|
char group[NEU_GROUP_NAME_LEN];
|
|
uint32_t interval;
|
|
} neu_req_add_group_t, neu_req_update_group;
|
|
|
|
typedef struct neu_req_del_group {
|
|
char driver[NEU_NODE_NAME_LEN];
|
|
char group[NEU_GROUP_NAME_LEN];
|
|
} neu_req_del_group_t;
|
|
|
|
typedef struct neu_req_get_group {
|
|
char driver[NEU_NODE_NAME_LEN];
|
|
} neu_req_get_group_t;
|
|
|
|
typedef struct neu_resp_group_info {
|
|
char name[NEU_GROUP_NAME_LEN];
|
|
uint16_t tag_count;
|
|
uint32_t interval;
|
|
} neu_resp_group_info_t;
|
|
|
|
typedef struct neu_resp_get_group {
|
|
UT_array *groups; // array neu_resp_group_info_t
|
|
} neu_resp_get_group_t;
|
|
|
|
typedef struct {
|
|
char driver[NEU_NODE_NAME_LEN];
|
|
char group[NEU_GROUP_NAME_LEN];
|
|
uint16_t n_tag;
|
|
neu_datatag_t *tags;
|
|
} neu_req_add_tag_t, neu_req_update_tag_t;
|
|
|
|
typedef struct {
|
|
uint16_t index;
|
|
int error;
|
|
} neu_resp_add_tag_t, neu_resp_update_tag_t;
|
|
|
|
typedef struct neu_req_del_tag {
|
|
char driver[NEU_NODE_NAME_LEN];
|
|
char group[NEU_GROUP_NAME_LEN];
|
|
uint16_t n_tag;
|
|
char ** tags;
|
|
} neu_req_del_tag_t;
|
|
|
|
typedef struct neu_req_get_tag {
|
|
char driver[NEU_NODE_NAME_LEN];
|
|
char group[NEU_GROUP_NAME_LEN];
|
|
} neu_req_get_tag_t;
|
|
|
|
typedef struct neu_resp_get_tag {
|
|
UT_array *tags; // array neu_datatag_t
|
|
} neu_resp_get_tag_t;
|
|
|
|
typedef struct {
|
|
char driver[NEU_NODE_NAME_LEN];
|
|
char group[NEU_GROUP_NAME_LEN];
|
|
UT_array *tags; // array neu_datatag_t
|
|
} neu_resp_app_subscribe_group_t;
|
|
|
|
typedef struct {
|
|
char driver[NEU_NODE_NAME_LEN];
|
|
char group[NEU_GROUP_NAME_LEN];
|
|
} neu_req_app_subscribe_group_t, neu_req_app_unsubscribe_group_t;
|
|
|
|
typedef struct {
|
|
char app[NEU_NODE_NAME_LEN];
|
|
char driver[NEU_NODE_NAME_LEN];
|
|
char group[NEU_GROUP_NAME_LEN];
|
|
} neu_req_subscribe_t, neu_req_unsubscribe_t;
|
|
|
|
typedef struct neu_req_get_subscribe_group {
|
|
char app[NEU_NODE_NAME_LEN];
|
|
} neu_req_get_subscribe_group_t;
|
|
|
|
typedef struct neu_resp_subscribe_info {
|
|
char app[NEU_NODE_NAME_LEN];
|
|
char driver[NEU_NODE_NAME_LEN];
|
|
char group[NEU_GROUP_NAME_LEN];
|
|
} neu_resp_subscribe_info_t;
|
|
|
|
typedef struct neu_resp_get_subscribe_group {
|
|
UT_array *groups; // array neu_resp_subscribe_info_t
|
|
} neu_resp_get_subscribe_group_t;
|
|
|
|
typedef struct neu_req_node_setting {
|
|
char node[NEU_NODE_NAME_LEN];
|
|
char *setting;
|
|
} neu_req_node_setting_t;
|
|
|
|
typedef struct neu_req_get_node_setting {
|
|
char ndoe[NEU_NODE_NAME_LEN];
|
|
} neu_req_get_node_setting_t;
|
|
|
|
typedef struct neu_resp_get_node_setting {
|
|
char *setting;
|
|
} neu_resp_get_node_setting_t;
|
|
|
|
typedef enum neu_adapter_ctl {
|
|
NEU_ADAPTER_CTL_START = 0,
|
|
NEU_ADAPTER_CTL_STOP,
|
|
} neu_adapter_ctl_e;
|
|
|
|
typedef struct neu_req_node_ctl {
|
|
char node[NEU_NODE_NAME_LEN];
|
|
neu_adapter_ctl_e ctl;
|
|
} neu_req_node_ctl_t;
|
|
|
|
typedef struct neu_req_get_node_state {
|
|
char node[NEU_NODE_NAME_LEN];
|
|
} neu_req_get_node_state_t;
|
|
|
|
typedef struct neu_resp_get_node_state {
|
|
neu_node_state_t state;
|
|
} neu_resp_get_node_state_t;
|
|
|
|
typedef struct neu_req_update_license {
|
|
} neu_req_update_license_t;
|
|
|
|
typedef struct neu_req_read_group {
|
|
char driver[NEU_NODE_NAME_LEN];
|
|
char group[NEU_GROUP_NAME_LEN];
|
|
} neu_req_read_group_t;
|
|
|
|
typedef struct neu_req_write_tag {
|
|
char driver[NEU_NODE_NAME_LEN];
|
|
char group[NEU_GROUP_NAME_LEN];
|
|
char tag[NEU_TAG_NAME_LEN];
|
|
neu_dvalue_t value;
|
|
} neu_req_write_tag_t;
|
|
|
|
typedef struct neu_resp_tag_value {
|
|
char tag[NEU_TAG_NAME_LEN];
|
|
neu_dvalue_t value;
|
|
} neu_resp_tag_value_t;
|
|
|
|
typedef struct {
|
|
char driver[NEU_NODE_NAME_LEN];
|
|
char group[NEU_GROUP_NAME_LEN];
|
|
uint16_t n_tag;
|
|
neu_resp_tag_value_t *tags;
|
|
} neu_resp_read_group_t;
|
|
|
|
typedef struct {
|
|
char driver[NEU_NODE_NAME_LEN];
|
|
char group[NEU_GROUP_NAME_LEN];
|
|
uint16_t n_tag;
|
|
neu_resp_tag_value_t tags[];
|
|
} neu_reqresp_trans_data_t;
|
|
|
|
inline static nng_msg *neu_msg_gen(neu_reqresp_head_t *header, void *data)
|
|
{
|
|
nng_msg *msg = NULL;
|
|
void * body = NULL;
|
|
size_t data_size = 0;
|
|
|
|
switch (header->type) {
|
|
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_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_NODE:
|
|
data_size = sizeof(neu_req_add_node_t);
|
|
break;
|
|
case NEU_REQ_DEL_NODE:
|
|
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_UPDATE_GROUP:
|
|
data_size = sizeof(neu_req_add_group_t);
|
|
break;
|
|
case NEU_REQ_DEL_GROUP:
|
|
data_size = sizeof(neu_req_del_group_t);
|
|
break;
|
|
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:
|
|
data_size = sizeof(neu_req_add_tag_t);
|
|
break;
|
|
case NEU_RESP_ADD_TAG:
|
|
data_size = sizeof(neu_resp_add_tag_t);
|
|
break;
|
|
case NEU_RESP_UPDATE_TAG:
|
|
data_size = sizeof(neu_resp_update_tag_t);
|
|
break;
|
|
case NEU_REQ_UPDATE_TAG:
|
|
data_size = sizeof(neu_req_update_tag_t);
|
|
break;
|
|
case NEU_REQ_DEL_TAG:
|
|
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:
|
|
data_size = sizeof(neu_resp_get_tag_t);
|
|
break;
|
|
case NEU_REQ_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_GET_SUBSCRIBE_GROUP:
|
|
data_size = sizeof(neu_req_get_subscribe_group_t);
|
|
break;
|
|
case NEU_RESP_GET_SUBSCRIBE_GROUP:
|
|
data_size = sizeof(neu_resp_get_subscribe_group_t);
|
|
break;
|
|
case NEU_REQ_NODE_SETTING:
|
|
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:
|
|
data_size = sizeof(neu_req_node_ctl_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_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_RESP_READ_GROUP:
|
|
data_size = sizeof(neu_resp_read_group_t);
|
|
break;
|
|
case NEU_REQRESP_TRANS_DATA: {
|
|
neu_reqresp_trans_data_t *trans = (neu_reqresp_trans_data_t *) data;
|
|
data_size = sizeof(neu_reqresp_trans_data_t) +
|
|
trans->n_tag * sizeof(neu_resp_tag_value_t);
|
|
break;
|
|
}
|
|
case NEU_REQ_UPDATE_LICENSE:
|
|
data_size = sizeof(neu_req_update_license_t);
|
|
break;
|
|
case NEU_RESP_APP_SUBSCRIBE_GROUP:
|
|
data_size = sizeof(neu_resp_app_subscribe_group_t);
|
|
break;
|
|
case NEU_REQ_APP_SUBSCRIBE_GROUP:
|
|
case NEU_REQ_APP_UNSUBSCRIBE_GROUP:
|
|
data_size = sizeof(neu_req_app_unsubscribe_group_t);
|
|
break;
|
|
default:
|
|
assert(false);
|
|
break;
|
|
}
|
|
|
|
nng_msg_alloc(&msg, sizeof(neu_reqresp_head_t) + data_size);
|
|
body = nng_msg_body(msg);
|
|
memcpy(body, header, sizeof(neu_reqresp_head_t));
|
|
memcpy((uint8_t *) body + sizeof(neu_reqresp_head_t), data, data_size);
|
|
return msg;
|
|
}
|
|
|
|
inline static void neu_msg_exchange(neu_reqresp_head_t *header)
|
|
{
|
|
char tmp[NEU_NODE_NAME_LEN] = { 0 };
|
|
|
|
strcpy(tmp, header->sender);
|
|
|
|
memset(header->sender, 0, sizeof(header->sender));
|
|
strcpy(header->sender, header->receiver);
|
|
|
|
memset(header->receiver, 0, sizeof(header->receiver));
|
|
strcpy(header->receiver, tmp);
|
|
}
|
|
|
|
typedef struct neu_adapter neu_adapter_t;
|
|
typedef struct neu_adapter_driver neu_adapter_driver_t;
|
|
typedef struct neu_adapter_app neu_adapter_app_t;
|
|
|
|
typedef struct adapter_callbacks {
|
|
int (*command)(neu_adapter_t *adapter, neu_reqresp_head_t head, void *data);
|
|
int (*response)(neu_adapter_t *adapter, neu_reqresp_head_t *head,
|
|
void *data);
|
|
|
|
union {
|
|
struct {
|
|
void (*update)(neu_adapter_t *adapter, const char *group,
|
|
const char *tag, neu_dvalue_t value);
|
|
void (*write_response)(neu_adapter_t *adapter, void *req,
|
|
int error);
|
|
} driver;
|
|
};
|
|
} adapter_callbacks_t;
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif |