wangzhengquan
2021-02-03 758438289fc45829a8f6cef1b42afed0a1a8cb60
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
#include "net_mod_socket_wrapper.h"
 
 
 
static Logger *logger = LoggerFactory::getLogger();
 
/**
 * 创建
 */
void * net_mod_socket_open() {
    NetModSocket *sockt = new NetModSocket;
    return (void *)sockt;
}
 
/**
 * 关闭
 */
void net_mod_socket_close(void *_socket) {
    NetModSocket *sockt = (NetModSocket *)_socket;
    delete sockt;
}
 
/**
 * 绑定端口到socket, 如果不绑定则系统自动分配一个
 * @return 0 成功, 其他值 失败的错误码
*/
int net_mod_socket_bind(void * _socket, int key){
    NetModSocket *sockt = (NetModSocket *)_socket;
    return sockt->bind(key);
}
 
/**
 * 强制绑定端口到socket, 适用于程序非正常关闭的情况下,重启程序绑定原来还没释放的key
 * @return 0 成功, 其他值 失败的错误码
*/
int net_mod_socket_force_bind(void * _socket, int key) {
    NetModSocket *sockt = (NetModSocket *)_socket;
    // return sockt->force_bind(key);
    return sockt->bind(key);
}
 
/**
 * 发送信息
 * @key 发送给谁
 * @return 0 成功, 其他值 失败的错误码
 */
int net_mod_socket_sendto(void *_socket, const void *buf, const int size, const int key) {
    NetModSocket *sockt = (NetModSocket *)_socket;
    logger->debug("net_mod_socket_sendto: %d sendto  %d", net_mod_socket_get_key(_socket), key);
    return sockt->sendto(buf, size, key);
}
// 发送信息超时返回。 @sec 秒 , @nsec 纳秒
int net_mod_socket_sendto_timeout(void *_socket, const void *buf, const int size, const int key, int sec, int nsec){
    NetModSocket *sockt = (NetModSocket *)_socket;
    logger->debug("net_mod_socket_sendto: %d sendto  %d", net_mod_socket_get_key(_socket), key);
    return sockt->sendto_timeout(buf, size, key, sec, nsec);
    // return sockt->sendto(buf, size, key);
}
// 发送信息立刻返回。
int net_mod_socket_sendto_nowait(void *_socket, const void *buf, const int size, const int key){
    NetModSocket *sockt = (NetModSocket *)_socket;
    logger->debug("net_mod_socket_sendto: %d sendto  %d", net_mod_socket_get_key(_socket), key);
    return sockt->sendto_nowait(buf, size, key);
}
 
/**
 * 接收信息
 * @port 从谁哪里收到的信息
 * @return 0 成功, 其他值 失败的错误码
*/
int net_mod_socket_recvfrom(void *_socket, void **buf, int *size, int *key){
    int rv;
    NetModSocket *sockt = (NetModSocket *)_socket;
 
    logger->debug(" %d net_mod_socket_recvfrom before", net_mod_socket_get_key(_socket));
    rv = sockt->recvfrom(buf, size, key);
    logger->debug(" %d net_mod_socket_recvfrom after. rv = %d", net_mod_socket_get_key(_socket), rv);
    return rv;
}
 
// 接受信息超时返回。 @sec 秒 , @nsec 纳秒
int net_mod_socket_recvfrom_timeout(void *_socket, void **buf, int *size, int *key, int sec, int nsec){
    NetModSocket *sockt = (NetModSocket *)_socket;
    // return sockt->recvfrom(buf, size, key);
    return sockt->recvfrom_timeout(buf, size, key, sec, nsec);
}
 
int net_mod_socket_recvfrom_nowait(void *_socket, void **buf, int *size, int *key){
    NetModSocket *sockt = (NetModSocket *)_socket;
    return sockt->recvfrom_nowait(buf, size, key);
}
 
 
int net_mod_socket_recvandsend(void *_socket, void **recvbuf, int *recvsize, int *key, recv_callback_fn callback) {
  NetModSocket *sockt = (NetModSocket *)_socket;
  return sockt->recvandsend( recvbuf, recvsize, key, callback);
 
}
 
int net_mod_socket_recvandsend_timeout(void *_socket, void **recvbuf, int *recvsize, int *key, recv_callback_fn callback,
                                       int sec, int nsec ) {
  NetModSocket *sockt = (NetModSocket *)_socket;
  struct timespec timeout = {sec, nsec};
  return sockt->recvandsend_timeout( recvbuf, recvsize, key, callback, &timeout);
}
 
int net_mod_socket_recvandsend_nowait(void *_socket, void **recvbuf, int *recvsize, int *key, recv_callback_fn callback) {
  NetModSocket *sockt = (NetModSocket *)_socket;
  return sockt->recvandsend_nowait( recvbuf, recvsize, key, callback);
}
 
 
int net_mod_socket_sendandrecv(void *_socket, net_node_t *node_arr, int arrlen, void *send_buf, int send_size, 
  net_mod_recv_msg_t ** recv_arr, int *recv_arr_size){
    NetModSocket *sockt = (NetModSocket *)_socket;
    return sockt->sendandrecv(node_arr,  arrlen, send_buf,  send_size, recv_arr, recv_arr_size);
}
 
 
 
 
/**
 * 如果建立连接的节点没有接受到消息等待timeout的时间后返回
 * @timeout 等待时间,单位是千分之一秒
*/
int net_mod_socket_sendandrecv_timeout(void *_socket, net_node_t *node_arr, int arrlen, void *send_buf, int send_size, 
  net_mod_recv_msg_t ** recv_arr, int *recv_arr_size,  int timeout){
    NetModSocket *sockt = (NetModSocket *)_socket;
    // return sockt->sendandrecv(node_arr,  arrlen, send_buf,  send_size, recv_arr, recv_arr_size);
    return sockt->sendandrecv_timeout(node_arr,  arrlen, send_buf,  send_size, recv_arr, recv_arr_size, timeout);
}
 
