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.
Files changed (118) hide show
  1. checksums.yaml +7 -0
  2. data/AUTHORS +1 -0
  3. data/CHANGES.md +88 -0
  4. data/Gemfile +2 -0
  5. data/LICENSE +14 -0
  6. data/README.md +112 -0
  7. data/lib/czmq-ffi-gen.rb +7 -0
  8. data/lib/czmq-ffi-gen/czmq/ffi.rb +1210 -0
  9. data/lib/czmq-ffi-gen/czmq/ffi/version.rb +15 -0
  10. data/lib/czmq-ffi-gen/czmq/ffi/zactor.rb +186 -0
  11. data/lib/czmq-ffi-gen/czmq/ffi/zarmour.rb +286 -0
  12. data/lib/czmq-ffi-gen/czmq/ffi/zcert.rb +307 -0
  13. data/lib/czmq-ffi-gen/czmq/ffi/zcertstore.rb +222 -0
  14. data/lib/czmq-ffi-gen/czmq/ffi/zchunk.rb +388 -0
  15. data/lib/czmq-ffi-gen/czmq/ffi/zclock.rb +140 -0
  16. data/lib/czmq-ffi-gen/czmq/ffi/zconfig.rb +442 -0
  17. data/lib/czmq-ffi-gen/czmq/ffi/zdigest.rb +156 -0
  18. data/lib/czmq-ffi-gen/czmq/ffi/zdir.rb +283 -0
  19. data/lib/czmq-ffi-gen/czmq/ffi/zdir_patch.rb +194 -0
  20. data/lib/czmq-ffi-gen/czmq/ffi/zfile.rb +353 -0
  21. data/lib/czmq-ffi-gen/czmq/ffi/zframe.rb +359 -0
  22. data/lib/czmq-ffi-gen/czmq/ffi/zhash.rb +416 -0
  23. data/lib/czmq-ffi-gen/czmq/ffi/zhashx.rb +659 -0
  24. data/lib/czmq-ffi-gen/czmq/ffi/ziflist.rb +189 -0
  25. data/lib/czmq-ffi-gen/czmq/ffi/zlist.rb +365 -0
  26. data/lib/czmq-ffi-gen/czmq/ffi/zlistx.rb +478 -0
  27. data/lib/czmq-ffi-gen/czmq/ffi/zloop.rb +396 -0
  28. data/lib/czmq-ffi-gen/czmq/ffi/zmsg.rb +515 -0
  29. data/lib/czmq-ffi-gen/czmq/ffi/zpoller.rb +194 -0
  30. data/lib/czmq-ffi-gen/czmq/ffi/zproc.rb +294 -0
  31. data/lib/czmq-ffi-gen/czmq/ffi/zsock.rb +3479 -0
  32. data/lib/czmq-ffi-gen/czmq/ffi/zstr.rb +203 -0
  33. data/lib/czmq-ffi-gen/czmq/ffi/ztimerset.rb +203 -0
  34. data/lib/czmq-ffi-gen/czmq/ffi/ztrie.rb +221 -0
  35. data/lib/czmq-ffi-gen/czmq/ffi/zuuid.rb +227 -0
  36. data/lib/czmq-ffi-gen/errors.rb +12 -0
  37. data/lib/czmq-ffi-gen/gem_version.rb +5 -0
  38. data/lib/czmq-ffi-gen/legacy.rb +16 -0
  39. data/lib/czmq-ffi-gen/libzmq.rb +18 -0
  40. data/lib/czmq-ffi-gen/signals.rb +27 -0
  41. data/lib/czmq-ffi-gen/vendor.rb +5 -0
  42. data/lib/czmq-ffi-gen/versions.rb +19 -0
  43. data/vendor/local/bin/inproc_lat.exe +0 -0
  44. data/vendor/local/bin/inproc_thr.exe +0 -0
  45. data/vendor/local/bin/libczmq.dll +0 -0
  46. data/vendor/local/bin/libgcc_s_sjlj-1.dll +0 -0
  47. data/vendor/local/bin/libstdc++-6.dll +0 -0
  48. data/vendor/local/bin/libzmq.dll +0 -0
  49. data/vendor/local/bin/local_lat.exe +0 -0
  50. data/vendor/local/bin/local_thr.exe +0 -0
  51. data/vendor/local/bin/remote_lat.exe +0 -0
  52. data/vendor/local/bin/remote_thr.exe +0 -0
  53. data/vendor/local/include/czmq.h +31 -0
  54. data/vendor/local/include/czmq_library.h +199 -0
  55. data/vendor/local/include/czmq_prelude.h +641 -0
  56. data/vendor/local/include/readme.txt +83 -0
  57. data/vendor/local/include/sha1.h +76 -0
  58. data/vendor/local/include/sha1.inc_c +335 -0
  59. data/vendor/local/include/slre.h +92 -0
  60. data/vendor/local/include/slre.inc_c +660 -0
  61. data/vendor/local/include/zactor.h +76 -0
  62. data/vendor/local/include/zarmour.h +114 -0
  63. data/vendor/local/include/zauth.h +100 -0
  64. data/vendor/local/include/zauth_v2.h +88 -0
  65. data/vendor/local/include/zbeacon.h +86 -0
  66. data/vendor/local/include/zbeacon_v2.h +75 -0
  67. data/vendor/local/include/zcert.h +136 -0
  68. data/vendor/local/include/zcertstore.h +100 -0
  69. data/vendor/local/include/zchunk.h +163 -0
  70. data/vendor/local/include/zclock.h +73 -0
  71. data/vendor/local/include/zconfig.h +185 -0
  72. data/vendor/local/include/zctx.h +107 -0
  73. data/vendor/local/include/zdigest.h +65 -0
  74. data/vendor/local/include/zdir.h +149 -0
  75. data/vendor/local/include/zdir_patch.h +82 -0
  76. data/vendor/local/include/zfile.h +177 -0
  77. data/vendor/local/include/zframe.h +176 -0
  78. data/vendor/local/include/zgossip.h +95 -0
  79. data/vendor/local/include/zgossip_engine.inc +927 -0
  80. data/vendor/local/include/zgossip_msg.h +129 -0
  81. data/vendor/local/include/zhash.h +195 -0
  82. data/vendor/local/include/zhash_primes.inc +329 -0
  83. data/vendor/local/include/zhashx.h +298 -0
  84. data/vendor/local/include/ziflist.h +77 -0
  85. data/vendor/local/include/zlist.h +158 -0
  86. data/vendor/local/include/zlistx.h +205 -0
  87. data/vendor/local/include/zloop.h +168 -0
  88. data/vendor/local/include/zmonitor.h +73 -0
  89. data/vendor/local/include/zmonitor_v2.h +56 -0
  90. data/vendor/local/include/zmq.h +617 -0
  91. data/vendor/local/include/zmq_utils.h +48 -0
  92. data/vendor/local/include/zmsg.h +280 -0
  93. data/vendor/local/include/zmutex.h +55 -0
  94. data/vendor/local/include/zpoller.h +92 -0
  95. data/vendor/local/include/zproc.h +168 -0
  96. data/vendor/local/include/zproxy.h +111 -0
  97. data/vendor/local/include/zproxy_v2.h +62 -0
  98. data/vendor/local/include/zrex.h +82 -0
  99. data/vendor/local/include/zsock.h +912 -0
  100. data/vendor/local/include/zsock_option.inc +4126 -0
  101. data/vendor/local/include/zsocket.h +110 -0
  102. data/vendor/local/include/zsockopt.h +256 -0
  103. data/vendor/local/include/zstr.h +110 -0
  104. data/vendor/local/include/zsys.h +386 -0
  105. data/vendor/local/include/zthread.h +50 -0
  106. data/vendor/local/include/ztimerset.h +90 -0
  107. data/vendor/local/include/ztrie.h +106 -0
  108. data/vendor/local/include/zuuid.h +96 -0
  109. data/vendor/local/lib/libczmq.dll.a +0 -0
  110. data/vendor/local/lib/liblibzmq.dll.a +0 -0
  111. data/vendor/local/lib/libzmq-static.a +0 -0
  112. data/vendor/local/lib/pkgconfig/libczmq.pc +23 -0
  113. data/vendor/local/lib/pkgconfig/libzmq.pc +11 -0
  114. data/vendor/local/share/zmq/AUTHORS.txt +147 -0
  115. data/vendor/local/share/zmq/COPYING.LESSER.txt +181 -0
  116. data/vendor/local/share/zmq/COPYING.txt +674 -0
  117. data/vendor/local/share/zmq/NEWS.txt +978 -0
  118. 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
+ }