czmq-ffi-gen 0.9.1-x86-mingw32
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +7 -0
- data/AUTHORS +1 -0
- data/CHANGES.md +88 -0
- data/Gemfile +2 -0
- data/LICENSE +14 -0
- data/README.md +112 -0
- data/lib/czmq-ffi-gen.rb +7 -0
- data/lib/czmq-ffi-gen/czmq/ffi.rb +1210 -0
- data/lib/czmq-ffi-gen/czmq/ffi/version.rb +15 -0
- data/lib/czmq-ffi-gen/czmq/ffi/zactor.rb +186 -0
- data/lib/czmq-ffi-gen/czmq/ffi/zarmour.rb +286 -0
- data/lib/czmq-ffi-gen/czmq/ffi/zcert.rb +307 -0
- data/lib/czmq-ffi-gen/czmq/ffi/zcertstore.rb +222 -0
- data/lib/czmq-ffi-gen/czmq/ffi/zchunk.rb +388 -0
- data/lib/czmq-ffi-gen/czmq/ffi/zclock.rb +140 -0
- data/lib/czmq-ffi-gen/czmq/ffi/zconfig.rb +442 -0
- data/lib/czmq-ffi-gen/czmq/ffi/zdigest.rb +156 -0
- data/lib/czmq-ffi-gen/czmq/ffi/zdir.rb +283 -0
- data/lib/czmq-ffi-gen/czmq/ffi/zdir_patch.rb +194 -0
- data/lib/czmq-ffi-gen/czmq/ffi/zfile.rb +353 -0
- data/lib/czmq-ffi-gen/czmq/ffi/zframe.rb +359 -0
- data/lib/czmq-ffi-gen/czmq/ffi/zhash.rb +416 -0
- data/lib/czmq-ffi-gen/czmq/ffi/zhashx.rb +659 -0
- data/lib/czmq-ffi-gen/czmq/ffi/ziflist.rb +189 -0
- data/lib/czmq-ffi-gen/czmq/ffi/zlist.rb +365 -0
- data/lib/czmq-ffi-gen/czmq/ffi/zlistx.rb +478 -0
- data/lib/czmq-ffi-gen/czmq/ffi/zloop.rb +396 -0
- data/lib/czmq-ffi-gen/czmq/ffi/zmsg.rb +515 -0
- data/lib/czmq-ffi-gen/czmq/ffi/zpoller.rb +194 -0
- data/lib/czmq-ffi-gen/czmq/ffi/zproc.rb +294 -0
- data/lib/czmq-ffi-gen/czmq/ffi/zsock.rb +3479 -0
- data/lib/czmq-ffi-gen/czmq/ffi/zstr.rb +203 -0
- data/lib/czmq-ffi-gen/czmq/ffi/ztimerset.rb +203 -0
- data/lib/czmq-ffi-gen/czmq/ffi/ztrie.rb +221 -0
- data/lib/czmq-ffi-gen/czmq/ffi/zuuid.rb +227 -0
- data/lib/czmq-ffi-gen/errors.rb +12 -0
- data/lib/czmq-ffi-gen/gem_version.rb +5 -0
- data/lib/czmq-ffi-gen/legacy.rb +16 -0
- data/lib/czmq-ffi-gen/libzmq.rb +18 -0
- data/lib/czmq-ffi-gen/signals.rb +27 -0
- data/lib/czmq-ffi-gen/vendor.rb +5 -0
- data/lib/czmq-ffi-gen/versions.rb +19 -0
- data/vendor/local/bin/inproc_lat.exe +0 -0
- data/vendor/local/bin/inproc_thr.exe +0 -0
- data/vendor/local/bin/libczmq.dll +0 -0
- data/vendor/local/bin/libgcc_s_sjlj-1.dll +0 -0
- data/vendor/local/bin/libstdc++-6.dll +0 -0
- data/vendor/local/bin/libzmq.dll +0 -0
- data/vendor/local/bin/local_lat.exe +0 -0
- data/vendor/local/bin/local_thr.exe +0 -0
- data/vendor/local/bin/remote_lat.exe +0 -0
- data/vendor/local/bin/remote_thr.exe +0 -0
- data/vendor/local/include/czmq.h +31 -0
- data/vendor/local/include/czmq_library.h +199 -0
- data/vendor/local/include/czmq_prelude.h +641 -0
- data/vendor/local/include/readme.txt +83 -0
- data/vendor/local/include/sha1.h +76 -0
- data/vendor/local/include/sha1.inc_c +335 -0
- data/vendor/local/include/slre.h +92 -0
- data/vendor/local/include/slre.inc_c +660 -0
- data/vendor/local/include/zactor.h +76 -0
- data/vendor/local/include/zarmour.h +114 -0
- data/vendor/local/include/zauth.h +100 -0
- data/vendor/local/include/zauth_v2.h +88 -0
- data/vendor/local/include/zbeacon.h +86 -0
- data/vendor/local/include/zbeacon_v2.h +75 -0
- data/vendor/local/include/zcert.h +136 -0
- data/vendor/local/include/zcertstore.h +100 -0
- data/vendor/local/include/zchunk.h +163 -0
- data/vendor/local/include/zclock.h +73 -0
- data/vendor/local/include/zconfig.h +185 -0
- data/vendor/local/include/zctx.h +107 -0
- data/vendor/local/include/zdigest.h +65 -0
- data/vendor/local/include/zdir.h +149 -0
- data/vendor/local/include/zdir_patch.h +82 -0
- data/vendor/local/include/zfile.h +177 -0
- data/vendor/local/include/zframe.h +176 -0
- data/vendor/local/include/zgossip.h +95 -0
- data/vendor/local/include/zgossip_engine.inc +927 -0
- data/vendor/local/include/zgossip_msg.h +129 -0
- data/vendor/local/include/zhash.h +195 -0
- data/vendor/local/include/zhash_primes.inc +329 -0
- data/vendor/local/include/zhashx.h +298 -0
- data/vendor/local/include/ziflist.h +77 -0
- data/vendor/local/include/zlist.h +158 -0
- data/vendor/local/include/zlistx.h +205 -0
- data/vendor/local/include/zloop.h +168 -0
- data/vendor/local/include/zmonitor.h +73 -0
- data/vendor/local/include/zmonitor_v2.h +56 -0
- data/vendor/local/include/zmq.h +617 -0
- data/vendor/local/include/zmq_utils.h +48 -0
- data/vendor/local/include/zmsg.h +280 -0
- data/vendor/local/include/zmutex.h +55 -0
- data/vendor/local/include/zpoller.h +92 -0
- data/vendor/local/include/zproc.h +168 -0
- data/vendor/local/include/zproxy.h +111 -0
- data/vendor/local/include/zproxy_v2.h +62 -0
- data/vendor/local/include/zrex.h +82 -0
- data/vendor/local/include/zsock.h +912 -0
- data/vendor/local/include/zsock_option.inc +4126 -0
- data/vendor/local/include/zsocket.h +110 -0
- data/vendor/local/include/zsockopt.h +256 -0
- data/vendor/local/include/zstr.h +110 -0
- data/vendor/local/include/zsys.h +386 -0
- data/vendor/local/include/zthread.h +50 -0
- data/vendor/local/include/ztimerset.h +90 -0
- data/vendor/local/include/ztrie.h +106 -0
- data/vendor/local/include/zuuid.h +96 -0
- data/vendor/local/lib/libczmq.dll.a +0 -0
- data/vendor/local/lib/liblibzmq.dll.a +0 -0
- data/vendor/local/lib/libzmq-static.a +0 -0
- data/vendor/local/lib/pkgconfig/libczmq.pc +23 -0
- data/vendor/local/lib/pkgconfig/libzmq.pc +11 -0
- data/vendor/local/share/zmq/AUTHORS.txt +147 -0
- data/vendor/local/share/zmq/COPYING.LESSER.txt +181 -0
- data/vendor/local/share/zmq/COPYING.txt +674 -0
- data/vendor/local/share/zmq/NEWS.txt +978 -0
- metadata +230 -0
@@ -0,0 +1,4126 @@
|
|
1
|
+
/* =========================================================================
|
2
|
+
zsock_option - get/set ZeroMQ socket options
|
3
|
+
|
4
|
+
******************************************************************
|
5
|
+
* GENERATED SOURCE CODE, DO NOT EDIT!! *
|
6
|
+
* TO CHANGE THIS FILE: *
|
7
|
+
* - EDIT src/zsock_option.gsl and/or *
|
8
|
+
* - EDIT src/zsock_option.xml and then *
|
9
|
+
* - RUN 'make code' *
|
10
|
+
******************************************************************
|
11
|
+
|
12
|
+
Copyright (c) the Contributors as noted in the AUTHORS file.
|
13
|
+
This file is part of CZMQ, the high-level C binding for ZeroMQ:
|
14
|
+
http://czmq.zeromq.org.
|
15
|
+
|
16
|
+
This Source Code Form is subject to the terms of the Mozilla Public
|
17
|
+
License, v. 2.0. If a copy of the MPL was not distributed with this
|
18
|
+
file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
19
|
+
=========================================================================
|
20
|
+
*/
|
21
|
+
|
22
|
+
#if (ZMQ_VERSION_MAJOR == 4)
|
23
|
+
// --------------------------------------------------------------------------
|
24
|
+
// Set socket ZMQ_HEARTBEAT_IVL value
|
25
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
26
|
+
|
27
|
+
void
|
28
|
+
zsock_set_heartbeat_ivl (void *self, int heartbeat_ivl)
|
29
|
+
{
|
30
|
+
assert (self);
|
31
|
+
# if defined (ZMQ_HEARTBEAT_IVL)
|
32
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_HEARTBEAT_IVL, &heartbeat_ivl, sizeof (int));
|
33
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
34
|
+
# endif
|
35
|
+
}
|
36
|
+
|
37
|
+
|
38
|
+
// --------------------------------------------------------------------------
|
39
|
+
// Return socket ZMQ_HEARTBEAT_IVL value
|
40
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
41
|
+
|
42
|
+
int
|
43
|
+
zsock_heartbeat_ivl (void *self)
|
44
|
+
{
|
45
|
+
assert (self);
|
46
|
+
# if defined (ZMQ_HEARTBEAT_IVL)
|
47
|
+
int heartbeat_ivl;
|
48
|
+
size_t option_len = sizeof (int);
|
49
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_HEARTBEAT_IVL, &heartbeat_ivl, &option_len);
|
50
|
+
return heartbeat_ivl;
|
51
|
+
# else
|
52
|
+
return 0;
|
53
|
+
# endif
|
54
|
+
}
|
55
|
+
|
56
|
+
// --------------------------------------------------------------------------
|
57
|
+
// Set socket ZMQ_HEARTBEAT_TTL value
|
58
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
59
|
+
|
60
|
+
void
|
61
|
+
zsock_set_heartbeat_ttl (void *self, int heartbeat_ttl)
|
62
|
+
{
|
63
|
+
assert (self);
|
64
|
+
# if defined (ZMQ_HEARTBEAT_TTL)
|
65
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_HEARTBEAT_TTL, &heartbeat_ttl, sizeof (int));
|
66
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
67
|
+
# endif
|
68
|
+
}
|
69
|
+
|
70
|
+
|
71
|
+
// --------------------------------------------------------------------------
|
72
|
+
// Return socket ZMQ_HEARTBEAT_TTL value
|
73
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
74
|
+
|
75
|
+
int
|
76
|
+
zsock_heartbeat_ttl (void *self)
|
77
|
+
{
|
78
|
+
assert (self);
|
79
|
+
# if defined (ZMQ_HEARTBEAT_TTL)
|
80
|
+
int heartbeat_ttl;
|
81
|
+
size_t option_len = sizeof (int);
|
82
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_HEARTBEAT_TTL, &heartbeat_ttl, &option_len);
|
83
|
+
return heartbeat_ttl;
|
84
|
+
# else
|
85
|
+
return 0;
|
86
|
+
# endif
|
87
|
+
}
|
88
|
+
|
89
|
+
// --------------------------------------------------------------------------
|
90
|
+
// Set socket ZMQ_HEARTBEAT_TIMEOUT value
|
91
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
92
|
+
|
93
|
+
void
|
94
|
+
zsock_set_heartbeat_timeout (void *self, int heartbeat_timeout)
|
95
|
+
{
|
96
|
+
assert (self);
|
97
|
+
# if defined (ZMQ_HEARTBEAT_TIMEOUT)
|
98
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_HEARTBEAT_TIMEOUT, &heartbeat_timeout, sizeof (int));
|
99
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
100
|
+
# endif
|
101
|
+
}
|
102
|
+
|
103
|
+
|
104
|
+
// --------------------------------------------------------------------------
|
105
|
+
// Return socket ZMQ_HEARTBEAT_TIMEOUT value
|
106
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
107
|
+
|
108
|
+
int
|
109
|
+
zsock_heartbeat_timeout (void *self)
|
110
|
+
{
|
111
|
+
assert (self);
|
112
|
+
# if defined (ZMQ_HEARTBEAT_TIMEOUT)
|
113
|
+
int heartbeat_timeout;
|
114
|
+
size_t option_len = sizeof (int);
|
115
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_HEARTBEAT_TIMEOUT, &heartbeat_timeout, &option_len);
|
116
|
+
return heartbeat_timeout;
|
117
|
+
# else
|
118
|
+
return 0;
|
119
|
+
# endif
|
120
|
+
}
|
121
|
+
|
122
|
+
// --------------------------------------------------------------------------
|
123
|
+
// Set socket ZMQ_USE_FD value
|
124
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
125
|
+
|
126
|
+
void
|
127
|
+
zsock_set_use_fd (void *self, int use_fd)
|
128
|
+
{
|
129
|
+
assert (self);
|
130
|
+
# if defined (ZMQ_USE_FD)
|
131
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_USE_FD, &use_fd, sizeof (int));
|
132
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
133
|
+
# endif
|
134
|
+
}
|
135
|
+
|
136
|
+
|
137
|
+
// --------------------------------------------------------------------------
|
138
|
+
// Return socket ZMQ_USE_FD value
|
139
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
140
|
+
|
141
|
+
int
|
142
|
+
zsock_use_fd (void *self)
|
143
|
+
{
|
144
|
+
assert (self);
|
145
|
+
# if defined (ZMQ_USE_FD)
|
146
|
+
int use_fd;
|
147
|
+
size_t option_len = sizeof (int);
|
148
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_USE_FD, &use_fd, &option_len);
|
149
|
+
return use_fd;
|
150
|
+
# else
|
151
|
+
return 0;
|
152
|
+
# endif
|
153
|
+
}
|
154
|
+
|
155
|
+
// --------------------------------------------------------------------------
|
156
|
+
// Set socket ZMQ_TOS value
|
157
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
158
|
+
|
159
|
+
void
|
160
|
+
zsock_set_tos (void *self, int tos)
|
161
|
+
{
|
162
|
+
assert (self);
|
163
|
+
# if defined (ZMQ_TOS)
|
164
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_TOS, &tos, sizeof (int));
|
165
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
166
|
+
# endif
|
167
|
+
}
|
168
|
+
|
169
|
+
|
170
|
+
// --------------------------------------------------------------------------
|
171
|
+
// Return socket ZMQ_TOS value
|
172
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
173
|
+
|
174
|
+
int
|
175
|
+
zsock_tos (void *self)
|
176
|
+
{
|
177
|
+
assert (self);
|
178
|
+
# if defined (ZMQ_TOS)
|
179
|
+
int tos;
|
180
|
+
size_t option_len = sizeof (int);
|
181
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_TOS, &tos, &option_len);
|
182
|
+
return tos;
|
183
|
+
# else
|
184
|
+
return 0;
|
185
|
+
# endif
|
186
|
+
}
|
187
|
+
|
188
|
+
// --------------------------------------------------------------------------
|
189
|
+
// Set socket ZMQ_ROUTER_HANDOVER value
|
190
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
191
|
+
|
192
|
+
void
|
193
|
+
zsock_set_router_handover (void *self, int router_handover)
|
194
|
+
{
|
195
|
+
assert (self);
|
196
|
+
# if defined (ZMQ_ROUTER_HANDOVER)
|
197
|
+
if (zsock_type (self) != ZMQ_ROUTER) {
|
198
|
+
printf ("ZMQ_ROUTER_HANDOVER is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
|
199
|
+
assert (false);
|
200
|
+
}
|
201
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_ROUTER_HANDOVER, &router_handover, sizeof (int));
|
202
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
203
|
+
# endif
|
204
|
+
}
|
205
|
+
|
206
|
+
|
207
|
+
// --------------------------------------------------------------------------
|
208
|
+
// Set socket ZMQ_ROUTER_MANDATORY value
|
209
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
210
|
+
|
211
|
+
void
|
212
|
+
zsock_set_router_mandatory (void *self, int router_mandatory)
|
213
|
+
{
|
214
|
+
assert (self);
|
215
|
+
# if defined (ZMQ_ROUTER_MANDATORY)
|
216
|
+
if (zsock_type (self) != ZMQ_ROUTER) {
|
217
|
+
printf ("ZMQ_ROUTER_MANDATORY is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
|
218
|
+
assert (false);
|
219
|
+
}
|
220
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_ROUTER_MANDATORY, &router_mandatory, sizeof (int));
|
221
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
222
|
+
# endif
|
223
|
+
}
|
224
|
+
|
225
|
+
|
226
|
+
// --------------------------------------------------------------------------
|
227
|
+
// Set socket ZMQ_PROBE_ROUTER value
|
228
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
229
|
+
|
230
|
+
void
|
231
|
+
zsock_set_probe_router (void *self, int probe_router)
|
232
|
+
{
|
233
|
+
assert (self);
|
234
|
+
# if defined (ZMQ_PROBE_ROUTER)
|
235
|
+
if (zsock_type (self) != ZMQ_ROUTER
|
236
|
+
&& zsock_type (self) != ZMQ_DEALER
|
237
|
+
&& zsock_type (self) != ZMQ_REQ) {
|
238
|
+
printf ("ZMQ_PROBE_ROUTER is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
|
239
|
+
assert (false);
|
240
|
+
}
|
241
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_PROBE_ROUTER, &probe_router, sizeof (int));
|
242
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
243
|
+
# endif
|
244
|
+
}
|
245
|
+
|
246
|
+
|
247
|
+
// --------------------------------------------------------------------------
|
248
|
+
// Set socket ZMQ_REQ_RELAXED value
|
249
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
250
|
+
|
251
|
+
void
|
252
|
+
zsock_set_req_relaxed (void *self, int req_relaxed)
|
253
|
+
{
|
254
|
+
assert (self);
|
255
|
+
# if defined (ZMQ_REQ_RELAXED)
|
256
|
+
if (zsock_type (self) != ZMQ_REQ) {
|
257
|
+
printf ("ZMQ_REQ_RELAXED is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
|
258
|
+
assert (false);
|
259
|
+
}
|
260
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_REQ_RELAXED, &req_relaxed, sizeof (int));
|
261
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
262
|
+
# endif
|
263
|
+
}
|
264
|
+
|
265
|
+
|
266
|
+
// --------------------------------------------------------------------------
|
267
|
+
// Set socket ZMQ_REQ_CORRELATE value
|
268
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
269
|
+
|
270
|
+
void
|
271
|
+
zsock_set_req_correlate (void *self, int req_correlate)
|
272
|
+
{
|
273
|
+
assert (self);
|
274
|
+
# if defined (ZMQ_REQ_CORRELATE)
|
275
|
+
if (zsock_type (self) != ZMQ_REQ) {
|
276
|
+
printf ("ZMQ_REQ_CORRELATE is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
|
277
|
+
assert (false);
|
278
|
+
}
|
279
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_REQ_CORRELATE, &req_correlate, sizeof (int));
|
280
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
281
|
+
# endif
|
282
|
+
}
|
283
|
+
|
284
|
+
|
285
|
+
// --------------------------------------------------------------------------
|
286
|
+
// Set socket ZMQ_CONFLATE value
|
287
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
288
|
+
|
289
|
+
void
|
290
|
+
zsock_set_conflate (void *self, int conflate)
|
291
|
+
{
|
292
|
+
assert (self);
|
293
|
+
# if defined (ZMQ_CONFLATE)
|
294
|
+
if (zsock_type (self) != ZMQ_PUSH
|
295
|
+
&& zsock_type (self) != ZMQ_PULL
|
296
|
+
&& zsock_type (self) != ZMQ_PUB
|
297
|
+
&& zsock_type (self) != ZMQ_SUB
|
298
|
+
&& zsock_type (self) != ZMQ_DEALER) {
|
299
|
+
printf ("ZMQ_CONFLATE is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
|
300
|
+
assert (false);
|
301
|
+
}
|
302
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_CONFLATE, &conflate, sizeof (int));
|
303
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
304
|
+
# endif
|
305
|
+
}
|
306
|
+
|
307
|
+
|
308
|
+
// --------------------------------------------------------------------------
|
309
|
+
// Set socket ZMQ_ZAP_DOMAIN value
|
310
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
311
|
+
|
312
|
+
void
|
313
|
+
zsock_set_zap_domain (void *self, const char * zap_domain)
|
314
|
+
{
|
315
|
+
assert (self);
|
316
|
+
# if defined (ZMQ_ZAP_DOMAIN)
|
317
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_ZAP_DOMAIN, zap_domain, strlen (zap_domain));
|
318
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
319
|
+
# endif
|
320
|
+
}
|
321
|
+
|
322
|
+
|
323
|
+
// --------------------------------------------------------------------------
|
324
|
+
// Return socket ZMQ_ZAP_DOMAIN value
|
325
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
326
|
+
|
327
|
+
char *
|
328
|
+
zsock_zap_domain (void *self)
|
329
|
+
{
|
330
|
+
assert (self);
|
331
|
+
# if defined (ZMQ_ZAP_DOMAIN)
|
332
|
+
size_t option_len = 255;
|
333
|
+
char *zap_domain = (char *) zmalloc (option_len);
|
334
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_ZAP_DOMAIN, zap_domain, &option_len);
|
335
|
+
return (char *) zap_domain;
|
336
|
+
# else
|
337
|
+
return NULL;
|
338
|
+
# endif
|
339
|
+
}
|
340
|
+
|
341
|
+
// --------------------------------------------------------------------------
|
342
|
+
// Return socket ZMQ_MECHANISM value
|
343
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
344
|
+
|
345
|
+
int
|
346
|
+
zsock_mechanism (void *self)
|
347
|
+
{
|
348
|
+
assert (self);
|
349
|
+
# if defined (ZMQ_MECHANISM)
|
350
|
+
int mechanism;
|
351
|
+
size_t option_len = sizeof (int);
|
352
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_MECHANISM, &mechanism, &option_len);
|
353
|
+
return mechanism;
|
354
|
+
# else
|
355
|
+
return 0;
|
356
|
+
# endif
|
357
|
+
}
|
358
|
+
|
359
|
+
// --------------------------------------------------------------------------
|
360
|
+
// Set socket ZMQ_PLAIN_SERVER value
|
361
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
362
|
+
|
363
|
+
void
|
364
|
+
zsock_set_plain_server (void *self, int plain_server)
|
365
|
+
{
|
366
|
+
assert (self);
|
367
|
+
# if defined (ZMQ_PLAIN_SERVER)
|
368
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_PLAIN_SERVER, &plain_server, sizeof (int));
|
369
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
370
|
+
# endif
|
371
|
+
}
|
372
|
+
|
373
|
+
|
374
|
+
// --------------------------------------------------------------------------
|
375
|
+
// Return socket ZMQ_PLAIN_SERVER value
|
376
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
377
|
+
|
378
|
+
int
|
379
|
+
zsock_plain_server (void *self)
|
380
|
+
{
|
381
|
+
assert (self);
|
382
|
+
# if defined (ZMQ_PLAIN_SERVER)
|
383
|
+
int plain_server;
|
384
|
+
size_t option_len = sizeof (int);
|
385
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_PLAIN_SERVER, &plain_server, &option_len);
|
386
|
+
return plain_server;
|
387
|
+
# else
|
388
|
+
return 0;
|
389
|
+
# endif
|
390
|
+
}
|
391
|
+
|
392
|
+
// --------------------------------------------------------------------------
|
393
|
+
// Set socket ZMQ_PLAIN_USERNAME value
|
394
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
395
|
+
|
396
|
+
void
|
397
|
+
zsock_set_plain_username (void *self, const char * plain_username)
|
398
|
+
{
|
399
|
+
assert (self);
|
400
|
+
# if defined (ZMQ_PLAIN_USERNAME)
|
401
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_PLAIN_USERNAME, plain_username, strlen (plain_username));
|
402
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
403
|
+
# endif
|
404
|
+
}
|
405
|
+
|
406
|
+
|
407
|
+
// --------------------------------------------------------------------------
|
408
|
+
// Return socket ZMQ_PLAIN_USERNAME value
|
409
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
410
|
+
|
411
|
+
char *
|
412
|
+
zsock_plain_username (void *self)
|
413
|
+
{
|
414
|
+
assert (self);
|
415
|
+
# if defined (ZMQ_PLAIN_USERNAME)
|
416
|
+
size_t option_len = 255;
|
417
|
+
char *plain_username = (char *) zmalloc (option_len);
|
418
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_PLAIN_USERNAME, plain_username, &option_len);
|
419
|
+
return (char *) plain_username;
|
420
|
+
# else
|
421
|
+
return NULL;
|
422
|
+
# endif
|
423
|
+
}
|
424
|
+
|
425
|
+
// --------------------------------------------------------------------------
|
426
|
+
// Set socket ZMQ_PLAIN_PASSWORD value
|
427
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
428
|
+
|
429
|
+
void
|
430
|
+
zsock_set_plain_password (void *self, const char * plain_password)
|
431
|
+
{
|
432
|
+
assert (self);
|
433
|
+
# if defined (ZMQ_PLAIN_PASSWORD)
|
434
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_PLAIN_PASSWORD, plain_password, strlen (plain_password));
|
435
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
436
|
+
# endif
|
437
|
+
}
|
438
|
+
|
439
|
+
|
440
|
+
// --------------------------------------------------------------------------
|
441
|
+
// Return socket ZMQ_PLAIN_PASSWORD value
|
442
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
443
|
+
|
444
|
+
char *
|
445
|
+
zsock_plain_password (void *self)
|
446
|
+
{
|
447
|
+
assert (self);
|
448
|
+
# if defined (ZMQ_PLAIN_PASSWORD)
|
449
|
+
size_t option_len = 255;
|
450
|
+
char *plain_password = (char *) zmalloc (option_len);
|
451
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_PLAIN_PASSWORD, plain_password, &option_len);
|
452
|
+
return (char *) plain_password;
|
453
|
+
# else
|
454
|
+
return NULL;
|
455
|
+
# endif
|
456
|
+
}
|
457
|
+
|
458
|
+
// --------------------------------------------------------------------------
|
459
|
+
// Set socket ZMQ_CURVE_SERVER value
|
460
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
461
|
+
|
462
|
+
void
|
463
|
+
zsock_set_curve_server (void *self, int curve_server)
|
464
|
+
{
|
465
|
+
assert (self);
|
466
|
+
# if defined (ZMQ_CURVE_SERVER)
|
467
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_CURVE_SERVER, &curve_server, sizeof (int));
|
468
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
469
|
+
# endif
|
470
|
+
}
|
471
|
+
|
472
|
+
|
473
|
+
// --------------------------------------------------------------------------
|
474
|
+
// Return socket ZMQ_CURVE_SERVER value
|
475
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
476
|
+
|
477
|
+
int
|
478
|
+
zsock_curve_server (void *self)
|
479
|
+
{
|
480
|
+
assert (self);
|
481
|
+
# if defined (ZMQ_CURVE_SERVER)
|
482
|
+
int curve_server;
|
483
|
+
size_t option_len = sizeof (int);
|
484
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_CURVE_SERVER, &curve_server, &option_len);
|
485
|
+
return curve_server;
|
486
|
+
# else
|
487
|
+
return 0;
|
488
|
+
# endif
|
489
|
+
}
|
490
|
+
|
491
|
+
// --------------------------------------------------------------------------
|
492
|
+
// Set socket ZMQ_CURVE_PUBLICKEY value
|
493
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
494
|
+
|
495
|
+
void
|
496
|
+
zsock_set_curve_publickey (void *self, const char * curve_publickey)
|
497
|
+
{
|
498
|
+
assert (self);
|
499
|
+
# if defined (ZMQ_CURVE_PUBLICKEY)
|
500
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_CURVE_PUBLICKEY, curve_publickey, strlen (curve_publickey));
|
501
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
502
|
+
# endif
|
503
|
+
}
|
504
|
+
|
505
|
+
|
506
|
+
// --------------------------------------------------------------------------
|
507
|
+
// Set socket ZMQ_CURVE_PUBLICKEY value from 32-octet binary
|
508
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
509
|
+
|
510
|
+
void
|
511
|
+
zsock_set_curve_publickey_bin (void *self, const byte *curve_publickey)
|
512
|
+
{
|
513
|
+
# if defined (ZMQ_CURVE_PUBLICKEY)
|
514
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_CURVE_PUBLICKEY, curve_publickey, 32);
|
515
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
516
|
+
# endif
|
517
|
+
}
|
518
|
+
|
519
|
+
|
520
|
+
// --------------------------------------------------------------------------
|
521
|
+
// Return socket ZMQ_CURVE_PUBLICKEY value
|
522
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
523
|
+
|
524
|
+
char *
|
525
|
+
zsock_curve_publickey (void *self)
|
526
|
+
{
|
527
|
+
assert (self);
|
528
|
+
# if defined (ZMQ_CURVE_PUBLICKEY)
|
529
|
+
size_t option_len = 40 + 1; // Z85 key + terminator
|
530
|
+
char *curve_publickey = (char *) zmalloc (option_len);
|
531
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_CURVE_PUBLICKEY, curve_publickey, &option_len);
|
532
|
+
return (char *) curve_publickey;
|
533
|
+
# else
|
534
|
+
return NULL;
|
535
|
+
# endif
|
536
|
+
}
|
537
|
+
|
538
|
+
// --------------------------------------------------------------------------
|
539
|
+
// Set socket ZMQ_CURVE_SECRETKEY value
|
540
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
541
|
+
|
542
|
+
void
|
543
|
+
zsock_set_curve_secretkey (void *self, const char * curve_secretkey)
|
544
|
+
{
|
545
|
+
assert (self);
|
546
|
+
# if defined (ZMQ_CURVE_SECRETKEY)
|
547
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_CURVE_SECRETKEY, curve_secretkey, strlen (curve_secretkey));
|
548
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
549
|
+
# endif
|
550
|
+
}
|
551
|
+
|
552
|
+
|
553
|
+
// --------------------------------------------------------------------------
|
554
|
+
// Set socket ZMQ_CURVE_SECRETKEY value from 32-octet binary
|
555
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
556
|
+
|
557
|
+
void
|
558
|
+
zsock_set_curve_secretkey_bin (void *self, const byte *curve_secretkey)
|
559
|
+
{
|
560
|
+
# if defined (ZMQ_CURVE_SECRETKEY)
|
561
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_CURVE_SECRETKEY, curve_secretkey, 32);
|
562
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
563
|
+
# endif
|
564
|
+
}
|
565
|
+
|
566
|
+
|
567
|
+
// --------------------------------------------------------------------------
|
568
|
+
// Return socket ZMQ_CURVE_SECRETKEY value
|
569
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
570
|
+
|
571
|
+
char *
|
572
|
+
zsock_curve_secretkey (void *self)
|
573
|
+
{
|
574
|
+
assert (self);
|
575
|
+
# if defined (ZMQ_CURVE_SECRETKEY)
|
576
|
+
size_t option_len = 40 + 1; // Z85 key + terminator
|
577
|
+
char *curve_secretkey = (char *) zmalloc (option_len);
|
578
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_CURVE_SECRETKEY, curve_secretkey, &option_len);
|
579
|
+
return (char *) curve_secretkey;
|
580
|
+
# else
|
581
|
+
return NULL;
|
582
|
+
# endif
|
583
|
+
}
|
584
|
+
|
585
|
+
// --------------------------------------------------------------------------
|
586
|
+
// Set socket ZMQ_CURVE_SERVERKEY value
|
587
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
588
|
+
|
589
|
+
void
|
590
|
+
zsock_set_curve_serverkey (void *self, const char * curve_serverkey)
|
591
|
+
{
|
592
|
+
assert (self);
|
593
|
+
# if defined (ZMQ_CURVE_SERVERKEY)
|
594
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_CURVE_SERVERKEY, curve_serverkey, strlen (curve_serverkey));
|
595
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
596
|
+
# endif
|
597
|
+
}
|
598
|
+
|
599
|
+
|
600
|
+
// --------------------------------------------------------------------------
|
601
|
+
// Set socket ZMQ_CURVE_SERVERKEY value from 32-octet binary
|
602
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
603
|
+
|
604
|
+
void
|
605
|
+
zsock_set_curve_serverkey_bin (void *self, const byte *curve_serverkey)
|
606
|
+
{
|
607
|
+
# if defined (ZMQ_CURVE_SERVERKEY)
|
608
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_CURVE_SERVERKEY, curve_serverkey, 32);
|
609
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
610
|
+
# endif
|
611
|
+
}
|
612
|
+
|
613
|
+
|
614
|
+
// --------------------------------------------------------------------------
|
615
|
+
// Return socket ZMQ_CURVE_SERVERKEY value
|
616
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
617
|
+
|
618
|
+
char *
|
619
|
+
zsock_curve_serverkey (void *self)
|
620
|
+
{
|
621
|
+
assert (self);
|
622
|
+
# if defined (ZMQ_CURVE_SERVERKEY)
|
623
|
+
size_t option_len = 40 + 1; // Z85 key + terminator
|
624
|
+
char *curve_serverkey = (char *) zmalloc (option_len);
|
625
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_CURVE_SERVERKEY, curve_serverkey, &option_len);
|
626
|
+
return (char *) curve_serverkey;
|
627
|
+
# else
|
628
|
+
return NULL;
|
629
|
+
# endif
|
630
|
+
}
|
631
|
+
|
632
|
+
// --------------------------------------------------------------------------
|
633
|
+
// Set socket ZMQ_GSSAPI_SERVER value
|
634
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
635
|
+
|
636
|
+
void
|
637
|
+
zsock_set_gssapi_server (void *self, int gssapi_server)
|
638
|
+
{
|
639
|
+
assert (self);
|
640
|
+
# if defined (ZMQ_GSSAPI_SERVER)
|
641
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_GSSAPI_SERVER, &gssapi_server, sizeof (int));
|
642
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
643
|
+
# endif
|
644
|
+
}
|
645
|
+
|
646
|
+
|
647
|
+
// --------------------------------------------------------------------------
|
648
|
+
// Return socket ZMQ_GSSAPI_SERVER value
|
649
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
650
|
+
|
651
|
+
int
|
652
|
+
zsock_gssapi_server (void *self)
|
653
|
+
{
|
654
|
+
assert (self);
|
655
|
+
# if defined (ZMQ_GSSAPI_SERVER)
|
656
|
+
int gssapi_server;
|
657
|
+
size_t option_len = sizeof (int);
|
658
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_GSSAPI_SERVER, &gssapi_server, &option_len);
|
659
|
+
return gssapi_server;
|
660
|
+
# else
|
661
|
+
return 0;
|
662
|
+
# endif
|
663
|
+
}
|
664
|
+
|
665
|
+
// --------------------------------------------------------------------------
|
666
|
+
// Set socket ZMQ_GSSAPI_PLAINTEXT value
|
667
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
668
|
+
|
669
|
+
void
|
670
|
+
zsock_set_gssapi_plaintext (void *self, int gssapi_plaintext)
|
671
|
+
{
|
672
|
+
assert (self);
|
673
|
+
# if defined (ZMQ_GSSAPI_PLAINTEXT)
|
674
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_GSSAPI_PLAINTEXT, &gssapi_plaintext, sizeof (int));
|
675
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
676
|
+
# endif
|
677
|
+
}
|
678
|
+
|
679
|
+
|
680
|
+
// --------------------------------------------------------------------------
|
681
|
+
// Return socket ZMQ_GSSAPI_PLAINTEXT value
|
682
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
683
|
+
|
684
|
+
int
|
685
|
+
zsock_gssapi_plaintext (void *self)
|
686
|
+
{
|
687
|
+
assert (self);
|
688
|
+
# if defined (ZMQ_GSSAPI_PLAINTEXT)
|
689
|
+
int gssapi_plaintext;
|
690
|
+
size_t option_len = sizeof (int);
|
691
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_GSSAPI_PLAINTEXT, &gssapi_plaintext, &option_len);
|
692
|
+
return gssapi_plaintext;
|
693
|
+
# else
|
694
|
+
return 0;
|
695
|
+
# endif
|
696
|
+
}
|
697
|
+
|
698
|
+
// --------------------------------------------------------------------------
|
699
|
+
// Set socket ZMQ_GSSAPI_PRINCIPAL value
|
700
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
701
|
+
|
702
|
+
void
|
703
|
+
zsock_set_gssapi_principal (void *self, const char * gssapi_principal)
|
704
|
+
{
|
705
|
+
assert (self);
|
706
|
+
# if defined (ZMQ_GSSAPI_PRINCIPAL)
|
707
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_GSSAPI_PRINCIPAL, gssapi_principal, strlen (gssapi_principal));
|
708
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
709
|
+
# endif
|
710
|
+
}
|
711
|
+
|
712
|
+
|
713
|
+
// --------------------------------------------------------------------------
|
714
|
+
// Return socket ZMQ_GSSAPI_PRINCIPAL value
|
715
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
716
|
+
|
717
|
+
char *
|
718
|
+
zsock_gssapi_principal (void *self)
|
719
|
+
{
|
720
|
+
assert (self);
|
721
|
+
# if defined (ZMQ_GSSAPI_PRINCIPAL)
|
722
|
+
size_t option_len = 255;
|
723
|
+
char *gssapi_principal = (char *) zmalloc (option_len);
|
724
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_GSSAPI_PRINCIPAL, gssapi_principal, &option_len);
|
725
|
+
return (char *) gssapi_principal;
|
726
|
+
# else
|
727
|
+
return NULL;
|
728
|
+
# endif
|
729
|
+
}
|
730
|
+
|
731
|
+
// --------------------------------------------------------------------------
|
732
|
+
// Set socket ZMQ_GSSAPI_SERVICE_PRINCIPAL value
|
733
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
734
|
+
|
735
|
+
void
|
736
|
+
zsock_set_gssapi_service_principal (void *self, const char * gssapi_service_principal)
|
737
|
+
{
|
738
|
+
assert (self);
|
739
|
+
# if defined (ZMQ_GSSAPI_SERVICE_PRINCIPAL)
|
740
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_GSSAPI_SERVICE_PRINCIPAL, gssapi_service_principal, strlen (gssapi_service_principal));
|
741
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
742
|
+
# endif
|
743
|
+
}
|
744
|
+
|
745
|
+
|
746
|
+
// --------------------------------------------------------------------------
|
747
|
+
// Return socket ZMQ_GSSAPI_SERVICE_PRINCIPAL value
|
748
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
749
|
+
|
750
|
+
char *
|
751
|
+
zsock_gssapi_service_principal (void *self)
|
752
|
+
{
|
753
|
+
assert (self);
|
754
|
+
# if defined (ZMQ_GSSAPI_SERVICE_PRINCIPAL)
|
755
|
+
size_t option_len = 255;
|
756
|
+
char *gssapi_service_principal = (char *) zmalloc (option_len);
|
757
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_GSSAPI_SERVICE_PRINCIPAL, gssapi_service_principal, &option_len);
|
758
|
+
return (char *) gssapi_service_principal;
|
759
|
+
# else
|
760
|
+
return NULL;
|
761
|
+
# endif
|
762
|
+
}
|
763
|
+
|
764
|
+
// --------------------------------------------------------------------------
|
765
|
+
// Set socket ZMQ_IPV6 value
|
766
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
767
|
+
|
768
|
+
void
|
769
|
+
zsock_set_ipv6 (void *self, int ipv6)
|
770
|
+
{
|
771
|
+
assert (self);
|
772
|
+
# if defined (ZMQ_IPV6)
|
773
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_IPV6, &ipv6, sizeof (int));
|
774
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
775
|
+
# endif
|
776
|
+
}
|
777
|
+
|
778
|
+
|
779
|
+
// --------------------------------------------------------------------------
|
780
|
+
// Return socket ZMQ_IPV6 value
|
781
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
782
|
+
|
783
|
+
int
|
784
|
+
zsock_ipv6 (void *self)
|
785
|
+
{
|
786
|
+
assert (self);
|
787
|
+
# if defined (ZMQ_IPV6)
|
788
|
+
int ipv6;
|
789
|
+
size_t option_len = sizeof (int);
|
790
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_IPV6, &ipv6, &option_len);
|
791
|
+
return ipv6;
|
792
|
+
# else
|
793
|
+
return 0;
|
794
|
+
# endif
|
795
|
+
}
|
796
|
+
|
797
|
+
// --------------------------------------------------------------------------
|
798
|
+
// Set socket ZMQ_IMMEDIATE value
|
799
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
800
|
+
|
801
|
+
void
|
802
|
+
zsock_set_immediate (void *self, int immediate)
|
803
|
+
{
|
804
|
+
assert (self);
|
805
|
+
# if defined (ZMQ_IMMEDIATE)
|
806
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_IMMEDIATE, &immediate, sizeof (int));
|
807
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
808
|
+
# endif
|
809
|
+
}
|
810
|
+
|
811
|
+
|
812
|
+
// --------------------------------------------------------------------------
|
813
|
+
// Return socket ZMQ_IMMEDIATE value
|
814
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
815
|
+
|
816
|
+
int
|
817
|
+
zsock_immediate (void *self)
|
818
|
+
{
|
819
|
+
assert (self);
|
820
|
+
# if defined (ZMQ_IMMEDIATE)
|
821
|
+
int immediate;
|
822
|
+
size_t option_len = sizeof (int);
|
823
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_IMMEDIATE, &immediate, &option_len);
|
824
|
+
return immediate;
|
825
|
+
# else
|
826
|
+
return 0;
|
827
|
+
# endif
|
828
|
+
}
|
829
|
+
|
830
|
+
// --------------------------------------------------------------------------
|
831
|
+
// Set socket ZMQ_ROUTER_RAW value
|
832
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
833
|
+
|
834
|
+
void
|
835
|
+
zsock_set_router_raw (void *self, int router_raw)
|
836
|
+
{
|
837
|
+
assert (self);
|
838
|
+
# if defined (ZMQ_ROUTER_RAW)
|
839
|
+
if (zsock_type (self) != ZMQ_ROUTER) {
|
840
|
+
printf ("ZMQ_ROUTER_RAW is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
|
841
|
+
assert (false);
|
842
|
+
}
|
843
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_ROUTER_RAW, &router_raw, sizeof (int));
|
844
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
845
|
+
# endif
|
846
|
+
}
|
847
|
+
|
848
|
+
|
849
|
+
// --------------------------------------------------------------------------
|
850
|
+
// Set socket ZMQ_IPV4ONLY value
|
851
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
852
|
+
|
853
|
+
void
|
854
|
+
zsock_set_ipv4only (void *self, int ipv4only)
|
855
|
+
{
|
856
|
+
assert (self);
|
857
|
+
# if defined (ZMQ_IPV4ONLY)
|
858
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_IPV4ONLY, &ipv4only, sizeof (int));
|
859
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
860
|
+
# endif
|
861
|
+
}
|
862
|
+
|
863
|
+
|
864
|
+
// --------------------------------------------------------------------------
|
865
|
+
// Return socket ZMQ_IPV4ONLY value
|
866
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
867
|
+
|
868
|
+
int
|
869
|
+
zsock_ipv4only (void *self)
|
870
|
+
{
|
871
|
+
assert (self);
|
872
|
+
# if defined (ZMQ_IPV4ONLY)
|
873
|
+
int ipv4only;
|
874
|
+
size_t option_len = sizeof (int);
|
875
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_IPV4ONLY, &ipv4only, &option_len);
|
876
|
+
return ipv4only;
|
877
|
+
# else
|
878
|
+
return 0;
|
879
|
+
# endif
|
880
|
+
}
|
881
|
+
|
882
|
+
// --------------------------------------------------------------------------
|
883
|
+
// Set socket ZMQ_DELAY_ATTACH_ON_CONNECT value
|
884
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
885
|
+
|
886
|
+
void
|
887
|
+
zsock_set_delay_attach_on_connect (void *self, int delay_attach_on_connect)
|
888
|
+
{
|
889
|
+
assert (self);
|
890
|
+
# if defined (ZMQ_DELAY_ATTACH_ON_CONNECT)
|
891
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_DELAY_ATTACH_ON_CONNECT, &delay_attach_on_connect, sizeof (int));
|
892
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
893
|
+
# endif
|
894
|
+
}
|
895
|
+
|
896
|
+
|
897
|
+
// --------------------------------------------------------------------------
|
898
|
+
// Return socket ZMQ_TYPE value
|
899
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
900
|
+
|
901
|
+
int
|
902
|
+
zsock_type (void *self)
|
903
|
+
{
|
904
|
+
assert (self);
|
905
|
+
# if defined (ZMQ_TYPE)
|
906
|
+
int type;
|
907
|
+
size_t option_len = sizeof (int);
|
908
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_TYPE, &type, &option_len);
|
909
|
+
return type;
|
910
|
+
# else
|
911
|
+
return 0;
|
912
|
+
# endif
|
913
|
+
}
|
914
|
+
|
915
|
+
// --------------------------------------------------------------------------
|
916
|
+
// Set socket ZMQ_SNDHWM value
|
917
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
918
|
+
|
919
|
+
void
|
920
|
+
zsock_set_sndhwm (void *self, int sndhwm)
|
921
|
+
{
|
922
|
+
assert (self);
|
923
|
+
# if defined (ZMQ_SNDHWM)
|
924
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_SNDHWM, &sndhwm, sizeof (int));
|
925
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
926
|
+
# endif
|
927
|
+
}
|
928
|
+
|
929
|
+
|
930
|
+
// --------------------------------------------------------------------------
|
931
|
+
// Return socket ZMQ_SNDHWM value
|
932
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
933
|
+
|
934
|
+
int
|
935
|
+
zsock_sndhwm (void *self)
|
936
|
+
{
|
937
|
+
assert (self);
|
938
|
+
# if defined (ZMQ_SNDHWM)
|
939
|
+
int sndhwm;
|
940
|
+
size_t option_len = sizeof (int);
|
941
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_SNDHWM, &sndhwm, &option_len);
|
942
|
+
return sndhwm;
|
943
|
+
# else
|
944
|
+
return 0;
|
945
|
+
# endif
|
946
|
+
}
|
947
|
+
|
948
|
+
// --------------------------------------------------------------------------
|
949
|
+
// Set socket ZMQ_RCVHWM value
|
950
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
951
|
+
|
952
|
+
void
|
953
|
+
zsock_set_rcvhwm (void *self, int rcvhwm)
|
954
|
+
{
|
955
|
+
assert (self);
|
956
|
+
# if defined (ZMQ_RCVHWM)
|
957
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_RCVHWM, &rcvhwm, sizeof (int));
|
958
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
959
|
+
# endif
|
960
|
+
}
|
961
|
+
|
962
|
+
|
963
|
+
// --------------------------------------------------------------------------
|
964
|
+
// Return socket ZMQ_RCVHWM value
|
965
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
966
|
+
|
967
|
+
int
|
968
|
+
zsock_rcvhwm (void *self)
|
969
|
+
{
|
970
|
+
assert (self);
|
971
|
+
# if defined (ZMQ_RCVHWM)
|
972
|
+
int rcvhwm;
|
973
|
+
size_t option_len = sizeof (int);
|
974
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RCVHWM, &rcvhwm, &option_len);
|
975
|
+
return rcvhwm;
|
976
|
+
# else
|
977
|
+
return 0;
|
978
|
+
# endif
|
979
|
+
}
|
980
|
+
|
981
|
+
// --------------------------------------------------------------------------
|
982
|
+
// Set socket ZMQ_AFFINITY value
|
983
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
984
|
+
|
985
|
+
void
|
986
|
+
zsock_set_affinity (void *self, int affinity)
|
987
|
+
{
|
988
|
+
assert (self);
|
989
|
+
# if defined (ZMQ_AFFINITY)
|
990
|
+
uint64_t value = affinity;
|
991
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_AFFINITY, &value, sizeof (uint64_t));
|
992
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
993
|
+
# endif
|
994
|
+
}
|
995
|
+
|
996
|
+
|
997
|
+
// --------------------------------------------------------------------------
|
998
|
+
// Return socket ZMQ_AFFINITY value
|
999
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1000
|
+
|
1001
|
+
int
|
1002
|
+
zsock_affinity (void *self)
|
1003
|
+
{
|
1004
|
+
assert (self);
|
1005
|
+
# if defined (ZMQ_AFFINITY)
|
1006
|
+
uint64_t affinity;
|
1007
|
+
size_t option_len = sizeof (uint64_t);
|
1008
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_AFFINITY, &affinity, &option_len);
|
1009
|
+
return (int) affinity;
|
1010
|
+
# else
|
1011
|
+
return 0;
|
1012
|
+
# endif
|
1013
|
+
}
|
1014
|
+
|
1015
|
+
// --------------------------------------------------------------------------
|
1016
|
+
// Set socket ZMQ_SUBSCRIBE value
|
1017
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1018
|
+
|
1019
|
+
void
|
1020
|
+
zsock_set_subscribe (void *self, const char * subscribe)
|
1021
|
+
{
|
1022
|
+
assert (self);
|
1023
|
+
# if defined (ZMQ_SUBSCRIBE)
|
1024
|
+
if (zsock_type (self) != ZMQ_SUB) {
|
1025
|
+
printf ("ZMQ_SUBSCRIBE is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
|
1026
|
+
assert (false);
|
1027
|
+
}
|
1028
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_SUBSCRIBE, subscribe, strlen (subscribe));
|
1029
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1030
|
+
# endif
|
1031
|
+
}
|
1032
|
+
|
1033
|
+
|
1034
|
+
// --------------------------------------------------------------------------
|
1035
|
+
// Set socket ZMQ_UNSUBSCRIBE value
|
1036
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1037
|
+
|
1038
|
+
void
|
1039
|
+
zsock_set_unsubscribe (void *self, const char * unsubscribe)
|
1040
|
+
{
|
1041
|
+
assert (self);
|
1042
|
+
# if defined (ZMQ_UNSUBSCRIBE)
|
1043
|
+
if (zsock_type (self) != ZMQ_SUB) {
|
1044
|
+
printf ("ZMQ_UNSUBSCRIBE is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
|
1045
|
+
assert (false);
|
1046
|
+
}
|
1047
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_UNSUBSCRIBE, unsubscribe, strlen (unsubscribe));
|
1048
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1049
|
+
# endif
|
1050
|
+
}
|
1051
|
+
|
1052
|
+
|
1053
|
+
// --------------------------------------------------------------------------
|
1054
|
+
// Set socket ZMQ_IDENTITY value
|
1055
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1056
|
+
|
1057
|
+
void
|
1058
|
+
zsock_set_identity (void *self, const char * identity)
|
1059
|
+
{
|
1060
|
+
assert (self);
|
1061
|
+
# if defined (ZMQ_IDENTITY)
|
1062
|
+
if (zsock_type (self) != ZMQ_REQ
|
1063
|
+
&& zsock_type (self) != ZMQ_REP
|
1064
|
+
&& zsock_type (self) != ZMQ_DEALER
|
1065
|
+
&& zsock_type (self) != ZMQ_ROUTER) {
|
1066
|
+
printf ("ZMQ_IDENTITY is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
|
1067
|
+
assert (false);
|
1068
|
+
}
|
1069
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_IDENTITY, identity, strlen (identity));
|
1070
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1071
|
+
# endif
|
1072
|
+
}
|
1073
|
+
|
1074
|
+
|
1075
|
+
// --------------------------------------------------------------------------
|
1076
|
+
// Return socket ZMQ_IDENTITY value
|
1077
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1078
|
+
|
1079
|
+
char *
|
1080
|
+
zsock_identity (void *self)
|
1081
|
+
{
|
1082
|
+
assert (self);
|
1083
|
+
# if defined (ZMQ_IDENTITY)
|
1084
|
+
size_t option_len = 255;
|
1085
|
+
char *identity = (char *) zmalloc (option_len);
|
1086
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_IDENTITY, identity, &option_len);
|
1087
|
+
return (char *) identity;
|
1088
|
+
# else
|
1089
|
+
return NULL;
|
1090
|
+
# endif
|
1091
|
+
}
|
1092
|
+
|
1093
|
+
// --------------------------------------------------------------------------
|
1094
|
+
// Set socket ZMQ_RATE value
|
1095
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1096
|
+
|
1097
|
+
void
|
1098
|
+
zsock_set_rate (void *self, int rate)
|
1099
|
+
{
|
1100
|
+
assert (self);
|
1101
|
+
# if defined (ZMQ_RATE)
|
1102
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_RATE, &rate, sizeof (int));
|
1103
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1104
|
+
# endif
|
1105
|
+
}
|
1106
|
+
|
1107
|
+
|
1108
|
+
// --------------------------------------------------------------------------
|
1109
|
+
// Return socket ZMQ_RATE value
|
1110
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1111
|
+
|
1112
|
+
int
|
1113
|
+
zsock_rate (void *self)
|
1114
|
+
{
|
1115
|
+
assert (self);
|
1116
|
+
# if defined (ZMQ_RATE)
|
1117
|
+
int rate;
|
1118
|
+
size_t option_len = sizeof (int);
|
1119
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RATE, &rate, &option_len);
|
1120
|
+
return rate;
|
1121
|
+
# else
|
1122
|
+
return 0;
|
1123
|
+
# endif
|
1124
|
+
}
|
1125
|
+
|
1126
|
+
// --------------------------------------------------------------------------
|
1127
|
+
// Set socket ZMQ_RECOVERY_IVL value
|
1128
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1129
|
+
|
1130
|
+
void
|
1131
|
+
zsock_set_recovery_ivl (void *self, int recovery_ivl)
|
1132
|
+
{
|
1133
|
+
assert (self);
|
1134
|
+
# if defined (ZMQ_RECOVERY_IVL)
|
1135
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_RECOVERY_IVL, &recovery_ivl, sizeof (int));
|
1136
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1137
|
+
# endif
|
1138
|
+
}
|
1139
|
+
|
1140
|
+
|
1141
|
+
// --------------------------------------------------------------------------
|
1142
|
+
// Return socket ZMQ_RECOVERY_IVL value
|
1143
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1144
|
+
|
1145
|
+
int
|
1146
|
+
zsock_recovery_ivl (void *self)
|
1147
|
+
{
|
1148
|
+
assert (self);
|
1149
|
+
# if defined (ZMQ_RECOVERY_IVL)
|
1150
|
+
int recovery_ivl;
|
1151
|
+
size_t option_len = sizeof (int);
|
1152
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RECOVERY_IVL, &recovery_ivl, &option_len);
|
1153
|
+
return recovery_ivl;
|
1154
|
+
# else
|
1155
|
+
return 0;
|
1156
|
+
# endif
|
1157
|
+
}
|
1158
|
+
|
1159
|
+
// --------------------------------------------------------------------------
|
1160
|
+
// Set socket ZMQ_SNDBUF value
|
1161
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1162
|
+
|
1163
|
+
void
|
1164
|
+
zsock_set_sndbuf (void *self, int sndbuf)
|
1165
|
+
{
|
1166
|
+
assert (self);
|
1167
|
+
# if defined (ZMQ_SNDBUF)
|
1168
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_SNDBUF, &sndbuf, sizeof (int));
|
1169
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1170
|
+
# endif
|
1171
|
+
}
|
1172
|
+
|
1173
|
+
|
1174
|
+
// --------------------------------------------------------------------------
|
1175
|
+
// Return socket ZMQ_SNDBUF value
|
1176
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1177
|
+
|
1178
|
+
int
|
1179
|
+
zsock_sndbuf (void *self)
|
1180
|
+
{
|
1181
|
+
assert (self);
|
1182
|
+
# if defined (ZMQ_SNDBUF)
|
1183
|
+
int sndbuf;
|
1184
|
+
size_t option_len = sizeof (int);
|
1185
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_SNDBUF, &sndbuf, &option_len);
|
1186
|
+
return sndbuf;
|
1187
|
+
# else
|
1188
|
+
return 0;
|
1189
|
+
# endif
|
1190
|
+
}
|
1191
|
+
|
1192
|
+
// --------------------------------------------------------------------------
|
1193
|
+
// Set socket ZMQ_RCVBUF value
|
1194
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1195
|
+
|
1196
|
+
void
|
1197
|
+
zsock_set_rcvbuf (void *self, int rcvbuf)
|
1198
|
+
{
|
1199
|
+
assert (self);
|
1200
|
+
# if defined (ZMQ_RCVBUF)
|
1201
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_RCVBUF, &rcvbuf, sizeof (int));
|
1202
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1203
|
+
# endif
|
1204
|
+
}
|
1205
|
+
|
1206
|
+
|
1207
|
+
// --------------------------------------------------------------------------
|
1208
|
+
// Return socket ZMQ_RCVBUF value
|
1209
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1210
|
+
|
1211
|
+
int
|
1212
|
+
zsock_rcvbuf (void *self)
|
1213
|
+
{
|
1214
|
+
assert (self);
|
1215
|
+
# if defined (ZMQ_RCVBUF)
|
1216
|
+
int rcvbuf;
|
1217
|
+
size_t option_len = sizeof (int);
|
1218
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RCVBUF, &rcvbuf, &option_len);
|
1219
|
+
return rcvbuf;
|
1220
|
+
# else
|
1221
|
+
return 0;
|
1222
|
+
# endif
|
1223
|
+
}
|
1224
|
+
|
1225
|
+
// --------------------------------------------------------------------------
|
1226
|
+
// Set socket ZMQ_LINGER value
|
1227
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1228
|
+
|
1229
|
+
void
|
1230
|
+
zsock_set_linger (void *self, int linger)
|
1231
|
+
{
|
1232
|
+
assert (self);
|
1233
|
+
# if defined (ZMQ_LINGER)
|
1234
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_LINGER, &linger, sizeof (int));
|
1235
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1236
|
+
# endif
|
1237
|
+
}
|
1238
|
+
|
1239
|
+
|
1240
|
+
// --------------------------------------------------------------------------
|
1241
|
+
// Return socket ZMQ_LINGER value
|
1242
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1243
|
+
|
1244
|
+
int
|
1245
|
+
zsock_linger (void *self)
|
1246
|
+
{
|
1247
|
+
assert (self);
|
1248
|
+
# if defined (ZMQ_LINGER)
|
1249
|
+
int linger;
|
1250
|
+
size_t option_len = sizeof (int);
|
1251
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_LINGER, &linger, &option_len);
|
1252
|
+
return linger;
|
1253
|
+
# else
|
1254
|
+
return 0;
|
1255
|
+
# endif
|
1256
|
+
}
|
1257
|
+
|
1258
|
+
// --------------------------------------------------------------------------
|
1259
|
+
// Set socket ZMQ_RECONNECT_IVL value
|
1260
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1261
|
+
|
1262
|
+
void
|
1263
|
+
zsock_set_reconnect_ivl (void *self, int reconnect_ivl)
|
1264
|
+
{
|
1265
|
+
assert (self);
|
1266
|
+
# if defined (ZMQ_RECONNECT_IVL)
|
1267
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_RECONNECT_IVL, &reconnect_ivl, sizeof (int));
|
1268
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1269
|
+
# endif
|
1270
|
+
}
|
1271
|
+
|
1272
|
+
|
1273
|
+
// --------------------------------------------------------------------------
|
1274
|
+
// Return socket ZMQ_RECONNECT_IVL value
|
1275
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1276
|
+
|
1277
|
+
int
|
1278
|
+
zsock_reconnect_ivl (void *self)
|
1279
|
+
{
|
1280
|
+
assert (self);
|
1281
|
+
# if defined (ZMQ_RECONNECT_IVL)
|
1282
|
+
int reconnect_ivl;
|
1283
|
+
size_t option_len = sizeof (int);
|
1284
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RECONNECT_IVL, &reconnect_ivl, &option_len);
|
1285
|
+
return reconnect_ivl;
|
1286
|
+
# else
|
1287
|
+
return 0;
|
1288
|
+
# endif
|
1289
|
+
}
|
1290
|
+
|
1291
|
+
// --------------------------------------------------------------------------
|
1292
|
+
// Set socket ZMQ_RECONNECT_IVL_MAX value
|
1293
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1294
|
+
|
1295
|
+
void
|
1296
|
+
zsock_set_reconnect_ivl_max (void *self, int reconnect_ivl_max)
|
1297
|
+
{
|
1298
|
+
assert (self);
|
1299
|
+
# if defined (ZMQ_RECONNECT_IVL_MAX)
|
1300
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_RECONNECT_IVL_MAX, &reconnect_ivl_max, sizeof (int));
|
1301
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1302
|
+
# endif
|
1303
|
+
}
|
1304
|
+
|
1305
|
+
|
1306
|
+
// --------------------------------------------------------------------------
|
1307
|
+
// Return socket ZMQ_RECONNECT_IVL_MAX value
|
1308
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1309
|
+
|
1310
|
+
int
|
1311
|
+
zsock_reconnect_ivl_max (void *self)
|
1312
|
+
{
|
1313
|
+
assert (self);
|
1314
|
+
# if defined (ZMQ_RECONNECT_IVL_MAX)
|
1315
|
+
int reconnect_ivl_max;
|
1316
|
+
size_t option_len = sizeof (int);
|
1317
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RECONNECT_IVL_MAX, &reconnect_ivl_max, &option_len);
|
1318
|
+
return reconnect_ivl_max;
|
1319
|
+
# else
|
1320
|
+
return 0;
|
1321
|
+
# endif
|
1322
|
+
}
|
1323
|
+
|
1324
|
+
// --------------------------------------------------------------------------
|
1325
|
+
// Set socket ZMQ_BACKLOG value
|
1326
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1327
|
+
|
1328
|
+
void
|
1329
|
+
zsock_set_backlog (void *self, int backlog)
|
1330
|
+
{
|
1331
|
+
assert (self);
|
1332
|
+
# if defined (ZMQ_BACKLOG)
|
1333
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_BACKLOG, &backlog, sizeof (int));
|
1334
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1335
|
+
# endif
|
1336
|
+
}
|
1337
|
+
|
1338
|
+
|
1339
|
+
// --------------------------------------------------------------------------
|
1340
|
+
// Return socket ZMQ_BACKLOG value
|
1341
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1342
|
+
|
1343
|
+
int
|
1344
|
+
zsock_backlog (void *self)
|
1345
|
+
{
|
1346
|
+
assert (self);
|
1347
|
+
# if defined (ZMQ_BACKLOG)
|
1348
|
+
int backlog;
|
1349
|
+
size_t option_len = sizeof (int);
|
1350
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_BACKLOG, &backlog, &option_len);
|
1351
|
+
return backlog;
|
1352
|
+
# else
|
1353
|
+
return 0;
|
1354
|
+
# endif
|
1355
|
+
}
|
1356
|
+
|
1357
|
+
// --------------------------------------------------------------------------
|
1358
|
+
// Set socket ZMQ_MAXMSGSIZE value
|
1359
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1360
|
+
|
1361
|
+
void
|
1362
|
+
zsock_set_maxmsgsize (void *self, int maxmsgsize)
|
1363
|
+
{
|
1364
|
+
assert (self);
|
1365
|
+
# if defined (ZMQ_MAXMSGSIZE)
|
1366
|
+
int64_t value = maxmsgsize;
|
1367
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_MAXMSGSIZE, &value, sizeof (int64_t));
|
1368
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1369
|
+
# endif
|
1370
|
+
}
|
1371
|
+
|
1372
|
+
|
1373
|
+
// --------------------------------------------------------------------------
|
1374
|
+
// Return socket ZMQ_MAXMSGSIZE value
|
1375
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1376
|
+
|
1377
|
+
int
|
1378
|
+
zsock_maxmsgsize (void *self)
|
1379
|
+
{
|
1380
|
+
assert (self);
|
1381
|
+
# if defined (ZMQ_MAXMSGSIZE)
|
1382
|
+
int64_t maxmsgsize;
|
1383
|
+
size_t option_len = sizeof (int64_t);
|
1384
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_MAXMSGSIZE, &maxmsgsize, &option_len);
|
1385
|
+
return (int) maxmsgsize;
|
1386
|
+
# else
|
1387
|
+
return 0;
|
1388
|
+
# endif
|
1389
|
+
}
|
1390
|
+
|
1391
|
+
// --------------------------------------------------------------------------
|
1392
|
+
// Set socket ZMQ_MULTICAST_HOPS value
|
1393
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1394
|
+
|
1395
|
+
void
|
1396
|
+
zsock_set_multicast_hops (void *self, int multicast_hops)
|
1397
|
+
{
|
1398
|
+
assert (self);
|
1399
|
+
# if defined (ZMQ_MULTICAST_HOPS)
|
1400
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_MULTICAST_HOPS, &multicast_hops, sizeof (int));
|
1401
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1402
|
+
# endif
|
1403
|
+
}
|
1404
|
+
|
1405
|
+
|
1406
|
+
// --------------------------------------------------------------------------
|
1407
|
+
// Return socket ZMQ_MULTICAST_HOPS value
|
1408
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1409
|
+
|
1410
|
+
int
|
1411
|
+
zsock_multicast_hops (void *self)
|
1412
|
+
{
|
1413
|
+
assert (self);
|
1414
|
+
# if defined (ZMQ_MULTICAST_HOPS)
|
1415
|
+
int multicast_hops;
|
1416
|
+
size_t option_len = sizeof (int);
|
1417
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_MULTICAST_HOPS, &multicast_hops, &option_len);
|
1418
|
+
return multicast_hops;
|
1419
|
+
# else
|
1420
|
+
return 0;
|
1421
|
+
# endif
|
1422
|
+
}
|
1423
|
+
|
1424
|
+
// --------------------------------------------------------------------------
|
1425
|
+
// Set socket ZMQ_RCVTIMEO value
|
1426
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1427
|
+
|
1428
|
+
void
|
1429
|
+
zsock_set_rcvtimeo (void *self, int rcvtimeo)
|
1430
|
+
{
|
1431
|
+
assert (self);
|
1432
|
+
# if defined (ZMQ_RCVTIMEO)
|
1433
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_RCVTIMEO, &rcvtimeo, sizeof (int));
|
1434
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1435
|
+
# endif
|
1436
|
+
}
|
1437
|
+
|
1438
|
+
|
1439
|
+
// --------------------------------------------------------------------------
|
1440
|
+
// Return socket ZMQ_RCVTIMEO value
|
1441
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1442
|
+
|
1443
|
+
int
|
1444
|
+
zsock_rcvtimeo (void *self)
|
1445
|
+
{
|
1446
|
+
assert (self);
|
1447
|
+
# if defined (ZMQ_RCVTIMEO)
|
1448
|
+
int rcvtimeo;
|
1449
|
+
size_t option_len = sizeof (int);
|
1450
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RCVTIMEO, &rcvtimeo, &option_len);
|
1451
|
+
return rcvtimeo;
|
1452
|
+
# else
|
1453
|
+
return 0;
|
1454
|
+
# endif
|
1455
|
+
}
|
1456
|
+
|
1457
|
+
// --------------------------------------------------------------------------
|
1458
|
+
// Set socket ZMQ_SNDTIMEO value
|
1459
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1460
|
+
|
1461
|
+
void
|
1462
|
+
zsock_set_sndtimeo (void *self, int sndtimeo)
|
1463
|
+
{
|
1464
|
+
assert (self);
|
1465
|
+
# if defined (ZMQ_SNDTIMEO)
|
1466
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_SNDTIMEO, &sndtimeo, sizeof (int));
|
1467
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1468
|
+
# endif
|
1469
|
+
}
|
1470
|
+
|
1471
|
+
|
1472
|
+
// --------------------------------------------------------------------------
|
1473
|
+
// Return socket ZMQ_SNDTIMEO value
|
1474
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1475
|
+
|
1476
|
+
int
|
1477
|
+
zsock_sndtimeo (void *self)
|
1478
|
+
{
|
1479
|
+
assert (self);
|
1480
|
+
# if defined (ZMQ_SNDTIMEO)
|
1481
|
+
int sndtimeo;
|
1482
|
+
size_t option_len = sizeof (int);
|
1483
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_SNDTIMEO, &sndtimeo, &option_len);
|
1484
|
+
return sndtimeo;
|
1485
|
+
# else
|
1486
|
+
return 0;
|
1487
|
+
# endif
|
1488
|
+
}
|
1489
|
+
|
1490
|
+
// --------------------------------------------------------------------------
|
1491
|
+
// Set socket ZMQ_XPUB_VERBOSE value
|
1492
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1493
|
+
|
1494
|
+
void
|
1495
|
+
zsock_set_xpub_verbose (void *self, int xpub_verbose)
|
1496
|
+
{
|
1497
|
+
assert (self);
|
1498
|
+
# if defined (ZMQ_XPUB_VERBOSE)
|
1499
|
+
if (zsock_type (self) != ZMQ_XPUB) {
|
1500
|
+
printf ("ZMQ_XPUB_VERBOSE is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
|
1501
|
+
assert (false);
|
1502
|
+
}
|
1503
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_XPUB_VERBOSE, &xpub_verbose, sizeof (int));
|
1504
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1505
|
+
# endif
|
1506
|
+
}
|
1507
|
+
|
1508
|
+
|
1509
|
+
// --------------------------------------------------------------------------
|
1510
|
+
// Set socket ZMQ_TCP_KEEPALIVE value
|
1511
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1512
|
+
|
1513
|
+
void
|
1514
|
+
zsock_set_tcp_keepalive (void *self, int tcp_keepalive)
|
1515
|
+
{
|
1516
|
+
assert (self);
|
1517
|
+
# if defined (ZMQ_TCP_KEEPALIVE)
|
1518
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_TCP_KEEPALIVE, &tcp_keepalive, sizeof (int));
|
1519
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1520
|
+
# endif
|
1521
|
+
}
|
1522
|
+
|
1523
|
+
|
1524
|
+
// --------------------------------------------------------------------------
|
1525
|
+
// Return socket ZMQ_TCP_KEEPALIVE value
|
1526
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1527
|
+
|
1528
|
+
int
|
1529
|
+
zsock_tcp_keepalive (void *self)
|
1530
|
+
{
|
1531
|
+
assert (self);
|
1532
|
+
# if defined (ZMQ_TCP_KEEPALIVE)
|
1533
|
+
int tcp_keepalive;
|
1534
|
+
size_t option_len = sizeof (int);
|
1535
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_TCP_KEEPALIVE, &tcp_keepalive, &option_len);
|
1536
|
+
return tcp_keepalive;
|
1537
|
+
# else
|
1538
|
+
return 0;
|
1539
|
+
# endif
|
1540
|
+
}
|
1541
|
+
|
1542
|
+
// --------------------------------------------------------------------------
|
1543
|
+
// Set socket ZMQ_TCP_KEEPALIVE_IDLE value
|
1544
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1545
|
+
|
1546
|
+
void
|
1547
|
+
zsock_set_tcp_keepalive_idle (void *self, int tcp_keepalive_idle)
|
1548
|
+
{
|
1549
|
+
assert (self);
|
1550
|
+
# if defined (ZMQ_TCP_KEEPALIVE_IDLE)
|
1551
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_TCP_KEEPALIVE_IDLE, &tcp_keepalive_idle, sizeof (int));
|
1552
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1553
|
+
# endif
|
1554
|
+
}
|
1555
|
+
|
1556
|
+
|
1557
|
+
// --------------------------------------------------------------------------
|
1558
|
+
// Return socket ZMQ_TCP_KEEPALIVE_IDLE value
|
1559
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1560
|
+
|
1561
|
+
int
|
1562
|
+
zsock_tcp_keepalive_idle (void *self)
|
1563
|
+
{
|
1564
|
+
assert (self);
|
1565
|
+
# if defined (ZMQ_TCP_KEEPALIVE_IDLE)
|
1566
|
+
int tcp_keepalive_idle;
|
1567
|
+
size_t option_len = sizeof (int);
|
1568
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_TCP_KEEPALIVE_IDLE, &tcp_keepalive_idle, &option_len);
|
1569
|
+
return tcp_keepalive_idle;
|
1570
|
+
# else
|
1571
|
+
return 0;
|
1572
|
+
# endif
|
1573
|
+
}
|
1574
|
+
|
1575
|
+
// --------------------------------------------------------------------------
|
1576
|
+
// Set socket ZMQ_TCP_KEEPALIVE_CNT value
|
1577
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1578
|
+
|
1579
|
+
void
|
1580
|
+
zsock_set_tcp_keepalive_cnt (void *self, int tcp_keepalive_cnt)
|
1581
|
+
{
|
1582
|
+
assert (self);
|
1583
|
+
# if defined (ZMQ_TCP_KEEPALIVE_CNT)
|
1584
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_TCP_KEEPALIVE_CNT, &tcp_keepalive_cnt, sizeof (int));
|
1585
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1586
|
+
# endif
|
1587
|
+
}
|
1588
|
+
|
1589
|
+
|
1590
|
+
// --------------------------------------------------------------------------
|
1591
|
+
// Return socket ZMQ_TCP_KEEPALIVE_CNT value
|
1592
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1593
|
+
|
1594
|
+
int
|
1595
|
+
zsock_tcp_keepalive_cnt (void *self)
|
1596
|
+
{
|
1597
|
+
assert (self);
|
1598
|
+
# if defined (ZMQ_TCP_KEEPALIVE_CNT)
|
1599
|
+
int tcp_keepalive_cnt;
|
1600
|
+
size_t option_len = sizeof (int);
|
1601
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_TCP_KEEPALIVE_CNT, &tcp_keepalive_cnt, &option_len);
|
1602
|
+
return tcp_keepalive_cnt;
|
1603
|
+
# else
|
1604
|
+
return 0;
|
1605
|
+
# endif
|
1606
|
+
}
|
1607
|
+
|
1608
|
+
// --------------------------------------------------------------------------
|
1609
|
+
// Set socket ZMQ_TCP_KEEPALIVE_INTVL value
|
1610
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1611
|
+
|
1612
|
+
void
|
1613
|
+
zsock_set_tcp_keepalive_intvl (void *self, int tcp_keepalive_intvl)
|
1614
|
+
{
|
1615
|
+
assert (self);
|
1616
|
+
# if defined (ZMQ_TCP_KEEPALIVE_INTVL)
|
1617
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_TCP_KEEPALIVE_INTVL, &tcp_keepalive_intvl, sizeof (int));
|
1618
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1619
|
+
# endif
|
1620
|
+
}
|
1621
|
+
|
1622
|
+
|
1623
|
+
// --------------------------------------------------------------------------
|
1624
|
+
// Return socket ZMQ_TCP_KEEPALIVE_INTVL value
|
1625
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1626
|
+
|
1627
|
+
int
|
1628
|
+
zsock_tcp_keepalive_intvl (void *self)
|
1629
|
+
{
|
1630
|
+
assert (self);
|
1631
|
+
# if defined (ZMQ_TCP_KEEPALIVE_INTVL)
|
1632
|
+
int tcp_keepalive_intvl;
|
1633
|
+
size_t option_len = sizeof (int);
|
1634
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_TCP_KEEPALIVE_INTVL, &tcp_keepalive_intvl, &option_len);
|
1635
|
+
return tcp_keepalive_intvl;
|
1636
|
+
# else
|
1637
|
+
return 0;
|
1638
|
+
# endif
|
1639
|
+
}
|
1640
|
+
|
1641
|
+
// --------------------------------------------------------------------------
|
1642
|
+
// Set socket ZMQ_TCP_ACCEPT_FILTER value
|
1643
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1644
|
+
|
1645
|
+
void
|
1646
|
+
zsock_set_tcp_accept_filter (void *self, const char * tcp_accept_filter)
|
1647
|
+
{
|
1648
|
+
assert (self);
|
1649
|
+
# if defined (ZMQ_TCP_ACCEPT_FILTER)
|
1650
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_TCP_ACCEPT_FILTER, tcp_accept_filter, strlen (tcp_accept_filter));
|
1651
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1652
|
+
# endif
|
1653
|
+
}
|
1654
|
+
|
1655
|
+
|
1656
|
+
// --------------------------------------------------------------------------
|
1657
|
+
// Return socket ZMQ_TCP_ACCEPT_FILTER value
|
1658
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1659
|
+
|
1660
|
+
char *
|
1661
|
+
zsock_tcp_accept_filter (void *self)
|
1662
|
+
{
|
1663
|
+
assert (self);
|
1664
|
+
# if defined (ZMQ_TCP_ACCEPT_FILTER)
|
1665
|
+
size_t option_len = 255;
|
1666
|
+
char *tcp_accept_filter = (char *) zmalloc (option_len);
|
1667
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_TCP_ACCEPT_FILTER, tcp_accept_filter, &option_len);
|
1668
|
+
return (char *) tcp_accept_filter;
|
1669
|
+
# else
|
1670
|
+
return NULL;
|
1671
|
+
# endif
|
1672
|
+
}
|
1673
|
+
|
1674
|
+
// --------------------------------------------------------------------------
|
1675
|
+
// Return socket ZMQ_RCVMORE value
|
1676
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1677
|
+
|
1678
|
+
int
|
1679
|
+
zsock_rcvmore (void *self)
|
1680
|
+
{
|
1681
|
+
assert (self);
|
1682
|
+
# if defined (ZMQ_RCVMORE)
|
1683
|
+
int rcvmore;
|
1684
|
+
size_t option_len = sizeof (int);
|
1685
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RCVMORE, &rcvmore, &option_len);
|
1686
|
+
return rcvmore;
|
1687
|
+
# else
|
1688
|
+
return 0;
|
1689
|
+
# endif
|
1690
|
+
}
|
1691
|
+
|
1692
|
+
// --------------------------------------------------------------------------
|
1693
|
+
// Return socket ZMQ_FD value
|
1694
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1695
|
+
|
1696
|
+
SOCKET
|
1697
|
+
zsock_fd (void *self)
|
1698
|
+
{
|
1699
|
+
assert (self);
|
1700
|
+
# if defined (ZMQ_FD)
|
1701
|
+
SOCKET fd;
|
1702
|
+
size_t option_len = sizeof (SOCKET);
|
1703
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_FD, &fd, &option_len);
|
1704
|
+
return fd;
|
1705
|
+
# else
|
1706
|
+
return 0;
|
1707
|
+
# endif
|
1708
|
+
}
|
1709
|
+
|
1710
|
+
// --------------------------------------------------------------------------
|
1711
|
+
// Return socket ZMQ_EVENTS value
|
1712
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1713
|
+
|
1714
|
+
int
|
1715
|
+
zsock_events (void *self)
|
1716
|
+
{
|
1717
|
+
assert (self);
|
1718
|
+
# if defined (ZMQ_EVENTS)
|
1719
|
+
int events;
|
1720
|
+
size_t option_len = sizeof (int);
|
1721
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_EVENTS, &events, &option_len);
|
1722
|
+
return events;
|
1723
|
+
# else
|
1724
|
+
return 0;
|
1725
|
+
# endif
|
1726
|
+
}
|
1727
|
+
|
1728
|
+
// --------------------------------------------------------------------------
|
1729
|
+
// Return socket ZMQ_LAST_ENDPOINT value
|
1730
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1731
|
+
|
1732
|
+
char *
|
1733
|
+
zsock_last_endpoint (void *self)
|
1734
|
+
{
|
1735
|
+
assert (self);
|
1736
|
+
# if defined (ZMQ_LAST_ENDPOINT)
|
1737
|
+
size_t option_len = 255;
|
1738
|
+
char *last_endpoint = (char *) zmalloc (option_len);
|
1739
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_LAST_ENDPOINT, last_endpoint, &option_len);
|
1740
|
+
return (char *) last_endpoint;
|
1741
|
+
# else
|
1742
|
+
return NULL;
|
1743
|
+
# endif
|
1744
|
+
}
|
1745
|
+
|
1746
|
+
#endif
|
1747
|
+
|
1748
|
+
#if (ZMQ_VERSION_MAJOR == 3)
|
1749
|
+
// --------------------------------------------------------------------------
|
1750
|
+
// Set socket ZMQ_ROUTER_RAW value
|
1751
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1752
|
+
|
1753
|
+
void
|
1754
|
+
zsock_set_router_raw (void *self, int router_raw)
|
1755
|
+
{
|
1756
|
+
assert (self);
|
1757
|
+
# if defined (ZMQ_ROUTER_RAW)
|
1758
|
+
if (zsock_type (self) != ZMQ_ROUTER) {
|
1759
|
+
printf ("ZMQ_ROUTER_RAW is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
|
1760
|
+
assert (false);
|
1761
|
+
}
|
1762
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_ROUTER_RAW, &router_raw, sizeof (int));
|
1763
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1764
|
+
# endif
|
1765
|
+
}
|
1766
|
+
|
1767
|
+
|
1768
|
+
// --------------------------------------------------------------------------
|
1769
|
+
// Set socket ZMQ_IPV4ONLY value
|
1770
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1771
|
+
|
1772
|
+
void
|
1773
|
+
zsock_set_ipv4only (void *self, int ipv4only)
|
1774
|
+
{
|
1775
|
+
assert (self);
|
1776
|
+
# if defined (ZMQ_IPV4ONLY)
|
1777
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_IPV4ONLY, &ipv4only, sizeof (int));
|
1778
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1779
|
+
# endif
|
1780
|
+
}
|
1781
|
+
|
1782
|
+
|
1783
|
+
// --------------------------------------------------------------------------
|
1784
|
+
// Return socket ZMQ_IPV4ONLY value
|
1785
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1786
|
+
|
1787
|
+
int
|
1788
|
+
zsock_ipv4only (void *self)
|
1789
|
+
{
|
1790
|
+
assert (self);
|
1791
|
+
# if defined (ZMQ_IPV4ONLY)
|
1792
|
+
int ipv4only;
|
1793
|
+
size_t option_len = sizeof (int);
|
1794
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_IPV4ONLY, &ipv4only, &option_len);
|
1795
|
+
return ipv4only;
|
1796
|
+
# else
|
1797
|
+
return 0;
|
1798
|
+
# endif
|
1799
|
+
}
|
1800
|
+
|
1801
|
+
// --------------------------------------------------------------------------
|
1802
|
+
// Set socket ZMQ_DELAY_ATTACH_ON_CONNECT value
|
1803
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1804
|
+
|
1805
|
+
void
|
1806
|
+
zsock_set_delay_attach_on_connect (void *self, int delay_attach_on_connect)
|
1807
|
+
{
|
1808
|
+
assert (self);
|
1809
|
+
# if defined (ZMQ_DELAY_ATTACH_ON_CONNECT)
|
1810
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_DELAY_ATTACH_ON_CONNECT, &delay_attach_on_connect, sizeof (int));
|
1811
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1812
|
+
# endif
|
1813
|
+
}
|
1814
|
+
|
1815
|
+
|
1816
|
+
// --------------------------------------------------------------------------
|
1817
|
+
// Return socket ZMQ_TYPE value
|
1818
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1819
|
+
|
1820
|
+
int
|
1821
|
+
zsock_type (void *self)
|
1822
|
+
{
|
1823
|
+
assert (self);
|
1824
|
+
# if defined (ZMQ_TYPE)
|
1825
|
+
int type;
|
1826
|
+
size_t option_len = sizeof (int);
|
1827
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_TYPE, &type, &option_len);
|
1828
|
+
return type;
|
1829
|
+
# else
|
1830
|
+
return 0;
|
1831
|
+
# endif
|
1832
|
+
}
|
1833
|
+
|
1834
|
+
// --------------------------------------------------------------------------
|
1835
|
+
// Set socket ZMQ_SNDHWM value
|
1836
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1837
|
+
|
1838
|
+
void
|
1839
|
+
zsock_set_sndhwm (void *self, int sndhwm)
|
1840
|
+
{
|
1841
|
+
assert (self);
|
1842
|
+
# if defined (ZMQ_SNDHWM)
|
1843
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_SNDHWM, &sndhwm, sizeof (int));
|
1844
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1845
|
+
# endif
|
1846
|
+
}
|
1847
|
+
|
1848
|
+
|
1849
|
+
// --------------------------------------------------------------------------
|
1850
|
+
// Return socket ZMQ_SNDHWM value
|
1851
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1852
|
+
|
1853
|
+
int
|
1854
|
+
zsock_sndhwm (void *self)
|
1855
|
+
{
|
1856
|
+
assert (self);
|
1857
|
+
# if defined (ZMQ_SNDHWM)
|
1858
|
+
int sndhwm;
|
1859
|
+
size_t option_len = sizeof (int);
|
1860
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_SNDHWM, &sndhwm, &option_len);
|
1861
|
+
return sndhwm;
|
1862
|
+
# else
|
1863
|
+
return 0;
|
1864
|
+
# endif
|
1865
|
+
}
|
1866
|
+
|
1867
|
+
// --------------------------------------------------------------------------
|
1868
|
+
// Set socket ZMQ_RCVHWM value
|
1869
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1870
|
+
|
1871
|
+
void
|
1872
|
+
zsock_set_rcvhwm (void *self, int rcvhwm)
|
1873
|
+
{
|
1874
|
+
assert (self);
|
1875
|
+
# if defined (ZMQ_RCVHWM)
|
1876
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_RCVHWM, &rcvhwm, sizeof (int));
|
1877
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1878
|
+
# endif
|
1879
|
+
}
|
1880
|
+
|
1881
|
+
|
1882
|
+
// --------------------------------------------------------------------------
|
1883
|
+
// Return socket ZMQ_RCVHWM value
|
1884
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1885
|
+
|
1886
|
+
int
|
1887
|
+
zsock_rcvhwm (void *self)
|
1888
|
+
{
|
1889
|
+
assert (self);
|
1890
|
+
# if defined (ZMQ_RCVHWM)
|
1891
|
+
int rcvhwm;
|
1892
|
+
size_t option_len = sizeof (int);
|
1893
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RCVHWM, &rcvhwm, &option_len);
|
1894
|
+
return rcvhwm;
|
1895
|
+
# else
|
1896
|
+
return 0;
|
1897
|
+
# endif
|
1898
|
+
}
|
1899
|
+
|
1900
|
+
// --------------------------------------------------------------------------
|
1901
|
+
// Set socket ZMQ_AFFINITY value
|
1902
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1903
|
+
|
1904
|
+
void
|
1905
|
+
zsock_set_affinity (void *self, int affinity)
|
1906
|
+
{
|
1907
|
+
assert (self);
|
1908
|
+
# if defined (ZMQ_AFFINITY)
|
1909
|
+
uint64_t value = affinity;
|
1910
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_AFFINITY, &value, sizeof (uint64_t));
|
1911
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1912
|
+
# endif
|
1913
|
+
}
|
1914
|
+
|
1915
|
+
|
1916
|
+
// --------------------------------------------------------------------------
|
1917
|
+
// Return socket ZMQ_AFFINITY value
|
1918
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1919
|
+
|
1920
|
+
int
|
1921
|
+
zsock_affinity (void *self)
|
1922
|
+
{
|
1923
|
+
assert (self);
|
1924
|
+
# if defined (ZMQ_AFFINITY)
|
1925
|
+
uint64_t affinity;
|
1926
|
+
size_t option_len = sizeof (uint64_t);
|
1927
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_AFFINITY, &affinity, &option_len);
|
1928
|
+
return (int) affinity;
|
1929
|
+
# else
|
1930
|
+
return 0;
|
1931
|
+
# endif
|
1932
|
+
}
|
1933
|
+
|
1934
|
+
// --------------------------------------------------------------------------
|
1935
|
+
// Set socket ZMQ_SUBSCRIBE value
|
1936
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1937
|
+
|
1938
|
+
void
|
1939
|
+
zsock_set_subscribe (void *self, const char * subscribe)
|
1940
|
+
{
|
1941
|
+
assert (self);
|
1942
|
+
# if defined (ZMQ_SUBSCRIBE)
|
1943
|
+
if (zsock_type (self) != ZMQ_SUB) {
|
1944
|
+
printf ("ZMQ_SUBSCRIBE is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
|
1945
|
+
assert (false);
|
1946
|
+
}
|
1947
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_SUBSCRIBE, subscribe, strlen (subscribe));
|
1948
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1949
|
+
# endif
|
1950
|
+
}
|
1951
|
+
|
1952
|
+
|
1953
|
+
// --------------------------------------------------------------------------
|
1954
|
+
// Set socket ZMQ_UNSUBSCRIBE value
|
1955
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1956
|
+
|
1957
|
+
void
|
1958
|
+
zsock_set_unsubscribe (void *self, const char * unsubscribe)
|
1959
|
+
{
|
1960
|
+
assert (self);
|
1961
|
+
# if defined (ZMQ_UNSUBSCRIBE)
|
1962
|
+
if (zsock_type (self) != ZMQ_SUB) {
|
1963
|
+
printf ("ZMQ_UNSUBSCRIBE is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
|
1964
|
+
assert (false);
|
1965
|
+
}
|
1966
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_UNSUBSCRIBE, unsubscribe, strlen (unsubscribe));
|
1967
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1968
|
+
# endif
|
1969
|
+
}
|
1970
|
+
|
1971
|
+
|
1972
|
+
// --------------------------------------------------------------------------
|
1973
|
+
// Set socket ZMQ_IDENTITY value
|
1974
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1975
|
+
|
1976
|
+
void
|
1977
|
+
zsock_set_identity (void *self, const char * identity)
|
1978
|
+
{
|
1979
|
+
assert (self);
|
1980
|
+
# if defined (ZMQ_IDENTITY)
|
1981
|
+
if (zsock_type (self) != ZMQ_REQ
|
1982
|
+
&& zsock_type (self) != ZMQ_REP
|
1983
|
+
&& zsock_type (self) != ZMQ_DEALER
|
1984
|
+
&& zsock_type (self) != ZMQ_ROUTER) {
|
1985
|
+
printf ("ZMQ_IDENTITY is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
|
1986
|
+
assert (false);
|
1987
|
+
}
|
1988
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_IDENTITY, identity, strlen (identity));
|
1989
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
1990
|
+
# endif
|
1991
|
+
}
|
1992
|
+
|
1993
|
+
|
1994
|
+
// --------------------------------------------------------------------------
|
1995
|
+
// Return socket ZMQ_IDENTITY value
|
1996
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
1997
|
+
|
1998
|
+
char *
|
1999
|
+
zsock_identity (void *self)
|
2000
|
+
{
|
2001
|
+
assert (self);
|
2002
|
+
# if defined (ZMQ_IDENTITY)
|
2003
|
+
size_t option_len = 255;
|
2004
|
+
char *identity = (char *) zmalloc (option_len);
|
2005
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_IDENTITY, identity, &option_len);
|
2006
|
+
return (char *) identity;
|
2007
|
+
# else
|
2008
|
+
return NULL;
|
2009
|
+
# endif
|
2010
|
+
}
|
2011
|
+
|
2012
|
+
// --------------------------------------------------------------------------
|
2013
|
+
// Set socket ZMQ_RATE value
|
2014
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2015
|
+
|
2016
|
+
void
|
2017
|
+
zsock_set_rate (void *self, int rate)
|
2018
|
+
{
|
2019
|
+
assert (self);
|
2020
|
+
# if defined (ZMQ_RATE)
|
2021
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_RATE, &rate, sizeof (int));
|
2022
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2023
|
+
# endif
|
2024
|
+
}
|
2025
|
+
|
2026
|
+
|
2027
|
+
// --------------------------------------------------------------------------
|
2028
|
+
// Return socket ZMQ_RATE value
|
2029
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2030
|
+
|
2031
|
+
int
|
2032
|
+
zsock_rate (void *self)
|
2033
|
+
{
|
2034
|
+
assert (self);
|
2035
|
+
# if defined (ZMQ_RATE)
|
2036
|
+
int rate;
|
2037
|
+
size_t option_len = sizeof (int);
|
2038
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RATE, &rate, &option_len);
|
2039
|
+
return rate;
|
2040
|
+
# else
|
2041
|
+
return 0;
|
2042
|
+
# endif
|
2043
|
+
}
|
2044
|
+
|
2045
|
+
// --------------------------------------------------------------------------
|
2046
|
+
// Set socket ZMQ_RECOVERY_IVL value
|
2047
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2048
|
+
|
2049
|
+
void
|
2050
|
+
zsock_set_recovery_ivl (void *self, int recovery_ivl)
|
2051
|
+
{
|
2052
|
+
assert (self);
|
2053
|
+
# if defined (ZMQ_RECOVERY_IVL)
|
2054
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_RECOVERY_IVL, &recovery_ivl, sizeof (int));
|
2055
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2056
|
+
# endif
|
2057
|
+
}
|
2058
|
+
|
2059
|
+
|
2060
|
+
// --------------------------------------------------------------------------
|
2061
|
+
// Return socket ZMQ_RECOVERY_IVL value
|
2062
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2063
|
+
|
2064
|
+
int
|
2065
|
+
zsock_recovery_ivl (void *self)
|
2066
|
+
{
|
2067
|
+
assert (self);
|
2068
|
+
# if defined (ZMQ_RECOVERY_IVL)
|
2069
|
+
int recovery_ivl;
|
2070
|
+
size_t option_len = sizeof (int);
|
2071
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RECOVERY_IVL, &recovery_ivl, &option_len);
|
2072
|
+
return recovery_ivl;
|
2073
|
+
# else
|
2074
|
+
return 0;
|
2075
|
+
# endif
|
2076
|
+
}
|
2077
|
+
|
2078
|
+
// --------------------------------------------------------------------------
|
2079
|
+
// Set socket ZMQ_SNDBUF value
|
2080
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2081
|
+
|
2082
|
+
void
|
2083
|
+
zsock_set_sndbuf (void *self, int sndbuf)
|
2084
|
+
{
|
2085
|
+
assert (self);
|
2086
|
+
# if defined (ZMQ_SNDBUF)
|
2087
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_SNDBUF, &sndbuf, sizeof (int));
|
2088
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2089
|
+
# endif
|
2090
|
+
}
|
2091
|
+
|
2092
|
+
|
2093
|
+
// --------------------------------------------------------------------------
|
2094
|
+
// Return socket ZMQ_SNDBUF value
|
2095
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2096
|
+
|
2097
|
+
int
|
2098
|
+
zsock_sndbuf (void *self)
|
2099
|
+
{
|
2100
|
+
assert (self);
|
2101
|
+
# if defined (ZMQ_SNDBUF)
|
2102
|
+
int sndbuf;
|
2103
|
+
size_t option_len = sizeof (int);
|
2104
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_SNDBUF, &sndbuf, &option_len);
|
2105
|
+
return sndbuf;
|
2106
|
+
# else
|
2107
|
+
return 0;
|
2108
|
+
# endif
|
2109
|
+
}
|
2110
|
+
|
2111
|
+
// --------------------------------------------------------------------------
|
2112
|
+
// Set socket ZMQ_RCVBUF value
|
2113
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2114
|
+
|
2115
|
+
void
|
2116
|
+
zsock_set_rcvbuf (void *self, int rcvbuf)
|
2117
|
+
{
|
2118
|
+
assert (self);
|
2119
|
+
# if defined (ZMQ_RCVBUF)
|
2120
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_RCVBUF, &rcvbuf, sizeof (int));
|
2121
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2122
|
+
# endif
|
2123
|
+
}
|
2124
|
+
|
2125
|
+
|
2126
|
+
// --------------------------------------------------------------------------
|
2127
|
+
// Return socket ZMQ_RCVBUF value
|
2128
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2129
|
+
|
2130
|
+
int
|
2131
|
+
zsock_rcvbuf (void *self)
|
2132
|
+
{
|
2133
|
+
assert (self);
|
2134
|
+
# if defined (ZMQ_RCVBUF)
|
2135
|
+
int rcvbuf;
|
2136
|
+
size_t option_len = sizeof (int);
|
2137
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RCVBUF, &rcvbuf, &option_len);
|
2138
|
+
return rcvbuf;
|
2139
|
+
# else
|
2140
|
+
return 0;
|
2141
|
+
# endif
|
2142
|
+
}
|
2143
|
+
|
2144
|
+
// --------------------------------------------------------------------------
|
2145
|
+
// Set socket ZMQ_LINGER value
|
2146
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2147
|
+
|
2148
|
+
void
|
2149
|
+
zsock_set_linger (void *self, int linger)
|
2150
|
+
{
|
2151
|
+
assert (self);
|
2152
|
+
# if defined (ZMQ_LINGER)
|
2153
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_LINGER, &linger, sizeof (int));
|
2154
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2155
|
+
# endif
|
2156
|
+
}
|
2157
|
+
|
2158
|
+
|
2159
|
+
// --------------------------------------------------------------------------
|
2160
|
+
// Return socket ZMQ_LINGER value
|
2161
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2162
|
+
|
2163
|
+
int
|
2164
|
+
zsock_linger (void *self)
|
2165
|
+
{
|
2166
|
+
assert (self);
|
2167
|
+
# if defined (ZMQ_LINGER)
|
2168
|
+
int linger;
|
2169
|
+
size_t option_len = sizeof (int);
|
2170
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_LINGER, &linger, &option_len);
|
2171
|
+
return linger;
|
2172
|
+
# else
|
2173
|
+
return 0;
|
2174
|
+
# endif
|
2175
|
+
}
|
2176
|
+
|
2177
|
+
// --------------------------------------------------------------------------
|
2178
|
+
// Set socket ZMQ_RECONNECT_IVL value
|
2179
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2180
|
+
|
2181
|
+
void
|
2182
|
+
zsock_set_reconnect_ivl (void *self, int reconnect_ivl)
|
2183
|
+
{
|
2184
|
+
assert (self);
|
2185
|
+
# if defined (ZMQ_RECONNECT_IVL)
|
2186
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_RECONNECT_IVL, &reconnect_ivl, sizeof (int));
|
2187
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2188
|
+
# endif
|
2189
|
+
}
|
2190
|
+
|
2191
|
+
|
2192
|
+
// --------------------------------------------------------------------------
|
2193
|
+
// Return socket ZMQ_RECONNECT_IVL value
|
2194
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2195
|
+
|
2196
|
+
int
|
2197
|
+
zsock_reconnect_ivl (void *self)
|
2198
|
+
{
|
2199
|
+
assert (self);
|
2200
|
+
# if defined (ZMQ_RECONNECT_IVL)
|
2201
|
+
int reconnect_ivl;
|
2202
|
+
size_t option_len = sizeof (int);
|
2203
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RECONNECT_IVL, &reconnect_ivl, &option_len);
|
2204
|
+
return reconnect_ivl;
|
2205
|
+
# else
|
2206
|
+
return 0;
|
2207
|
+
# endif
|
2208
|
+
}
|
2209
|
+
|
2210
|
+
// --------------------------------------------------------------------------
|
2211
|
+
// Set socket ZMQ_RECONNECT_IVL_MAX value
|
2212
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2213
|
+
|
2214
|
+
void
|
2215
|
+
zsock_set_reconnect_ivl_max (void *self, int reconnect_ivl_max)
|
2216
|
+
{
|
2217
|
+
assert (self);
|
2218
|
+
# if defined (ZMQ_RECONNECT_IVL_MAX)
|
2219
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_RECONNECT_IVL_MAX, &reconnect_ivl_max, sizeof (int));
|
2220
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2221
|
+
# endif
|
2222
|
+
}
|
2223
|
+
|
2224
|
+
|
2225
|
+
// --------------------------------------------------------------------------
|
2226
|
+
// Return socket ZMQ_RECONNECT_IVL_MAX value
|
2227
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2228
|
+
|
2229
|
+
int
|
2230
|
+
zsock_reconnect_ivl_max (void *self)
|
2231
|
+
{
|
2232
|
+
assert (self);
|
2233
|
+
# if defined (ZMQ_RECONNECT_IVL_MAX)
|
2234
|
+
int reconnect_ivl_max;
|
2235
|
+
size_t option_len = sizeof (int);
|
2236
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RECONNECT_IVL_MAX, &reconnect_ivl_max, &option_len);
|
2237
|
+
return reconnect_ivl_max;
|
2238
|
+
# else
|
2239
|
+
return 0;
|
2240
|
+
# endif
|
2241
|
+
}
|
2242
|
+
|
2243
|
+
// --------------------------------------------------------------------------
|
2244
|
+
// Set socket ZMQ_BACKLOG value
|
2245
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2246
|
+
|
2247
|
+
void
|
2248
|
+
zsock_set_backlog (void *self, int backlog)
|
2249
|
+
{
|
2250
|
+
assert (self);
|
2251
|
+
# if defined (ZMQ_BACKLOG)
|
2252
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_BACKLOG, &backlog, sizeof (int));
|
2253
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2254
|
+
# endif
|
2255
|
+
}
|
2256
|
+
|
2257
|
+
|
2258
|
+
// --------------------------------------------------------------------------
|
2259
|
+
// Return socket ZMQ_BACKLOG value
|
2260
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2261
|
+
|
2262
|
+
int
|
2263
|
+
zsock_backlog (void *self)
|
2264
|
+
{
|
2265
|
+
assert (self);
|
2266
|
+
# if defined (ZMQ_BACKLOG)
|
2267
|
+
int backlog;
|
2268
|
+
size_t option_len = sizeof (int);
|
2269
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_BACKLOG, &backlog, &option_len);
|
2270
|
+
return backlog;
|
2271
|
+
# else
|
2272
|
+
return 0;
|
2273
|
+
# endif
|
2274
|
+
}
|
2275
|
+
|
2276
|
+
// --------------------------------------------------------------------------
|
2277
|
+
// Set socket ZMQ_MAXMSGSIZE value
|
2278
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2279
|
+
|
2280
|
+
void
|
2281
|
+
zsock_set_maxmsgsize (void *self, int maxmsgsize)
|
2282
|
+
{
|
2283
|
+
assert (self);
|
2284
|
+
# if defined (ZMQ_MAXMSGSIZE)
|
2285
|
+
int64_t value = maxmsgsize;
|
2286
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_MAXMSGSIZE, &value, sizeof (int64_t));
|
2287
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2288
|
+
# endif
|
2289
|
+
}
|
2290
|
+
|
2291
|
+
|
2292
|
+
// --------------------------------------------------------------------------
|
2293
|
+
// Return socket ZMQ_MAXMSGSIZE value
|
2294
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2295
|
+
|
2296
|
+
int
|
2297
|
+
zsock_maxmsgsize (void *self)
|
2298
|
+
{
|
2299
|
+
assert (self);
|
2300
|
+
# if defined (ZMQ_MAXMSGSIZE)
|
2301
|
+
int64_t maxmsgsize;
|
2302
|
+
size_t option_len = sizeof (int64_t);
|
2303
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_MAXMSGSIZE, &maxmsgsize, &option_len);
|
2304
|
+
return (int) maxmsgsize;
|
2305
|
+
# else
|
2306
|
+
return 0;
|
2307
|
+
# endif
|
2308
|
+
}
|
2309
|
+
|
2310
|
+
// --------------------------------------------------------------------------
|
2311
|
+
// Set socket ZMQ_MULTICAST_HOPS value
|
2312
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2313
|
+
|
2314
|
+
void
|
2315
|
+
zsock_set_multicast_hops (void *self, int multicast_hops)
|
2316
|
+
{
|
2317
|
+
assert (self);
|
2318
|
+
# if defined (ZMQ_MULTICAST_HOPS)
|
2319
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_MULTICAST_HOPS, &multicast_hops, sizeof (int));
|
2320
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2321
|
+
# endif
|
2322
|
+
}
|
2323
|
+
|
2324
|
+
|
2325
|
+
// --------------------------------------------------------------------------
|
2326
|
+
// Return socket ZMQ_MULTICAST_HOPS value
|
2327
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2328
|
+
|
2329
|
+
int
|
2330
|
+
zsock_multicast_hops (void *self)
|
2331
|
+
{
|
2332
|
+
assert (self);
|
2333
|
+
# if defined (ZMQ_MULTICAST_HOPS)
|
2334
|
+
int multicast_hops;
|
2335
|
+
size_t option_len = sizeof (int);
|
2336
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_MULTICAST_HOPS, &multicast_hops, &option_len);
|
2337
|
+
return multicast_hops;
|
2338
|
+
# else
|
2339
|
+
return 0;
|
2340
|
+
# endif
|
2341
|
+
}
|
2342
|
+
|
2343
|
+
// --------------------------------------------------------------------------
|
2344
|
+
// Set socket ZMQ_RCVTIMEO value
|
2345
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2346
|
+
|
2347
|
+
void
|
2348
|
+
zsock_set_rcvtimeo (void *self, int rcvtimeo)
|
2349
|
+
{
|
2350
|
+
assert (self);
|
2351
|
+
# if defined (ZMQ_RCVTIMEO)
|
2352
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_RCVTIMEO, &rcvtimeo, sizeof (int));
|
2353
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2354
|
+
# endif
|
2355
|
+
}
|
2356
|
+
|
2357
|
+
|
2358
|
+
// --------------------------------------------------------------------------
|
2359
|
+
// Return socket ZMQ_RCVTIMEO value
|
2360
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2361
|
+
|
2362
|
+
int
|
2363
|
+
zsock_rcvtimeo (void *self)
|
2364
|
+
{
|
2365
|
+
assert (self);
|
2366
|
+
# if defined (ZMQ_RCVTIMEO)
|
2367
|
+
int rcvtimeo;
|
2368
|
+
size_t option_len = sizeof (int);
|
2369
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RCVTIMEO, &rcvtimeo, &option_len);
|
2370
|
+
return rcvtimeo;
|
2371
|
+
# else
|
2372
|
+
return 0;
|
2373
|
+
# endif
|
2374
|
+
}
|
2375
|
+
|
2376
|
+
// --------------------------------------------------------------------------
|
2377
|
+
// Set socket ZMQ_SNDTIMEO value
|
2378
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2379
|
+
|
2380
|
+
void
|
2381
|
+
zsock_set_sndtimeo (void *self, int sndtimeo)
|
2382
|
+
{
|
2383
|
+
assert (self);
|
2384
|
+
# if defined (ZMQ_SNDTIMEO)
|
2385
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_SNDTIMEO, &sndtimeo, sizeof (int));
|
2386
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2387
|
+
# endif
|
2388
|
+
}
|
2389
|
+
|
2390
|
+
|
2391
|
+
// --------------------------------------------------------------------------
|
2392
|
+
// Return socket ZMQ_SNDTIMEO value
|
2393
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2394
|
+
|
2395
|
+
int
|
2396
|
+
zsock_sndtimeo (void *self)
|
2397
|
+
{
|
2398
|
+
assert (self);
|
2399
|
+
# if defined (ZMQ_SNDTIMEO)
|
2400
|
+
int sndtimeo;
|
2401
|
+
size_t option_len = sizeof (int);
|
2402
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_SNDTIMEO, &sndtimeo, &option_len);
|
2403
|
+
return sndtimeo;
|
2404
|
+
# else
|
2405
|
+
return 0;
|
2406
|
+
# endif
|
2407
|
+
}
|
2408
|
+
|
2409
|
+
// --------------------------------------------------------------------------
|
2410
|
+
// Set socket ZMQ_XPUB_VERBOSE value
|
2411
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2412
|
+
|
2413
|
+
void
|
2414
|
+
zsock_set_xpub_verbose (void *self, int xpub_verbose)
|
2415
|
+
{
|
2416
|
+
assert (self);
|
2417
|
+
# if defined (ZMQ_XPUB_VERBOSE)
|
2418
|
+
if (zsock_type (self) != ZMQ_XPUB) {
|
2419
|
+
printf ("ZMQ_XPUB_VERBOSE is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
|
2420
|
+
assert (false);
|
2421
|
+
}
|
2422
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_XPUB_VERBOSE, &xpub_verbose, sizeof (int));
|
2423
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2424
|
+
# endif
|
2425
|
+
}
|
2426
|
+
|
2427
|
+
|
2428
|
+
// --------------------------------------------------------------------------
|
2429
|
+
// Set socket ZMQ_TCP_KEEPALIVE value
|
2430
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2431
|
+
|
2432
|
+
void
|
2433
|
+
zsock_set_tcp_keepalive (void *self, int tcp_keepalive)
|
2434
|
+
{
|
2435
|
+
assert (self);
|
2436
|
+
# if defined (ZMQ_TCP_KEEPALIVE)
|
2437
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_TCP_KEEPALIVE, &tcp_keepalive, sizeof (int));
|
2438
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2439
|
+
# endif
|
2440
|
+
}
|
2441
|
+
|
2442
|
+
|
2443
|
+
// --------------------------------------------------------------------------
|
2444
|
+
// Return socket ZMQ_TCP_KEEPALIVE value
|
2445
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2446
|
+
|
2447
|
+
int
|
2448
|
+
zsock_tcp_keepalive (void *self)
|
2449
|
+
{
|
2450
|
+
assert (self);
|
2451
|
+
# if defined (ZMQ_TCP_KEEPALIVE)
|
2452
|
+
int tcp_keepalive;
|
2453
|
+
size_t option_len = sizeof (int);
|
2454
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_TCP_KEEPALIVE, &tcp_keepalive, &option_len);
|
2455
|
+
return tcp_keepalive;
|
2456
|
+
# else
|
2457
|
+
return 0;
|
2458
|
+
# endif
|
2459
|
+
}
|
2460
|
+
|
2461
|
+
// --------------------------------------------------------------------------
|
2462
|
+
// Set socket ZMQ_TCP_KEEPALIVE_IDLE value
|
2463
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2464
|
+
|
2465
|
+
void
|
2466
|
+
zsock_set_tcp_keepalive_idle (void *self, int tcp_keepalive_idle)
|
2467
|
+
{
|
2468
|
+
assert (self);
|
2469
|
+
# if defined (ZMQ_TCP_KEEPALIVE_IDLE)
|
2470
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_TCP_KEEPALIVE_IDLE, &tcp_keepalive_idle, sizeof (int));
|
2471
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2472
|
+
# endif
|
2473
|
+
}
|
2474
|
+
|
2475
|
+
|
2476
|
+
// --------------------------------------------------------------------------
|
2477
|
+
// Return socket ZMQ_TCP_KEEPALIVE_IDLE value
|
2478
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2479
|
+
|
2480
|
+
int
|
2481
|
+
zsock_tcp_keepalive_idle (void *self)
|
2482
|
+
{
|
2483
|
+
assert (self);
|
2484
|
+
# if defined (ZMQ_TCP_KEEPALIVE_IDLE)
|
2485
|
+
int tcp_keepalive_idle;
|
2486
|
+
size_t option_len = sizeof (int);
|
2487
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_TCP_KEEPALIVE_IDLE, &tcp_keepalive_idle, &option_len);
|
2488
|
+
return tcp_keepalive_idle;
|
2489
|
+
# else
|
2490
|
+
return 0;
|
2491
|
+
# endif
|
2492
|
+
}
|
2493
|
+
|
2494
|
+
// --------------------------------------------------------------------------
|
2495
|
+
// Set socket ZMQ_TCP_KEEPALIVE_CNT value
|
2496
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2497
|
+
|
2498
|
+
void
|
2499
|
+
zsock_set_tcp_keepalive_cnt (void *self, int tcp_keepalive_cnt)
|
2500
|
+
{
|
2501
|
+
assert (self);
|
2502
|
+
# if defined (ZMQ_TCP_KEEPALIVE_CNT)
|
2503
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_TCP_KEEPALIVE_CNT, &tcp_keepalive_cnt, sizeof (int));
|
2504
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2505
|
+
# endif
|
2506
|
+
}
|
2507
|
+
|
2508
|
+
|
2509
|
+
// --------------------------------------------------------------------------
|
2510
|
+
// Return socket ZMQ_TCP_KEEPALIVE_CNT value
|
2511
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2512
|
+
|
2513
|
+
int
|
2514
|
+
zsock_tcp_keepalive_cnt (void *self)
|
2515
|
+
{
|
2516
|
+
assert (self);
|
2517
|
+
# if defined (ZMQ_TCP_KEEPALIVE_CNT)
|
2518
|
+
int tcp_keepalive_cnt;
|
2519
|
+
size_t option_len = sizeof (int);
|
2520
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_TCP_KEEPALIVE_CNT, &tcp_keepalive_cnt, &option_len);
|
2521
|
+
return tcp_keepalive_cnt;
|
2522
|
+
# else
|
2523
|
+
return 0;
|
2524
|
+
# endif
|
2525
|
+
}
|
2526
|
+
|
2527
|
+
// --------------------------------------------------------------------------
|
2528
|
+
// Set socket ZMQ_TCP_KEEPALIVE_INTVL value
|
2529
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2530
|
+
|
2531
|
+
void
|
2532
|
+
zsock_set_tcp_keepalive_intvl (void *self, int tcp_keepalive_intvl)
|
2533
|
+
{
|
2534
|
+
assert (self);
|
2535
|
+
# if defined (ZMQ_TCP_KEEPALIVE_INTVL)
|
2536
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_TCP_KEEPALIVE_INTVL, &tcp_keepalive_intvl, sizeof (int));
|
2537
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2538
|
+
# endif
|
2539
|
+
}
|
2540
|
+
|
2541
|
+
|
2542
|
+
// --------------------------------------------------------------------------
|
2543
|
+
// Return socket ZMQ_TCP_KEEPALIVE_INTVL value
|
2544
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2545
|
+
|
2546
|
+
int
|
2547
|
+
zsock_tcp_keepalive_intvl (void *self)
|
2548
|
+
{
|
2549
|
+
assert (self);
|
2550
|
+
# if defined (ZMQ_TCP_KEEPALIVE_INTVL)
|
2551
|
+
int tcp_keepalive_intvl;
|
2552
|
+
size_t option_len = sizeof (int);
|
2553
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_TCP_KEEPALIVE_INTVL, &tcp_keepalive_intvl, &option_len);
|
2554
|
+
return tcp_keepalive_intvl;
|
2555
|
+
# else
|
2556
|
+
return 0;
|
2557
|
+
# endif
|
2558
|
+
}
|
2559
|
+
|
2560
|
+
// --------------------------------------------------------------------------
|
2561
|
+
// Set socket ZMQ_TCP_ACCEPT_FILTER value
|
2562
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2563
|
+
|
2564
|
+
void
|
2565
|
+
zsock_set_tcp_accept_filter (void *self, const char * tcp_accept_filter)
|
2566
|
+
{
|
2567
|
+
assert (self);
|
2568
|
+
# if defined (ZMQ_TCP_ACCEPT_FILTER)
|
2569
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_TCP_ACCEPT_FILTER, tcp_accept_filter, strlen (tcp_accept_filter));
|
2570
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2571
|
+
# endif
|
2572
|
+
}
|
2573
|
+
|
2574
|
+
|
2575
|
+
// --------------------------------------------------------------------------
|
2576
|
+
// Return socket ZMQ_TCP_ACCEPT_FILTER value
|
2577
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2578
|
+
|
2579
|
+
char *
|
2580
|
+
zsock_tcp_accept_filter (void *self)
|
2581
|
+
{
|
2582
|
+
assert (self);
|
2583
|
+
# if defined (ZMQ_TCP_ACCEPT_FILTER)
|
2584
|
+
size_t option_len = 255;
|
2585
|
+
char *tcp_accept_filter = (char *) zmalloc (option_len);
|
2586
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_TCP_ACCEPT_FILTER, tcp_accept_filter, &option_len);
|
2587
|
+
return (char *) tcp_accept_filter;
|
2588
|
+
# else
|
2589
|
+
return NULL;
|
2590
|
+
# endif
|
2591
|
+
}
|
2592
|
+
|
2593
|
+
// --------------------------------------------------------------------------
|
2594
|
+
// Return socket ZMQ_RCVMORE value
|
2595
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2596
|
+
|
2597
|
+
int
|
2598
|
+
zsock_rcvmore (void *self)
|
2599
|
+
{
|
2600
|
+
assert (self);
|
2601
|
+
# if defined (ZMQ_RCVMORE)
|
2602
|
+
int rcvmore;
|
2603
|
+
size_t option_len = sizeof (int);
|
2604
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RCVMORE, &rcvmore, &option_len);
|
2605
|
+
return rcvmore;
|
2606
|
+
# else
|
2607
|
+
return 0;
|
2608
|
+
# endif
|
2609
|
+
}
|
2610
|
+
|
2611
|
+
// --------------------------------------------------------------------------
|
2612
|
+
// Return socket ZMQ_FD value
|
2613
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2614
|
+
|
2615
|
+
SOCKET
|
2616
|
+
zsock_fd (void *self)
|
2617
|
+
{
|
2618
|
+
assert (self);
|
2619
|
+
# if defined (ZMQ_FD)
|
2620
|
+
SOCKET fd;
|
2621
|
+
size_t option_len = sizeof (SOCKET);
|
2622
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_FD, &fd, &option_len);
|
2623
|
+
return fd;
|
2624
|
+
# else
|
2625
|
+
return 0;
|
2626
|
+
# endif
|
2627
|
+
}
|
2628
|
+
|
2629
|
+
// --------------------------------------------------------------------------
|
2630
|
+
// Return socket ZMQ_EVENTS value
|
2631
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2632
|
+
|
2633
|
+
int
|
2634
|
+
zsock_events (void *self)
|
2635
|
+
{
|
2636
|
+
assert (self);
|
2637
|
+
# if defined (ZMQ_EVENTS)
|
2638
|
+
int events;
|
2639
|
+
size_t option_len = sizeof (int);
|
2640
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_EVENTS, &events, &option_len);
|
2641
|
+
return events;
|
2642
|
+
# else
|
2643
|
+
return 0;
|
2644
|
+
# endif
|
2645
|
+
}
|
2646
|
+
|
2647
|
+
// --------------------------------------------------------------------------
|
2648
|
+
// Return socket ZMQ_LAST_ENDPOINT value
|
2649
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2650
|
+
|
2651
|
+
char *
|
2652
|
+
zsock_last_endpoint (void *self)
|
2653
|
+
{
|
2654
|
+
assert (self);
|
2655
|
+
# if defined (ZMQ_LAST_ENDPOINT)
|
2656
|
+
size_t option_len = 255;
|
2657
|
+
char *last_endpoint = (char *) zmalloc (option_len);
|
2658
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_LAST_ENDPOINT, last_endpoint, &option_len);
|
2659
|
+
return (char *) last_endpoint;
|
2660
|
+
# else
|
2661
|
+
return NULL;
|
2662
|
+
# endif
|
2663
|
+
}
|
2664
|
+
|
2665
|
+
#endif
|
2666
|
+
|
2667
|
+
#if (ZMQ_VERSION_MAJOR == 2)
|
2668
|
+
// --------------------------------------------------------------------------
|
2669
|
+
// Set socket ZMQ_HWM value
|
2670
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2671
|
+
|
2672
|
+
void
|
2673
|
+
zsock_set_hwm (void *self, int hwm)
|
2674
|
+
{
|
2675
|
+
assert (self);
|
2676
|
+
# if defined (ZMQ_HWM)
|
2677
|
+
uint64_t value = hwm;
|
2678
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_HWM, &value, sizeof (uint64_t));
|
2679
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2680
|
+
# endif
|
2681
|
+
}
|
2682
|
+
|
2683
|
+
|
2684
|
+
// --------------------------------------------------------------------------
|
2685
|
+
// Return socket ZMQ_HWM value
|
2686
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2687
|
+
|
2688
|
+
int
|
2689
|
+
zsock_hwm (void *self)
|
2690
|
+
{
|
2691
|
+
assert (self);
|
2692
|
+
# if defined (ZMQ_HWM)
|
2693
|
+
uint64_t hwm;
|
2694
|
+
size_t option_len = sizeof (uint64_t);
|
2695
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_HWM, &hwm, &option_len);
|
2696
|
+
return (int) hwm;
|
2697
|
+
# else
|
2698
|
+
return 0;
|
2699
|
+
# endif
|
2700
|
+
}
|
2701
|
+
|
2702
|
+
// --------------------------------------------------------------------------
|
2703
|
+
// Set socket ZMQ_SWAP value
|
2704
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2705
|
+
|
2706
|
+
void
|
2707
|
+
zsock_set_swap (void *self, int swap)
|
2708
|
+
{
|
2709
|
+
assert (self);
|
2710
|
+
# if defined (ZMQ_SWAP)
|
2711
|
+
int64_t value = swap;
|
2712
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_SWAP, &value, sizeof (int64_t));
|
2713
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2714
|
+
# endif
|
2715
|
+
}
|
2716
|
+
|
2717
|
+
|
2718
|
+
// --------------------------------------------------------------------------
|
2719
|
+
// Return socket ZMQ_SWAP value
|
2720
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2721
|
+
|
2722
|
+
int
|
2723
|
+
zsock_swap (void *self)
|
2724
|
+
{
|
2725
|
+
assert (self);
|
2726
|
+
# if defined (ZMQ_SWAP)
|
2727
|
+
int64_t swap;
|
2728
|
+
size_t option_len = sizeof (int64_t);
|
2729
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_SWAP, &swap, &option_len);
|
2730
|
+
return (int) swap;
|
2731
|
+
# else
|
2732
|
+
return 0;
|
2733
|
+
# endif
|
2734
|
+
}
|
2735
|
+
|
2736
|
+
// --------------------------------------------------------------------------
|
2737
|
+
// Set socket ZMQ_AFFINITY value
|
2738
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2739
|
+
|
2740
|
+
void
|
2741
|
+
zsock_set_affinity (void *self, int affinity)
|
2742
|
+
{
|
2743
|
+
assert (self);
|
2744
|
+
# if defined (ZMQ_AFFINITY)
|
2745
|
+
uint64_t value = affinity;
|
2746
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_AFFINITY, &value, sizeof (uint64_t));
|
2747
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2748
|
+
# endif
|
2749
|
+
}
|
2750
|
+
|
2751
|
+
|
2752
|
+
// --------------------------------------------------------------------------
|
2753
|
+
// Return socket ZMQ_AFFINITY value
|
2754
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2755
|
+
|
2756
|
+
int
|
2757
|
+
zsock_affinity (void *self)
|
2758
|
+
{
|
2759
|
+
assert (self);
|
2760
|
+
# if defined (ZMQ_AFFINITY)
|
2761
|
+
uint64_t affinity;
|
2762
|
+
size_t option_len = sizeof (uint64_t);
|
2763
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_AFFINITY, &affinity, &option_len);
|
2764
|
+
return (int) affinity;
|
2765
|
+
# else
|
2766
|
+
return 0;
|
2767
|
+
# endif
|
2768
|
+
}
|
2769
|
+
|
2770
|
+
// --------------------------------------------------------------------------
|
2771
|
+
// Set socket ZMQ_IDENTITY value
|
2772
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2773
|
+
|
2774
|
+
void
|
2775
|
+
zsock_set_identity (void *self, const char * identity)
|
2776
|
+
{
|
2777
|
+
assert (self);
|
2778
|
+
# if defined (ZMQ_IDENTITY)
|
2779
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_IDENTITY, identity, strlen (identity));
|
2780
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2781
|
+
# endif
|
2782
|
+
}
|
2783
|
+
|
2784
|
+
|
2785
|
+
// --------------------------------------------------------------------------
|
2786
|
+
// Return socket ZMQ_IDENTITY value
|
2787
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2788
|
+
|
2789
|
+
char *
|
2790
|
+
zsock_identity (void *self)
|
2791
|
+
{
|
2792
|
+
assert (self);
|
2793
|
+
# if defined (ZMQ_IDENTITY)
|
2794
|
+
size_t option_len = 255;
|
2795
|
+
char *identity = (char *) zmalloc (option_len);
|
2796
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_IDENTITY, identity, &option_len);
|
2797
|
+
return (char *) identity;
|
2798
|
+
# else
|
2799
|
+
return NULL;
|
2800
|
+
# endif
|
2801
|
+
}
|
2802
|
+
|
2803
|
+
// --------------------------------------------------------------------------
|
2804
|
+
// Set socket ZMQ_RATE value
|
2805
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2806
|
+
|
2807
|
+
void
|
2808
|
+
zsock_set_rate (void *self, int rate)
|
2809
|
+
{
|
2810
|
+
assert (self);
|
2811
|
+
# if defined (ZMQ_RATE)
|
2812
|
+
int64_t value = rate;
|
2813
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_RATE, &value, sizeof (int64_t));
|
2814
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2815
|
+
# endif
|
2816
|
+
}
|
2817
|
+
|
2818
|
+
|
2819
|
+
// --------------------------------------------------------------------------
|
2820
|
+
// Return socket ZMQ_RATE value
|
2821
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2822
|
+
|
2823
|
+
int
|
2824
|
+
zsock_rate (void *self)
|
2825
|
+
{
|
2826
|
+
assert (self);
|
2827
|
+
# if defined (ZMQ_RATE)
|
2828
|
+
int64_t rate;
|
2829
|
+
size_t option_len = sizeof (int64_t);
|
2830
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RATE, &rate, &option_len);
|
2831
|
+
return (int) rate;
|
2832
|
+
# else
|
2833
|
+
return 0;
|
2834
|
+
# endif
|
2835
|
+
}
|
2836
|
+
|
2837
|
+
// --------------------------------------------------------------------------
|
2838
|
+
// Set socket ZMQ_RECOVERY_IVL value
|
2839
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2840
|
+
|
2841
|
+
void
|
2842
|
+
zsock_set_recovery_ivl (void *self, int recovery_ivl)
|
2843
|
+
{
|
2844
|
+
assert (self);
|
2845
|
+
# if defined (ZMQ_RECOVERY_IVL)
|
2846
|
+
int64_t value = recovery_ivl;
|
2847
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_RECOVERY_IVL, &value, sizeof (int64_t));
|
2848
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2849
|
+
# endif
|
2850
|
+
}
|
2851
|
+
|
2852
|
+
|
2853
|
+
// --------------------------------------------------------------------------
|
2854
|
+
// Return socket ZMQ_RECOVERY_IVL value
|
2855
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2856
|
+
|
2857
|
+
int
|
2858
|
+
zsock_recovery_ivl (void *self)
|
2859
|
+
{
|
2860
|
+
assert (self);
|
2861
|
+
# if defined (ZMQ_RECOVERY_IVL)
|
2862
|
+
int64_t recovery_ivl;
|
2863
|
+
size_t option_len = sizeof (int64_t);
|
2864
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RECOVERY_IVL, &recovery_ivl, &option_len);
|
2865
|
+
return (int) recovery_ivl;
|
2866
|
+
# else
|
2867
|
+
return 0;
|
2868
|
+
# endif
|
2869
|
+
}
|
2870
|
+
|
2871
|
+
// --------------------------------------------------------------------------
|
2872
|
+
// Set socket ZMQ_RECOVERY_IVL_MSEC value
|
2873
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2874
|
+
|
2875
|
+
void
|
2876
|
+
zsock_set_recovery_ivl_msec (void *self, int recovery_ivl_msec)
|
2877
|
+
{
|
2878
|
+
assert (self);
|
2879
|
+
# if defined (ZMQ_RECOVERY_IVL_MSEC)
|
2880
|
+
int64_t value = recovery_ivl_msec;
|
2881
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_RECOVERY_IVL_MSEC, &value, sizeof (int64_t));
|
2882
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2883
|
+
# endif
|
2884
|
+
}
|
2885
|
+
|
2886
|
+
|
2887
|
+
// --------------------------------------------------------------------------
|
2888
|
+
// Return socket ZMQ_RECOVERY_IVL_MSEC value
|
2889
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2890
|
+
|
2891
|
+
int
|
2892
|
+
zsock_recovery_ivl_msec (void *self)
|
2893
|
+
{
|
2894
|
+
assert (self);
|
2895
|
+
# if defined (ZMQ_RECOVERY_IVL_MSEC)
|
2896
|
+
int64_t recovery_ivl_msec;
|
2897
|
+
size_t option_len = sizeof (int64_t);
|
2898
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RECOVERY_IVL_MSEC, &recovery_ivl_msec, &option_len);
|
2899
|
+
return (int) recovery_ivl_msec;
|
2900
|
+
# else
|
2901
|
+
return 0;
|
2902
|
+
# endif
|
2903
|
+
}
|
2904
|
+
|
2905
|
+
// --------------------------------------------------------------------------
|
2906
|
+
// Set socket ZMQ_MCAST_LOOP value
|
2907
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2908
|
+
|
2909
|
+
void
|
2910
|
+
zsock_set_mcast_loop (void *self, int mcast_loop)
|
2911
|
+
{
|
2912
|
+
assert (self);
|
2913
|
+
# if defined (ZMQ_MCAST_LOOP)
|
2914
|
+
int64_t value = mcast_loop;
|
2915
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_MCAST_LOOP, &value, sizeof (int64_t));
|
2916
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2917
|
+
# endif
|
2918
|
+
}
|
2919
|
+
|
2920
|
+
|
2921
|
+
// --------------------------------------------------------------------------
|
2922
|
+
// Return socket ZMQ_MCAST_LOOP value
|
2923
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2924
|
+
|
2925
|
+
int
|
2926
|
+
zsock_mcast_loop (void *self)
|
2927
|
+
{
|
2928
|
+
assert (self);
|
2929
|
+
# if defined (ZMQ_MCAST_LOOP)
|
2930
|
+
int64_t mcast_loop;
|
2931
|
+
size_t option_len = sizeof (int64_t);
|
2932
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_MCAST_LOOP, &mcast_loop, &option_len);
|
2933
|
+
return (int) mcast_loop;
|
2934
|
+
# else
|
2935
|
+
return 0;
|
2936
|
+
# endif
|
2937
|
+
}
|
2938
|
+
|
2939
|
+
# if (ZMQ_VERSION_MINOR == 2)
|
2940
|
+
// --------------------------------------------------------------------------
|
2941
|
+
// Set socket ZMQ_RCVTIMEO value
|
2942
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2943
|
+
|
2944
|
+
void
|
2945
|
+
zsock_set_rcvtimeo (void *self, int rcvtimeo)
|
2946
|
+
{
|
2947
|
+
assert (self);
|
2948
|
+
# if defined (ZMQ_RCVTIMEO)
|
2949
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_RCVTIMEO, &rcvtimeo, sizeof (int));
|
2950
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2951
|
+
# endif
|
2952
|
+
}
|
2953
|
+
|
2954
|
+
|
2955
|
+
// --------------------------------------------------------------------------
|
2956
|
+
// Return socket ZMQ_RCVTIMEO value
|
2957
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2958
|
+
|
2959
|
+
int
|
2960
|
+
zsock_rcvtimeo (void *self)
|
2961
|
+
{
|
2962
|
+
assert (self);
|
2963
|
+
# if defined (ZMQ_RCVTIMEO)
|
2964
|
+
int rcvtimeo;
|
2965
|
+
size_t option_len = sizeof (int);
|
2966
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RCVTIMEO, &rcvtimeo, &option_len);
|
2967
|
+
return rcvtimeo;
|
2968
|
+
# else
|
2969
|
+
return 0;
|
2970
|
+
# endif
|
2971
|
+
}
|
2972
|
+
|
2973
|
+
# endif
|
2974
|
+
# if (ZMQ_VERSION_MINOR == 2)
|
2975
|
+
// --------------------------------------------------------------------------
|
2976
|
+
// Set socket ZMQ_SNDTIMEO value
|
2977
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2978
|
+
|
2979
|
+
void
|
2980
|
+
zsock_set_sndtimeo (void *self, int sndtimeo)
|
2981
|
+
{
|
2982
|
+
assert (self);
|
2983
|
+
# if defined (ZMQ_SNDTIMEO)
|
2984
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_SNDTIMEO, &sndtimeo, sizeof (int));
|
2985
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
2986
|
+
# endif
|
2987
|
+
}
|
2988
|
+
|
2989
|
+
|
2990
|
+
// --------------------------------------------------------------------------
|
2991
|
+
// Return socket ZMQ_SNDTIMEO value
|
2992
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
2993
|
+
|
2994
|
+
int
|
2995
|
+
zsock_sndtimeo (void *self)
|
2996
|
+
{
|
2997
|
+
assert (self);
|
2998
|
+
# if defined (ZMQ_SNDTIMEO)
|
2999
|
+
int sndtimeo;
|
3000
|
+
size_t option_len = sizeof (int);
|
3001
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_SNDTIMEO, &sndtimeo, &option_len);
|
3002
|
+
return sndtimeo;
|
3003
|
+
# else
|
3004
|
+
return 0;
|
3005
|
+
# endif
|
3006
|
+
}
|
3007
|
+
|
3008
|
+
# endif
|
3009
|
+
// --------------------------------------------------------------------------
|
3010
|
+
// Set socket ZMQ_SNDBUF value
|
3011
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
3012
|
+
|
3013
|
+
void
|
3014
|
+
zsock_set_sndbuf (void *self, int sndbuf)
|
3015
|
+
{
|
3016
|
+
assert (self);
|
3017
|
+
# if defined (ZMQ_SNDBUF)
|
3018
|
+
uint64_t value = sndbuf;
|
3019
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_SNDBUF, &value, sizeof (uint64_t));
|
3020
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
3021
|
+
# endif
|
3022
|
+
}
|
3023
|
+
|
3024
|
+
|
3025
|
+
// --------------------------------------------------------------------------
|
3026
|
+
// Return socket ZMQ_SNDBUF value
|
3027
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
3028
|
+
|
3029
|
+
int
|
3030
|
+
zsock_sndbuf (void *self)
|
3031
|
+
{
|
3032
|
+
assert (self);
|
3033
|
+
# if defined (ZMQ_SNDBUF)
|
3034
|
+
uint64_t sndbuf;
|
3035
|
+
size_t option_len = sizeof (uint64_t);
|
3036
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_SNDBUF, &sndbuf, &option_len);
|
3037
|
+
return (int) sndbuf;
|
3038
|
+
# else
|
3039
|
+
return 0;
|
3040
|
+
# endif
|
3041
|
+
}
|
3042
|
+
|
3043
|
+
// --------------------------------------------------------------------------
|
3044
|
+
// Set socket ZMQ_RCVBUF value
|
3045
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
3046
|
+
|
3047
|
+
void
|
3048
|
+
zsock_set_rcvbuf (void *self, int rcvbuf)
|
3049
|
+
{
|
3050
|
+
assert (self);
|
3051
|
+
# if defined (ZMQ_RCVBUF)
|
3052
|
+
uint64_t value = rcvbuf;
|
3053
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_RCVBUF, &value, sizeof (uint64_t));
|
3054
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
3055
|
+
# endif
|
3056
|
+
}
|
3057
|
+
|
3058
|
+
|
3059
|
+
// --------------------------------------------------------------------------
|
3060
|
+
// Return socket ZMQ_RCVBUF value
|
3061
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
3062
|
+
|
3063
|
+
int
|
3064
|
+
zsock_rcvbuf (void *self)
|
3065
|
+
{
|
3066
|
+
assert (self);
|
3067
|
+
# if defined (ZMQ_RCVBUF)
|
3068
|
+
uint64_t rcvbuf;
|
3069
|
+
size_t option_len = sizeof (uint64_t);
|
3070
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RCVBUF, &rcvbuf, &option_len);
|
3071
|
+
return (int) rcvbuf;
|
3072
|
+
# else
|
3073
|
+
return 0;
|
3074
|
+
# endif
|
3075
|
+
}
|
3076
|
+
|
3077
|
+
// --------------------------------------------------------------------------
|
3078
|
+
// Set socket ZMQ_LINGER value
|
3079
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
3080
|
+
|
3081
|
+
void
|
3082
|
+
zsock_set_linger (void *self, int linger)
|
3083
|
+
{
|
3084
|
+
assert (self);
|
3085
|
+
# if defined (ZMQ_LINGER)
|
3086
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_LINGER, &linger, sizeof (int));
|
3087
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
3088
|
+
# endif
|
3089
|
+
}
|
3090
|
+
|
3091
|
+
|
3092
|
+
// --------------------------------------------------------------------------
|
3093
|
+
// Return socket ZMQ_LINGER value
|
3094
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
3095
|
+
|
3096
|
+
int
|
3097
|
+
zsock_linger (void *self)
|
3098
|
+
{
|
3099
|
+
assert (self);
|
3100
|
+
# if defined (ZMQ_LINGER)
|
3101
|
+
int linger;
|
3102
|
+
size_t option_len = sizeof (int);
|
3103
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_LINGER, &linger, &option_len);
|
3104
|
+
return linger;
|
3105
|
+
# else
|
3106
|
+
return 0;
|
3107
|
+
# endif
|
3108
|
+
}
|
3109
|
+
|
3110
|
+
// --------------------------------------------------------------------------
|
3111
|
+
// Set socket ZMQ_RECONNECT_IVL value
|
3112
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
3113
|
+
|
3114
|
+
void
|
3115
|
+
zsock_set_reconnect_ivl (void *self, int reconnect_ivl)
|
3116
|
+
{
|
3117
|
+
assert (self);
|
3118
|
+
# if defined (ZMQ_RECONNECT_IVL)
|
3119
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_RECONNECT_IVL, &reconnect_ivl, sizeof (int));
|
3120
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
3121
|
+
# endif
|
3122
|
+
}
|
3123
|
+
|
3124
|
+
|
3125
|
+
// --------------------------------------------------------------------------
|
3126
|
+
// Return socket ZMQ_RECONNECT_IVL value
|
3127
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
3128
|
+
|
3129
|
+
int
|
3130
|
+
zsock_reconnect_ivl (void *self)
|
3131
|
+
{
|
3132
|
+
assert (self);
|
3133
|
+
# if defined (ZMQ_RECONNECT_IVL)
|
3134
|
+
int reconnect_ivl;
|
3135
|
+
size_t option_len = sizeof (int);
|
3136
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RECONNECT_IVL, &reconnect_ivl, &option_len);
|
3137
|
+
return reconnect_ivl;
|
3138
|
+
# else
|
3139
|
+
return 0;
|
3140
|
+
# endif
|
3141
|
+
}
|
3142
|
+
|
3143
|
+
// --------------------------------------------------------------------------
|
3144
|
+
// Set socket ZMQ_RECONNECT_IVL_MAX value
|
3145
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
3146
|
+
|
3147
|
+
void
|
3148
|
+
zsock_set_reconnect_ivl_max (void *self, int reconnect_ivl_max)
|
3149
|
+
{
|
3150
|
+
assert (self);
|
3151
|
+
# if defined (ZMQ_RECONNECT_IVL_MAX)
|
3152
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_RECONNECT_IVL_MAX, &reconnect_ivl_max, sizeof (int));
|
3153
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
3154
|
+
# endif
|
3155
|
+
}
|
3156
|
+
|
3157
|
+
|
3158
|
+
// --------------------------------------------------------------------------
|
3159
|
+
// Return socket ZMQ_RECONNECT_IVL_MAX value
|
3160
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
3161
|
+
|
3162
|
+
int
|
3163
|
+
zsock_reconnect_ivl_max (void *self)
|
3164
|
+
{
|
3165
|
+
assert (self);
|
3166
|
+
# if defined (ZMQ_RECONNECT_IVL_MAX)
|
3167
|
+
int reconnect_ivl_max;
|
3168
|
+
size_t option_len = sizeof (int);
|
3169
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RECONNECT_IVL_MAX, &reconnect_ivl_max, &option_len);
|
3170
|
+
return reconnect_ivl_max;
|
3171
|
+
# else
|
3172
|
+
return 0;
|
3173
|
+
# endif
|
3174
|
+
}
|
3175
|
+
|
3176
|
+
// --------------------------------------------------------------------------
|
3177
|
+
// Set socket ZMQ_BACKLOG value
|
3178
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
3179
|
+
|
3180
|
+
void
|
3181
|
+
zsock_set_backlog (void *self, int backlog)
|
3182
|
+
{
|
3183
|
+
assert (self);
|
3184
|
+
# if defined (ZMQ_BACKLOG)
|
3185
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_BACKLOG, &backlog, sizeof (int));
|
3186
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
3187
|
+
# endif
|
3188
|
+
}
|
3189
|
+
|
3190
|
+
|
3191
|
+
// --------------------------------------------------------------------------
|
3192
|
+
// Return socket ZMQ_BACKLOG value
|
3193
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
3194
|
+
|
3195
|
+
int
|
3196
|
+
zsock_backlog (void *self)
|
3197
|
+
{
|
3198
|
+
assert (self);
|
3199
|
+
# if defined (ZMQ_BACKLOG)
|
3200
|
+
int backlog;
|
3201
|
+
size_t option_len = sizeof (int);
|
3202
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_BACKLOG, &backlog, &option_len);
|
3203
|
+
return backlog;
|
3204
|
+
# else
|
3205
|
+
return 0;
|
3206
|
+
# endif
|
3207
|
+
}
|
3208
|
+
|
3209
|
+
// --------------------------------------------------------------------------
|
3210
|
+
// Set socket ZMQ_SUBSCRIBE value
|
3211
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
3212
|
+
|
3213
|
+
void
|
3214
|
+
zsock_set_subscribe (void *self, const char * subscribe)
|
3215
|
+
{
|
3216
|
+
assert (self);
|
3217
|
+
# if defined (ZMQ_SUBSCRIBE)
|
3218
|
+
if (zsock_type (self) != ZMQ_SUB) {
|
3219
|
+
printf ("ZMQ_SUBSCRIBE is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
|
3220
|
+
assert (false);
|
3221
|
+
}
|
3222
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_SUBSCRIBE, subscribe, strlen (subscribe));
|
3223
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
3224
|
+
# endif
|
3225
|
+
}
|
3226
|
+
|
3227
|
+
|
3228
|
+
// --------------------------------------------------------------------------
|
3229
|
+
// Set socket ZMQ_UNSUBSCRIBE value
|
3230
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
3231
|
+
|
3232
|
+
void
|
3233
|
+
zsock_set_unsubscribe (void *self, const char * unsubscribe)
|
3234
|
+
{
|
3235
|
+
assert (self);
|
3236
|
+
# if defined (ZMQ_UNSUBSCRIBE)
|
3237
|
+
if (zsock_type (self) != ZMQ_SUB) {
|
3238
|
+
printf ("ZMQ_UNSUBSCRIBE is not valid on %s sockets\n", zsys_sockname (zsock_type (self)));
|
3239
|
+
assert (false);
|
3240
|
+
}
|
3241
|
+
int rc = zmq_setsockopt (zsock_resolve (self), ZMQ_UNSUBSCRIBE, unsubscribe, strlen (unsubscribe));
|
3242
|
+
assert (rc == 0 || zmq_errno () == ETERM);
|
3243
|
+
# endif
|
3244
|
+
}
|
3245
|
+
|
3246
|
+
|
3247
|
+
// --------------------------------------------------------------------------
|
3248
|
+
// Return socket ZMQ_TYPE value
|
3249
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
3250
|
+
|
3251
|
+
int
|
3252
|
+
zsock_type (void *self)
|
3253
|
+
{
|
3254
|
+
assert (self);
|
3255
|
+
# if defined (ZMQ_TYPE)
|
3256
|
+
int type;
|
3257
|
+
size_t option_len = sizeof (int);
|
3258
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_TYPE, &type, &option_len);
|
3259
|
+
return type;
|
3260
|
+
# else
|
3261
|
+
return 0;
|
3262
|
+
# endif
|
3263
|
+
}
|
3264
|
+
|
3265
|
+
// --------------------------------------------------------------------------
|
3266
|
+
// Return socket ZMQ_RCVMORE value
|
3267
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
3268
|
+
|
3269
|
+
int
|
3270
|
+
zsock_rcvmore (void *self)
|
3271
|
+
{
|
3272
|
+
assert (self);
|
3273
|
+
# if defined (ZMQ_RCVMORE)
|
3274
|
+
int64_t rcvmore;
|
3275
|
+
size_t option_len = sizeof (int64_t);
|
3276
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_RCVMORE, &rcvmore, &option_len);
|
3277
|
+
return (int) rcvmore;
|
3278
|
+
# else
|
3279
|
+
return 0;
|
3280
|
+
# endif
|
3281
|
+
}
|
3282
|
+
|
3283
|
+
// --------------------------------------------------------------------------
|
3284
|
+
// Return socket ZMQ_FD value
|
3285
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
3286
|
+
|
3287
|
+
SOCKET
|
3288
|
+
zsock_fd (void *self)
|
3289
|
+
{
|
3290
|
+
assert (self);
|
3291
|
+
# if defined (ZMQ_FD)
|
3292
|
+
SOCKET fd;
|
3293
|
+
size_t option_len = sizeof (SOCKET);
|
3294
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_FD, &fd, &option_len);
|
3295
|
+
return fd;
|
3296
|
+
# else
|
3297
|
+
return 0;
|
3298
|
+
# endif
|
3299
|
+
}
|
3300
|
+
|
3301
|
+
// --------------------------------------------------------------------------
|
3302
|
+
// Return socket ZMQ_EVENTS value
|
3303
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
3304
|
+
|
3305
|
+
int
|
3306
|
+
zsock_events (void *self)
|
3307
|
+
{
|
3308
|
+
assert (self);
|
3309
|
+
# if defined (ZMQ_EVENTS)
|
3310
|
+
uint32_t events;
|
3311
|
+
size_t option_len = sizeof (uint32_t);
|
3312
|
+
zmq_getsockopt (zsock_resolve (self), ZMQ_EVENTS, &events, &option_len);
|
3313
|
+
return (int) events;
|
3314
|
+
# else
|
3315
|
+
return 0;
|
3316
|
+
# endif
|
3317
|
+
}
|
3318
|
+
|
3319
|
+
#endif
|
3320
|
+
|
3321
|
+
// --------------------------------------------------------------------------
|
3322
|
+
// Selftest
|
3323
|
+
// *** GENERATED SOURCE CODE, DO NOT EDIT, SEE INSTRUCTIONS AT START ***
|
3324
|
+
|
3325
|
+
void
|
3326
|
+
zsock_option_test (bool verbose)
|
3327
|
+
{
|
3328
|
+
printf (" * zsock_option: ");
|
3329
|
+
|
3330
|
+
// @selftest
|
3331
|
+
zsock_t *self;
|
3332
|
+
#if (ZMQ_VERSION_MAJOR == 4)
|
3333
|
+
# if defined (ZMQ_HEARTBEAT_IVL)
|
3334
|
+
self = zsock_new (ZMQ_DEALER);
|
3335
|
+
assert (self);
|
3336
|
+
zsock_set_heartbeat_ivl (self, 2000);
|
3337
|
+
assert (zsock_heartbeat_ivl (self) == 2000);
|
3338
|
+
zsock_heartbeat_ivl (self);
|
3339
|
+
zsock_destroy (&self);
|
3340
|
+
# endif
|
3341
|
+
# if defined (ZMQ_HEARTBEAT_TTL)
|
3342
|
+
self = zsock_new (ZMQ_DEALER);
|
3343
|
+
assert (self);
|
3344
|
+
zsock_set_heartbeat_ttl (self, 4000);
|
3345
|
+
assert (zsock_heartbeat_ttl (self) == 4000);
|
3346
|
+
zsock_heartbeat_ttl (self);
|
3347
|
+
zsock_destroy (&self);
|
3348
|
+
# endif
|
3349
|
+
# if defined (ZMQ_HEARTBEAT_TIMEOUT)
|
3350
|
+
self = zsock_new (ZMQ_DEALER);
|
3351
|
+
assert (self);
|
3352
|
+
zsock_set_heartbeat_timeout (self, 6000);
|
3353
|
+
assert (zsock_heartbeat_timeout (self) == 6000);
|
3354
|
+
zsock_heartbeat_timeout (self);
|
3355
|
+
zsock_destroy (&self);
|
3356
|
+
# endif
|
3357
|
+
# if defined (ZMQ_USE_FD)
|
3358
|
+
self = zsock_new (ZMQ_REQ);
|
3359
|
+
assert (self);
|
3360
|
+
zsock_set_use_fd (self, 3);
|
3361
|
+
assert (zsock_use_fd (self) == 3);
|
3362
|
+
zsock_use_fd (self);
|
3363
|
+
zsock_destroy (&self);
|
3364
|
+
# endif
|
3365
|
+
# if defined (ZMQ_TOS)
|
3366
|
+
self = zsock_new (ZMQ_DEALER);
|
3367
|
+
assert (self);
|
3368
|
+
zsock_set_tos (self, 1);
|
3369
|
+
assert (zsock_tos (self) == 1);
|
3370
|
+
zsock_tos (self);
|
3371
|
+
zsock_destroy (&self);
|
3372
|
+
# endif
|
3373
|
+
# if defined (ZMQ_ROUTER_HANDOVER)
|
3374
|
+
self = zsock_new (ZMQ_ROUTER);
|
3375
|
+
assert (self);
|
3376
|
+
zsock_set_router_handover (self, 1);
|
3377
|
+
zsock_destroy (&self);
|
3378
|
+
# endif
|
3379
|
+
# if defined (ZMQ_ROUTER_MANDATORY)
|
3380
|
+
self = zsock_new (ZMQ_ROUTER);
|
3381
|
+
assert (self);
|
3382
|
+
zsock_set_router_mandatory (self, 1);
|
3383
|
+
zsock_destroy (&self);
|
3384
|
+
# endif
|
3385
|
+
# if defined (ZMQ_PROBE_ROUTER)
|
3386
|
+
self = zsock_new (ZMQ_DEALER);
|
3387
|
+
assert (self);
|
3388
|
+
zsock_set_probe_router (self, 1);
|
3389
|
+
zsock_destroy (&self);
|
3390
|
+
# endif
|
3391
|
+
# if defined (ZMQ_REQ_RELAXED)
|
3392
|
+
self = zsock_new (ZMQ_REQ);
|
3393
|
+
assert (self);
|
3394
|
+
zsock_set_req_relaxed (self, 1);
|
3395
|
+
zsock_destroy (&self);
|
3396
|
+
# endif
|
3397
|
+
# if defined (ZMQ_REQ_CORRELATE)
|
3398
|
+
self = zsock_new (ZMQ_REQ);
|
3399
|
+
assert (self);
|
3400
|
+
zsock_set_req_correlate (self, 1);
|
3401
|
+
zsock_destroy (&self);
|
3402
|
+
# endif
|
3403
|
+
# if defined (ZMQ_CONFLATE)
|
3404
|
+
self = zsock_new (ZMQ_PUSH);
|
3405
|
+
assert (self);
|
3406
|
+
zsock_set_conflate (self, 1);
|
3407
|
+
zsock_destroy (&self);
|
3408
|
+
# endif
|
3409
|
+
# if defined (ZMQ_ZAP_DOMAIN)
|
3410
|
+
self = zsock_new (ZMQ_SUB);
|
3411
|
+
assert (self);
|
3412
|
+
zsock_set_zap_domain (self, "test");
|
3413
|
+
char *zap_domain = zsock_zap_domain (self);
|
3414
|
+
assert (zap_domain);
|
3415
|
+
free (zap_domain);
|
3416
|
+
zsock_destroy (&self);
|
3417
|
+
# endif
|
3418
|
+
# if defined (ZMQ_MECHANISM)
|
3419
|
+
self = zsock_new (ZMQ_SUB);
|
3420
|
+
assert (self);
|
3421
|
+
zsock_mechanism (self);
|
3422
|
+
zsock_destroy (&self);
|
3423
|
+
# endif
|
3424
|
+
# if defined (ZMQ_PLAIN_SERVER)
|
3425
|
+
self = zsock_new (ZMQ_PUB);
|
3426
|
+
assert (self);
|
3427
|
+
zsock_set_plain_server (self, 1);
|
3428
|
+
assert (zsock_plain_server (self) == 1);
|
3429
|
+
zsock_plain_server (self);
|
3430
|
+
zsock_destroy (&self);
|
3431
|
+
# endif
|
3432
|
+
# if defined (ZMQ_PLAIN_USERNAME)
|
3433
|
+
self = zsock_new (ZMQ_SUB);
|
3434
|
+
assert (self);
|
3435
|
+
zsock_set_plain_username (self, "test");
|
3436
|
+
char *plain_username = zsock_plain_username (self);
|
3437
|
+
assert (plain_username);
|
3438
|
+
free (plain_username);
|
3439
|
+
zsock_destroy (&self);
|
3440
|
+
# endif
|
3441
|
+
# if defined (ZMQ_PLAIN_PASSWORD)
|
3442
|
+
self = zsock_new (ZMQ_SUB);
|
3443
|
+
assert (self);
|
3444
|
+
zsock_set_plain_password (self, "test");
|
3445
|
+
char *plain_password = zsock_plain_password (self);
|
3446
|
+
assert (plain_password);
|
3447
|
+
free (plain_password);
|
3448
|
+
zsock_destroy (&self);
|
3449
|
+
# endif
|
3450
|
+
# if defined (ZMQ_IPV6)
|
3451
|
+
self = zsock_new (ZMQ_SUB);
|
3452
|
+
assert (self);
|
3453
|
+
zsock_set_ipv6 (self, 1);
|
3454
|
+
assert (zsock_ipv6 (self) == 1);
|
3455
|
+
zsock_ipv6 (self);
|
3456
|
+
zsock_destroy (&self);
|
3457
|
+
# endif
|
3458
|
+
# if defined (ZMQ_IMMEDIATE)
|
3459
|
+
self = zsock_new (ZMQ_DEALER);
|
3460
|
+
assert (self);
|
3461
|
+
zsock_set_immediate (self, 1);
|
3462
|
+
assert (zsock_immediate (self) == 1);
|
3463
|
+
zsock_immediate (self);
|
3464
|
+
zsock_destroy (&self);
|
3465
|
+
# endif
|
3466
|
+
# if defined (ZMQ_ROUTER_RAW)
|
3467
|
+
self = zsock_new (ZMQ_ROUTER);
|
3468
|
+
assert (self);
|
3469
|
+
zsock_set_router_raw (self, 1);
|
3470
|
+
zsock_destroy (&self);
|
3471
|
+
# endif
|
3472
|
+
# if defined (ZMQ_IPV4ONLY)
|
3473
|
+
self = zsock_new (ZMQ_SUB);
|
3474
|
+
assert (self);
|
3475
|
+
zsock_set_ipv4only (self, 1);
|
3476
|
+
assert (zsock_ipv4only (self) == 1);
|
3477
|
+
zsock_ipv4only (self);
|
3478
|
+
zsock_destroy (&self);
|
3479
|
+
# endif
|
3480
|
+
# if defined (ZMQ_DELAY_ATTACH_ON_CONNECT)
|
3481
|
+
self = zsock_new (ZMQ_PUB);
|
3482
|
+
assert (self);
|
3483
|
+
zsock_set_delay_attach_on_connect (self, 1);
|
3484
|
+
zsock_destroy (&self);
|
3485
|
+
# endif
|
3486
|
+
# if defined (ZMQ_TYPE)
|
3487
|
+
self = zsock_new (ZMQ_SUB);
|
3488
|
+
assert (self);
|
3489
|
+
zsock_type (self);
|
3490
|
+
zsock_destroy (&self);
|
3491
|
+
# endif
|
3492
|
+
# if defined (ZMQ_SNDHWM)
|
3493
|
+
self = zsock_new (ZMQ_PUB);
|
3494
|
+
assert (self);
|
3495
|
+
zsock_set_sndhwm (self, 1);
|
3496
|
+
assert (zsock_sndhwm (self) == 1);
|
3497
|
+
zsock_sndhwm (self);
|
3498
|
+
zsock_destroy (&self);
|
3499
|
+
# endif
|
3500
|
+
# if defined (ZMQ_RCVHWM)
|
3501
|
+
self = zsock_new (ZMQ_SUB);
|
3502
|
+
assert (self);
|
3503
|
+
zsock_set_rcvhwm (self, 1);
|
3504
|
+
assert (zsock_rcvhwm (self) == 1);
|
3505
|
+
zsock_rcvhwm (self);
|
3506
|
+
zsock_destroy (&self);
|
3507
|
+
# endif
|
3508
|
+
# if defined (ZMQ_AFFINITY)
|
3509
|
+
self = zsock_new (ZMQ_SUB);
|
3510
|
+
assert (self);
|
3511
|
+
zsock_set_affinity (self, 1);
|
3512
|
+
assert (zsock_affinity (self) == 1);
|
3513
|
+
zsock_affinity (self);
|
3514
|
+
zsock_destroy (&self);
|
3515
|
+
# endif
|
3516
|
+
# if defined (ZMQ_SUBSCRIBE)
|
3517
|
+
self = zsock_new (ZMQ_SUB);
|
3518
|
+
assert (self);
|
3519
|
+
zsock_set_subscribe (self, "test");
|
3520
|
+
zsock_destroy (&self);
|
3521
|
+
# endif
|
3522
|
+
# if defined (ZMQ_UNSUBSCRIBE)
|
3523
|
+
self = zsock_new (ZMQ_SUB);
|
3524
|
+
assert (self);
|
3525
|
+
zsock_set_unsubscribe (self, "test");
|
3526
|
+
zsock_destroy (&self);
|
3527
|
+
# endif
|
3528
|
+
# if defined (ZMQ_IDENTITY)
|
3529
|
+
self = zsock_new (ZMQ_DEALER);
|
3530
|
+
assert (self);
|
3531
|
+
zsock_set_identity (self, "test");
|
3532
|
+
char *identity = zsock_identity (self);
|
3533
|
+
assert (identity);
|
3534
|
+
free (identity);
|
3535
|
+
zsock_destroy (&self);
|
3536
|
+
# endif
|
3537
|
+
# if defined (ZMQ_RATE)
|
3538
|
+
self = zsock_new (ZMQ_SUB);
|
3539
|
+
assert (self);
|
3540
|
+
zsock_set_rate (self, 1);
|
3541
|
+
assert (zsock_rate (self) == 1);
|
3542
|
+
zsock_rate (self);
|
3543
|
+
zsock_destroy (&self);
|
3544
|
+
# endif
|
3545
|
+
# if defined (ZMQ_RECOVERY_IVL)
|
3546
|
+
self = zsock_new (ZMQ_SUB);
|
3547
|
+
assert (self);
|
3548
|
+
zsock_set_recovery_ivl (self, 1);
|
3549
|
+
assert (zsock_recovery_ivl (self) == 1);
|
3550
|
+
zsock_recovery_ivl (self);
|
3551
|
+
zsock_destroy (&self);
|
3552
|
+
# endif
|
3553
|
+
# if defined (ZMQ_SNDBUF)
|
3554
|
+
self = zsock_new (ZMQ_PUB);
|
3555
|
+
assert (self);
|
3556
|
+
zsock_set_sndbuf (self, 1);
|
3557
|
+
assert (zsock_sndbuf (self) == 1);
|
3558
|
+
zsock_sndbuf (self);
|
3559
|
+
zsock_destroy (&self);
|
3560
|
+
# endif
|
3561
|
+
# if defined (ZMQ_RCVBUF)
|
3562
|
+
self = zsock_new (ZMQ_SUB);
|
3563
|
+
assert (self);
|
3564
|
+
zsock_set_rcvbuf (self, 1);
|
3565
|
+
assert (zsock_rcvbuf (self) == 1);
|
3566
|
+
zsock_rcvbuf (self);
|
3567
|
+
zsock_destroy (&self);
|
3568
|
+
# endif
|
3569
|
+
# if defined (ZMQ_LINGER)
|
3570
|
+
self = zsock_new (ZMQ_SUB);
|
3571
|
+
assert (self);
|
3572
|
+
zsock_set_linger (self, 1);
|
3573
|
+
assert (zsock_linger (self) == 1);
|
3574
|
+
zsock_linger (self);
|
3575
|
+
zsock_destroy (&self);
|
3576
|
+
# endif
|
3577
|
+
# if defined (ZMQ_RECONNECT_IVL)
|
3578
|
+
self = zsock_new (ZMQ_SUB);
|
3579
|
+
assert (self);
|
3580
|
+
zsock_set_reconnect_ivl (self, 1);
|
3581
|
+
assert (zsock_reconnect_ivl (self) == 1);
|
3582
|
+
zsock_reconnect_ivl (self);
|
3583
|
+
zsock_destroy (&self);
|
3584
|
+
# endif
|
3585
|
+
# if defined (ZMQ_RECONNECT_IVL_MAX)
|
3586
|
+
self = zsock_new (ZMQ_SUB);
|
3587
|
+
assert (self);
|
3588
|
+
zsock_set_reconnect_ivl_max (self, 1);
|
3589
|
+
assert (zsock_reconnect_ivl_max (self) == 1);
|
3590
|
+
zsock_reconnect_ivl_max (self);
|
3591
|
+
zsock_destroy (&self);
|
3592
|
+
# endif
|
3593
|
+
# if defined (ZMQ_BACKLOG)
|
3594
|
+
self = zsock_new (ZMQ_SUB);
|
3595
|
+
assert (self);
|
3596
|
+
zsock_set_backlog (self, 1);
|
3597
|
+
assert (zsock_backlog (self) == 1);
|
3598
|
+
zsock_backlog (self);
|
3599
|
+
zsock_destroy (&self);
|
3600
|
+
# endif
|
3601
|
+
# if defined (ZMQ_MAXMSGSIZE)
|
3602
|
+
self = zsock_new (ZMQ_SUB);
|
3603
|
+
assert (self);
|
3604
|
+
zsock_set_maxmsgsize (self, 1);
|
3605
|
+
assert (zsock_maxmsgsize (self) == 1);
|
3606
|
+
zsock_maxmsgsize (self);
|
3607
|
+
zsock_destroy (&self);
|
3608
|
+
# endif
|
3609
|
+
# if defined (ZMQ_MULTICAST_HOPS)
|
3610
|
+
self = zsock_new (ZMQ_SUB);
|
3611
|
+
assert (self);
|
3612
|
+
zsock_set_multicast_hops (self, 1);
|
3613
|
+
assert (zsock_multicast_hops (self) == 1);
|
3614
|
+
zsock_multicast_hops (self);
|
3615
|
+
zsock_destroy (&self);
|
3616
|
+
# endif
|
3617
|
+
# if defined (ZMQ_RCVTIMEO)
|
3618
|
+
self = zsock_new (ZMQ_SUB);
|
3619
|
+
assert (self);
|
3620
|
+
zsock_set_rcvtimeo (self, 1);
|
3621
|
+
assert (zsock_rcvtimeo (self) == 1);
|
3622
|
+
zsock_rcvtimeo (self);
|
3623
|
+
zsock_destroy (&self);
|
3624
|
+
# endif
|
3625
|
+
# if defined (ZMQ_SNDTIMEO)
|
3626
|
+
self = zsock_new (ZMQ_SUB);
|
3627
|
+
assert (self);
|
3628
|
+
zsock_set_sndtimeo (self, 1);
|
3629
|
+
assert (zsock_sndtimeo (self) == 1);
|
3630
|
+
zsock_sndtimeo (self);
|
3631
|
+
zsock_destroy (&self);
|
3632
|
+
# endif
|
3633
|
+
# if defined (ZMQ_XPUB_VERBOSE)
|
3634
|
+
self = zsock_new (ZMQ_XPUB);
|
3635
|
+
assert (self);
|
3636
|
+
zsock_set_xpub_verbose (self, 1);
|
3637
|
+
zsock_destroy (&self);
|
3638
|
+
# endif
|
3639
|
+
# if defined (ZMQ_TCP_KEEPALIVE)
|
3640
|
+
self = zsock_new (ZMQ_SUB);
|
3641
|
+
assert (self);
|
3642
|
+
zsock_set_tcp_keepalive (self, 1);
|
3643
|
+
assert (zsock_tcp_keepalive (self) == 1);
|
3644
|
+
zsock_tcp_keepalive (self);
|
3645
|
+
zsock_destroy (&self);
|
3646
|
+
# endif
|
3647
|
+
# if defined (ZMQ_TCP_KEEPALIVE_IDLE)
|
3648
|
+
self = zsock_new (ZMQ_SUB);
|
3649
|
+
assert (self);
|
3650
|
+
zsock_set_tcp_keepalive_idle (self, 1);
|
3651
|
+
assert (zsock_tcp_keepalive_idle (self) == 1);
|
3652
|
+
zsock_tcp_keepalive_idle (self);
|
3653
|
+
zsock_destroy (&self);
|
3654
|
+
# endif
|
3655
|
+
# if defined (ZMQ_TCP_KEEPALIVE_CNT)
|
3656
|
+
self = zsock_new (ZMQ_SUB);
|
3657
|
+
assert (self);
|
3658
|
+
zsock_set_tcp_keepalive_cnt (self, 1);
|
3659
|
+
assert (zsock_tcp_keepalive_cnt (self) == 1);
|
3660
|
+
zsock_tcp_keepalive_cnt (self);
|
3661
|
+
zsock_destroy (&self);
|
3662
|
+
# endif
|
3663
|
+
# if defined (ZMQ_TCP_KEEPALIVE_INTVL)
|
3664
|
+
self = zsock_new (ZMQ_SUB);
|
3665
|
+
assert (self);
|
3666
|
+
zsock_set_tcp_keepalive_intvl (self, 1);
|
3667
|
+
assert (zsock_tcp_keepalive_intvl (self) == 1);
|
3668
|
+
zsock_tcp_keepalive_intvl (self);
|
3669
|
+
zsock_destroy (&self);
|
3670
|
+
# endif
|
3671
|
+
# if defined (ZMQ_TCP_ACCEPT_FILTER)
|
3672
|
+
self = zsock_new (ZMQ_SUB);
|
3673
|
+
assert (self);
|
3674
|
+
zsock_set_tcp_accept_filter (self, "127.0.0.1");
|
3675
|
+
char *tcp_accept_filter = zsock_tcp_accept_filter (self);
|
3676
|
+
assert (tcp_accept_filter);
|
3677
|
+
free (tcp_accept_filter);
|
3678
|
+
zsock_destroy (&self);
|
3679
|
+
# endif
|
3680
|
+
# if defined (ZMQ_RCVMORE)
|
3681
|
+
self = zsock_new (ZMQ_SUB);
|
3682
|
+
assert (self);
|
3683
|
+
zsock_rcvmore (self);
|
3684
|
+
zsock_destroy (&self);
|
3685
|
+
# endif
|
3686
|
+
# if defined (ZMQ_FD)
|
3687
|
+
self = zsock_new (ZMQ_SUB);
|
3688
|
+
assert (self);
|
3689
|
+
zsock_fd (self);
|
3690
|
+
zsock_destroy (&self);
|
3691
|
+
# endif
|
3692
|
+
# if defined (ZMQ_EVENTS)
|
3693
|
+
self = zsock_new (ZMQ_SUB);
|
3694
|
+
assert (self);
|
3695
|
+
zsock_events (self);
|
3696
|
+
zsock_destroy (&self);
|
3697
|
+
# endif
|
3698
|
+
# if defined (ZMQ_LAST_ENDPOINT)
|
3699
|
+
self = zsock_new (ZMQ_SUB);
|
3700
|
+
assert (self);
|
3701
|
+
char *last_endpoint = zsock_last_endpoint (self);
|
3702
|
+
assert (last_endpoint);
|
3703
|
+
free (last_endpoint);
|
3704
|
+
zsock_destroy (&self);
|
3705
|
+
# endif
|
3706
|
+
#endif
|
3707
|
+
|
3708
|
+
#if (ZMQ_VERSION_MAJOR == 3)
|
3709
|
+
# if defined (ZMQ_ROUTER_RAW)
|
3710
|
+
self = zsock_new (ZMQ_ROUTER);
|
3711
|
+
assert (self);
|
3712
|
+
zsock_set_router_raw (self, 1);
|
3713
|
+
zsock_destroy (&self);
|
3714
|
+
# endif
|
3715
|
+
# if defined (ZMQ_IPV4ONLY)
|
3716
|
+
self = zsock_new (ZMQ_SUB);
|
3717
|
+
assert (self);
|
3718
|
+
zsock_set_ipv4only (self, 1);
|
3719
|
+
assert (zsock_ipv4only (self) == 1);
|
3720
|
+
zsock_ipv4only (self);
|
3721
|
+
zsock_destroy (&self);
|
3722
|
+
# endif
|
3723
|
+
# if defined (ZMQ_DELAY_ATTACH_ON_CONNECT)
|
3724
|
+
self = zsock_new (ZMQ_PUB);
|
3725
|
+
assert (self);
|
3726
|
+
zsock_set_delay_attach_on_connect (self, 1);
|
3727
|
+
zsock_destroy (&self);
|
3728
|
+
# endif
|
3729
|
+
# if defined (ZMQ_TYPE)
|
3730
|
+
self = zsock_new (ZMQ_SUB);
|
3731
|
+
assert (self);
|
3732
|
+
zsock_type (self);
|
3733
|
+
zsock_destroy (&self);
|
3734
|
+
# endif
|
3735
|
+
# if defined (ZMQ_SNDHWM)
|
3736
|
+
self = zsock_new (ZMQ_PUB);
|
3737
|
+
assert (self);
|
3738
|
+
zsock_set_sndhwm (self, 1);
|
3739
|
+
assert (zsock_sndhwm (self) == 1);
|
3740
|
+
zsock_sndhwm (self);
|
3741
|
+
zsock_destroy (&self);
|
3742
|
+
# endif
|
3743
|
+
# if defined (ZMQ_RCVHWM)
|
3744
|
+
self = zsock_new (ZMQ_SUB);
|
3745
|
+
assert (self);
|
3746
|
+
zsock_set_rcvhwm (self, 1);
|
3747
|
+
assert (zsock_rcvhwm (self) == 1);
|
3748
|
+
zsock_rcvhwm (self);
|
3749
|
+
zsock_destroy (&self);
|
3750
|
+
# endif
|
3751
|
+
# if defined (ZMQ_AFFINITY)
|
3752
|
+
self = zsock_new (ZMQ_SUB);
|
3753
|
+
assert (self);
|
3754
|
+
zsock_set_affinity (self, 1);
|
3755
|
+
assert (zsock_affinity (self) == 1);
|
3756
|
+
zsock_affinity (self);
|
3757
|
+
zsock_destroy (&self);
|
3758
|
+
# endif
|
3759
|
+
# if defined (ZMQ_SUBSCRIBE)
|
3760
|
+
self = zsock_new (ZMQ_SUB);
|
3761
|
+
assert (self);
|
3762
|
+
zsock_set_subscribe (self, "test");
|
3763
|
+
zsock_destroy (&self);
|
3764
|
+
# endif
|
3765
|
+
# if defined (ZMQ_UNSUBSCRIBE)
|
3766
|
+
self = zsock_new (ZMQ_SUB);
|
3767
|
+
assert (self);
|
3768
|
+
zsock_set_unsubscribe (self, "test");
|
3769
|
+
zsock_destroy (&self);
|
3770
|
+
# endif
|
3771
|
+
# if defined (ZMQ_IDENTITY)
|
3772
|
+
self = zsock_new (ZMQ_DEALER);
|
3773
|
+
assert (self);
|
3774
|
+
zsock_set_identity (self, "test");
|
3775
|
+
char *identity = zsock_identity (self);
|
3776
|
+
assert (identity);
|
3777
|
+
free (identity);
|
3778
|
+
zsock_destroy (&self);
|
3779
|
+
# endif
|
3780
|
+
# if defined (ZMQ_RATE)
|
3781
|
+
self = zsock_new (ZMQ_SUB);
|
3782
|
+
assert (self);
|
3783
|
+
zsock_set_rate (self, 1);
|
3784
|
+
assert (zsock_rate (self) == 1);
|
3785
|
+
zsock_rate (self);
|
3786
|
+
zsock_destroy (&self);
|
3787
|
+
# endif
|
3788
|
+
# if defined (ZMQ_RECOVERY_IVL)
|
3789
|
+
self = zsock_new (ZMQ_SUB);
|
3790
|
+
assert (self);
|
3791
|
+
zsock_set_recovery_ivl (self, 1);
|
3792
|
+
assert (zsock_recovery_ivl (self) == 1);
|
3793
|
+
zsock_recovery_ivl (self);
|
3794
|
+
zsock_destroy (&self);
|
3795
|
+
# endif
|
3796
|
+
# if defined (ZMQ_SNDBUF)
|
3797
|
+
self = zsock_new (ZMQ_PUB);
|
3798
|
+
assert (self);
|
3799
|
+
zsock_set_sndbuf (self, 1);
|
3800
|
+
assert (zsock_sndbuf (self) == 1);
|
3801
|
+
zsock_sndbuf (self);
|
3802
|
+
zsock_destroy (&self);
|
3803
|
+
# endif
|
3804
|
+
# if defined (ZMQ_RCVBUF)
|
3805
|
+
self = zsock_new (ZMQ_SUB);
|
3806
|
+
assert (self);
|
3807
|
+
zsock_set_rcvbuf (self, 1);
|
3808
|
+
assert (zsock_rcvbuf (self) == 1);
|
3809
|
+
zsock_rcvbuf (self);
|
3810
|
+
zsock_destroy (&self);
|
3811
|
+
# endif
|
3812
|
+
# if defined (ZMQ_LINGER)
|
3813
|
+
self = zsock_new (ZMQ_SUB);
|
3814
|
+
assert (self);
|
3815
|
+
zsock_set_linger (self, 1);
|
3816
|
+
assert (zsock_linger (self) == 1);
|
3817
|
+
zsock_linger (self);
|
3818
|
+
zsock_destroy (&self);
|
3819
|
+
# endif
|
3820
|
+
# if defined (ZMQ_RECONNECT_IVL)
|
3821
|
+
self = zsock_new (ZMQ_SUB);
|
3822
|
+
assert (self);
|
3823
|
+
zsock_set_reconnect_ivl (self, 1);
|
3824
|
+
assert (zsock_reconnect_ivl (self) == 1);
|
3825
|
+
zsock_reconnect_ivl (self);
|
3826
|
+
zsock_destroy (&self);
|
3827
|
+
# endif
|
3828
|
+
# if defined (ZMQ_RECONNECT_IVL_MAX)
|
3829
|
+
self = zsock_new (ZMQ_SUB);
|
3830
|
+
assert (self);
|
3831
|
+
zsock_set_reconnect_ivl_max (self, 1);
|
3832
|
+
assert (zsock_reconnect_ivl_max (self) == 1);
|
3833
|
+
zsock_reconnect_ivl_max (self);
|
3834
|
+
zsock_destroy (&self);
|
3835
|
+
# endif
|
3836
|
+
# if defined (ZMQ_BACKLOG)
|
3837
|
+
self = zsock_new (ZMQ_SUB);
|
3838
|
+
assert (self);
|
3839
|
+
zsock_set_backlog (self, 1);
|
3840
|
+
assert (zsock_backlog (self) == 1);
|
3841
|
+
zsock_backlog (self);
|
3842
|
+
zsock_destroy (&self);
|
3843
|
+
# endif
|
3844
|
+
# if defined (ZMQ_MAXMSGSIZE)
|
3845
|
+
self = zsock_new (ZMQ_SUB);
|
3846
|
+
assert (self);
|
3847
|
+
zsock_set_maxmsgsize (self, 1);
|
3848
|
+
assert (zsock_maxmsgsize (self) == 1);
|
3849
|
+
zsock_maxmsgsize (self);
|
3850
|
+
zsock_destroy (&self);
|
3851
|
+
# endif
|
3852
|
+
# if defined (ZMQ_MULTICAST_HOPS)
|
3853
|
+
self = zsock_new (ZMQ_SUB);
|
3854
|
+
assert (self);
|
3855
|
+
zsock_set_multicast_hops (self, 1);
|
3856
|
+
assert (zsock_multicast_hops (self) == 1);
|
3857
|
+
zsock_multicast_hops (self);
|
3858
|
+
zsock_destroy (&self);
|
3859
|
+
# endif
|
3860
|
+
# if defined (ZMQ_RCVTIMEO)
|
3861
|
+
self = zsock_new (ZMQ_SUB);
|
3862
|
+
assert (self);
|
3863
|
+
zsock_set_rcvtimeo (self, 1);
|
3864
|
+
assert (zsock_rcvtimeo (self) == 1);
|
3865
|
+
zsock_rcvtimeo (self);
|
3866
|
+
zsock_destroy (&self);
|
3867
|
+
# endif
|
3868
|
+
# if defined (ZMQ_SNDTIMEO)
|
3869
|
+
self = zsock_new (ZMQ_SUB);
|
3870
|
+
assert (self);
|
3871
|
+
zsock_set_sndtimeo (self, 1);
|
3872
|
+
assert (zsock_sndtimeo (self) == 1);
|
3873
|
+
zsock_sndtimeo (self);
|
3874
|
+
zsock_destroy (&self);
|
3875
|
+
# endif
|
3876
|
+
# if defined (ZMQ_XPUB_VERBOSE)
|
3877
|
+
self = zsock_new (ZMQ_XPUB);
|
3878
|
+
assert (self);
|
3879
|
+
zsock_set_xpub_verbose (self, 1);
|
3880
|
+
zsock_destroy (&self);
|
3881
|
+
# endif
|
3882
|
+
# if defined (ZMQ_TCP_KEEPALIVE)
|
3883
|
+
self = zsock_new (ZMQ_SUB);
|
3884
|
+
assert (self);
|
3885
|
+
zsock_set_tcp_keepalive (self, 1);
|
3886
|
+
assert (zsock_tcp_keepalive (self) == 1);
|
3887
|
+
zsock_tcp_keepalive (self);
|
3888
|
+
zsock_destroy (&self);
|
3889
|
+
# endif
|
3890
|
+
# if defined (ZMQ_TCP_KEEPALIVE_IDLE)
|
3891
|
+
self = zsock_new (ZMQ_SUB);
|
3892
|
+
assert (self);
|
3893
|
+
zsock_set_tcp_keepalive_idle (self, 1);
|
3894
|
+
assert (zsock_tcp_keepalive_idle (self) == 1);
|
3895
|
+
zsock_tcp_keepalive_idle (self);
|
3896
|
+
zsock_destroy (&self);
|
3897
|
+
# endif
|
3898
|
+
# if defined (ZMQ_TCP_KEEPALIVE_CNT)
|
3899
|
+
self = zsock_new (ZMQ_SUB);
|
3900
|
+
assert (self);
|
3901
|
+
zsock_set_tcp_keepalive_cnt (self, 1);
|
3902
|
+
assert (zsock_tcp_keepalive_cnt (self) == 1);
|
3903
|
+
zsock_tcp_keepalive_cnt (self);
|
3904
|
+
zsock_destroy (&self);
|
3905
|
+
# endif
|
3906
|
+
# if defined (ZMQ_TCP_KEEPALIVE_INTVL)
|
3907
|
+
self = zsock_new (ZMQ_SUB);
|
3908
|
+
assert (self);
|
3909
|
+
zsock_set_tcp_keepalive_intvl (self, 1);
|
3910
|
+
assert (zsock_tcp_keepalive_intvl (self) == 1);
|
3911
|
+
zsock_tcp_keepalive_intvl (self);
|
3912
|
+
zsock_destroy (&self);
|
3913
|
+
# endif
|
3914
|
+
# if defined (ZMQ_TCP_ACCEPT_FILTER)
|
3915
|
+
self = zsock_new (ZMQ_SUB);
|
3916
|
+
assert (self);
|
3917
|
+
zsock_set_tcp_accept_filter (self, "127.0.0.1");
|
3918
|
+
char *tcp_accept_filter = zsock_tcp_accept_filter (self);
|
3919
|
+
assert (tcp_accept_filter);
|
3920
|
+
free (tcp_accept_filter);
|
3921
|
+
zsock_destroy (&self);
|
3922
|
+
# endif
|
3923
|
+
# if defined (ZMQ_RCVMORE)
|
3924
|
+
self = zsock_new (ZMQ_SUB);
|
3925
|
+
assert (self);
|
3926
|
+
zsock_rcvmore (self);
|
3927
|
+
zsock_destroy (&self);
|
3928
|
+
# endif
|
3929
|
+
# if defined (ZMQ_FD)
|
3930
|
+
self = zsock_new (ZMQ_SUB);
|
3931
|
+
assert (self);
|
3932
|
+
zsock_fd (self);
|
3933
|
+
zsock_destroy (&self);
|
3934
|
+
# endif
|
3935
|
+
# if defined (ZMQ_EVENTS)
|
3936
|
+
self = zsock_new (ZMQ_SUB);
|
3937
|
+
assert (self);
|
3938
|
+
zsock_events (self);
|
3939
|
+
zsock_destroy (&self);
|
3940
|
+
# endif
|
3941
|
+
# if defined (ZMQ_LAST_ENDPOINT)
|
3942
|
+
self = zsock_new (ZMQ_SUB);
|
3943
|
+
assert (self);
|
3944
|
+
char *last_endpoint = zsock_last_endpoint (self);
|
3945
|
+
assert (last_endpoint);
|
3946
|
+
free (last_endpoint);
|
3947
|
+
zsock_destroy (&self);
|
3948
|
+
# endif
|
3949
|
+
#endif
|
3950
|
+
|
3951
|
+
#if (ZMQ_VERSION_MAJOR == 2)
|
3952
|
+
# if defined (ZMQ_HWM)
|
3953
|
+
self = zsock_new (ZMQ_SUB);
|
3954
|
+
assert (self);
|
3955
|
+
zsock_set_hwm (self, 1);
|
3956
|
+
assert (zsock_hwm (self) == 1);
|
3957
|
+
zsock_hwm (self);
|
3958
|
+
zsock_destroy (&self);
|
3959
|
+
# endif
|
3960
|
+
# if defined (ZMQ_SWAP)
|
3961
|
+
self = zsock_new (ZMQ_SUB);
|
3962
|
+
assert (self);
|
3963
|
+
zsock_set_swap (self, 1);
|
3964
|
+
assert (zsock_swap (self) == 1);
|
3965
|
+
zsock_swap (self);
|
3966
|
+
zsock_destroy (&self);
|
3967
|
+
# endif
|
3968
|
+
# if defined (ZMQ_AFFINITY)
|
3969
|
+
self = zsock_new (ZMQ_SUB);
|
3970
|
+
assert (self);
|
3971
|
+
zsock_set_affinity (self, 1);
|
3972
|
+
assert (zsock_affinity (self) == 1);
|
3973
|
+
zsock_affinity (self);
|
3974
|
+
zsock_destroy (&self);
|
3975
|
+
# endif
|
3976
|
+
# if defined (ZMQ_IDENTITY)
|
3977
|
+
self = zsock_new (ZMQ_SUB);
|
3978
|
+
assert (self);
|
3979
|
+
zsock_set_identity (self, "test");
|
3980
|
+
char *identity = zsock_identity (self);
|
3981
|
+
assert (identity);
|
3982
|
+
free (identity);
|
3983
|
+
zsock_destroy (&self);
|
3984
|
+
# endif
|
3985
|
+
# if defined (ZMQ_RATE)
|
3986
|
+
self = zsock_new (ZMQ_SUB);
|
3987
|
+
assert (self);
|
3988
|
+
zsock_set_rate (self, 1);
|
3989
|
+
assert (zsock_rate (self) == 1);
|
3990
|
+
zsock_rate (self);
|
3991
|
+
zsock_destroy (&self);
|
3992
|
+
# endif
|
3993
|
+
# if defined (ZMQ_RECOVERY_IVL)
|
3994
|
+
self = zsock_new (ZMQ_SUB);
|
3995
|
+
assert (self);
|
3996
|
+
zsock_set_recovery_ivl (self, 1);
|
3997
|
+
assert (zsock_recovery_ivl (self) == 1);
|
3998
|
+
zsock_recovery_ivl (self);
|
3999
|
+
zsock_destroy (&self);
|
4000
|
+
# endif
|
4001
|
+
# if defined (ZMQ_RECOVERY_IVL_MSEC)
|
4002
|
+
self = zsock_new (ZMQ_SUB);
|
4003
|
+
assert (self);
|
4004
|
+
zsock_set_recovery_ivl_msec (self, 1);
|
4005
|
+
assert (zsock_recovery_ivl_msec (self) == 1);
|
4006
|
+
zsock_recovery_ivl_msec (self);
|
4007
|
+
zsock_destroy (&self);
|
4008
|
+
# endif
|
4009
|
+
# if defined (ZMQ_MCAST_LOOP)
|
4010
|
+
self = zsock_new (ZMQ_SUB);
|
4011
|
+
assert (self);
|
4012
|
+
zsock_set_mcast_loop (self, 1);
|
4013
|
+
assert (zsock_mcast_loop (self) == 1);
|
4014
|
+
zsock_mcast_loop (self);
|
4015
|
+
zsock_destroy (&self);
|
4016
|
+
# endif
|
4017
|
+
# if (ZMQ_VERSION_MINOR == 2)
|
4018
|
+
# if defined (ZMQ_RCVTIMEO)
|
4019
|
+
self = zsock_new (ZMQ_SUB);
|
4020
|
+
assert (self);
|
4021
|
+
zsock_set_rcvtimeo (self, 1);
|
4022
|
+
assert (zsock_rcvtimeo (self) == 1);
|
4023
|
+
zsock_rcvtimeo (self);
|
4024
|
+
zsock_destroy (&self);
|
4025
|
+
# endif
|
4026
|
+
# endif
|
4027
|
+
# if (ZMQ_VERSION_MINOR == 2)
|
4028
|
+
# if defined (ZMQ_SNDTIMEO)
|
4029
|
+
self = zsock_new (ZMQ_SUB);
|
4030
|
+
assert (self);
|
4031
|
+
zsock_set_sndtimeo (self, 1);
|
4032
|
+
assert (zsock_sndtimeo (self) == 1);
|
4033
|
+
zsock_sndtimeo (self);
|
4034
|
+
zsock_destroy (&self);
|
4035
|
+
# endif
|
4036
|
+
# endif
|
4037
|
+
# if defined (ZMQ_SNDBUF)
|
4038
|
+
self = zsock_new (ZMQ_SUB);
|
4039
|
+
assert (self);
|
4040
|
+
zsock_set_sndbuf (self, 1);
|
4041
|
+
assert (zsock_sndbuf (self) == 1);
|
4042
|
+
zsock_sndbuf (self);
|
4043
|
+
zsock_destroy (&self);
|
4044
|
+
# endif
|
4045
|
+
# if defined (ZMQ_RCVBUF)
|
4046
|
+
self = zsock_new (ZMQ_SUB);
|
4047
|
+
assert (self);
|
4048
|
+
zsock_set_rcvbuf (self, 1);
|
4049
|
+
assert (zsock_rcvbuf (self) == 1);
|
4050
|
+
zsock_rcvbuf (self);
|
4051
|
+
zsock_destroy (&self);
|
4052
|
+
# endif
|
4053
|
+
# if defined (ZMQ_LINGER)
|
4054
|
+
self = zsock_new (ZMQ_SUB);
|
4055
|
+
assert (self);
|
4056
|
+
zsock_set_linger (self, 1);
|
4057
|
+
assert (zsock_linger (self) == 1);
|
4058
|
+
zsock_linger (self);
|
4059
|
+
zsock_destroy (&self);
|
4060
|
+
# endif
|
4061
|
+
# if defined (ZMQ_RECONNECT_IVL)
|
4062
|
+
self = zsock_new (ZMQ_SUB);
|
4063
|
+
assert (self);
|
4064
|
+
zsock_set_reconnect_ivl (self, 1);
|
4065
|
+
assert (zsock_reconnect_ivl (self) == 1);
|
4066
|
+
zsock_reconnect_ivl (self);
|
4067
|
+
zsock_destroy (&self);
|
4068
|
+
# endif
|
4069
|
+
# if defined (ZMQ_RECONNECT_IVL_MAX)
|
4070
|
+
self = zsock_new (ZMQ_SUB);
|
4071
|
+
assert (self);
|
4072
|
+
zsock_set_reconnect_ivl_max (self, 1);
|
4073
|
+
assert (zsock_reconnect_ivl_max (self) == 1);
|
4074
|
+
zsock_reconnect_ivl_max (self);
|
4075
|
+
zsock_destroy (&self);
|
4076
|
+
# endif
|
4077
|
+
# if defined (ZMQ_BACKLOG)
|
4078
|
+
self = zsock_new (ZMQ_SUB);
|
4079
|
+
assert (self);
|
4080
|
+
zsock_set_backlog (self, 1);
|
4081
|
+
assert (zsock_backlog (self) == 1);
|
4082
|
+
zsock_backlog (self);
|
4083
|
+
zsock_destroy (&self);
|
4084
|
+
# endif
|
4085
|
+
# if defined (ZMQ_SUBSCRIBE)
|
4086
|
+
self = zsock_new (ZMQ_SUB);
|
4087
|
+
assert (self);
|
4088
|
+
zsock_set_subscribe (self, "test");
|
4089
|
+
zsock_destroy (&self);
|
4090
|
+
# endif
|
4091
|
+
# if defined (ZMQ_UNSUBSCRIBE)
|
4092
|
+
self = zsock_new (ZMQ_SUB);
|
4093
|
+
assert (self);
|
4094
|
+
zsock_set_unsubscribe (self, "test");
|
4095
|
+
zsock_destroy (&self);
|
4096
|
+
# endif
|
4097
|
+
# if defined (ZMQ_TYPE)
|
4098
|
+
self = zsock_new (ZMQ_SUB);
|
4099
|
+
assert (self);
|
4100
|
+
zsock_type (self);
|
4101
|
+
zsock_destroy (&self);
|
4102
|
+
# endif
|
4103
|
+
# if defined (ZMQ_RCVMORE)
|
4104
|
+
self = zsock_new (ZMQ_SUB);
|
4105
|
+
assert (self);
|
4106
|
+
zsock_rcvmore (self);
|
4107
|
+
zsock_destroy (&self);
|
4108
|
+
# endif
|
4109
|
+
# if defined (ZMQ_FD)
|
4110
|
+
self = zsock_new (ZMQ_SUB);
|
4111
|
+
assert (self);
|
4112
|
+
zsock_fd (self);
|
4113
|
+
zsock_destroy (&self);
|
4114
|
+
# endif
|
4115
|
+
# if defined (ZMQ_EVENTS)
|
4116
|
+
self = zsock_new (ZMQ_SUB);
|
4117
|
+
assert (self);
|
4118
|
+
zsock_events (self);
|
4119
|
+
zsock_destroy (&self);
|
4120
|
+
# endif
|
4121
|
+
#endif
|
4122
|
+
|
4123
|
+
// @end
|
4124
|
+
|
4125
|
+
printf ("OK\n");
|
4126
|
+
}
|