int net_mod_socket_sendandrecv_nowait(void *_socket, net_node_t *node_arr, int arrlen, void *send_buf, int send_size, 
  net_mod_recv_msg_t ** recv_arr, int *recv_arr_size) {
    NetModSocket *sockt = (NetModSocket *)_socket;
    return sockt->sendandrecv_nowait(node_arr,  arrlen, send_buf,  send_size, recv_arr, recv_arr_size);
}
 
 
 /**
 * 向node_arr 中的所有网络节点发布消息
 * @node_arr 网络节点组, @node_arr_len该数组长度
 * @topic 主题,@topic_size 该主题的长度
 * @content 内容,@content_size 内容长度
 * @return 成功发布的节点的个数
 */
int net_mod_socket_pub(void *_socket, net_node_t *node_arr, int node_arr_len, char *topic, int topic_size, void *content, int content_size) {
    NetModSocket *sockt = (NetModSocket *)_socket;
    return sockt->pub(node_arr, node_arr_len, topic, topic_size, content, content_size);
}
int net_mod_socket_pub_timeout(void *_socket, net_node_t *node_arr, int node_arr_len, char *topic, int topic_size, void *content, int content_size, int msec){
    NetModSocket *sockt = (NetModSocket *)_socket;
    return sockt->pub_timeout(node_arr, node_arr_len, topic, topic_size, content, content_size, msec);
}
int net_mod_socket_pub_nowait(void *_socket, net_node_t *node_arr, int node_arr_len, char *topic, int topic_size, void *content, int content_size){
    NetModSocket *sockt = (NetModSocket *)_socket;
    return sockt->pub_nowait(node_arr, node_arr_len, topic, topic_size, content, content_size);
}
 
 
 
 
 
/**
 * 订阅指定主题
 * @topic 主题
 * @size 主题长度
 * @port 总线端口
 */
int  net_mod_socket_sub(void * _socket, void *topic, int size) {
    NetModSocket *sockt = (NetModSocket *)_socket;
    return sockt->sub((char *)topic,  size,  SHM_BUS_KEY);
}
// 超时返回。 @sec 秒 , @nsec 纳秒
int  net_mod_socket_sub_timeout(void * _socket, void *topic, int size, int sec, int nsec){
    NetModSocket *sockt = (NetModSocket *)_socket;
    return sockt->sub_timeout((char *)topic,  size,  SHM_BUS_KEY, sec, nsec);
}
int  net_mod_socket_sub_nowait(void * _socket, void *topic, int size){
    NetModSocket *sockt = (NetModSocket *)_socket;
    return sockt->sub_nowait((char *)topic,  size,  SHM_BUS_KEY);
}
 
 
/**
 * 取消订阅指定主题
 * @topic 主题,主题为空时取消全部订阅
 * @size 主题长度
 */
int  net_mod_socket_desub(void * _socket, void *topic, int size) {
    NetModSocket *sockt = (NetModSocket *)_socket;
    return sockt->desub((char *)topic,  size,  SHM_BUS_KEY);
}
// 超时返回。 @sec 秒 , @nsec 纳秒
int  net_mod_socket_desub_timeout(void * _socket, void *topic, int size, int sec, int nsec) {
    NetModSocket *sockt = (NetModSocket *)_socket;
    return sockt->desub_timeout((char *)topic,  size,  SHM_BUS_KEY, sec, nsec);
}
int  net_mod_socket_desub_nowait(void * _socket, void *topic, int size){
    NetModSocket *sockt = (NetModSocket *)_socket;
    return sockt->desub_nowait((char *)topic,  size,  SHM_BUS_KEY);
}
 
 
 
/**
 * 获取soket端口号
 */
int net_mod_socket_get_key(void * _socket) {
    NetModSocket *sockt = (NetModSocket *)_socket;
    return sockt->get_key();
}
 
 
/**
 * 释放存储接收信息的buf
 */
void net_mod_socket_free(void *buf) {
    free(buf);
}
 
 
 
/**
 * 销毁sendandrecv方法返回的消息组 
 * @arr 消息组
 * @size 消息组的长度
 */
void  net_mod_socket_free_recv_msg_arr(net_mod_recv_msg_t * arr, int len) {
     
    return NetModSocket::free_recv_msg_arr(arr, len);
}
 
 
 
int shm_mod_socket_remove_keys(int keys[], int length){
    return ShmModSocket::remove_keys(keys, length);
}
 
int shm_mod_socket_remove_key(int key){
    int keys[] = {key};
    return ShmModSocket::remove_keys(keys, 1);
}