rbczmq 1.7.2 → 1.7.3

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MTFkZjRmNzg3MjRiYTliZmZkZjYxYTY0MTU1Y2M5NzM0ZDJhMWM1Yg==
+    OTFiODAyNWE1MjM4MGVlODE0YmIxMGQyYTIyOWM3ZDlkNTc0ZWVhMw==
   data.tar.gz: !binary |-
-    YWM5YTFmMTBhOWNmMjNjZWY0Y2EzZjM1NTM0MmI2NTc1MDI2MWIyZg==
-!binary "U0hBNTEy":
+    MjIzNzk5NzE5YWNhMmY3M2U2ODRmNmFmNzYxZmM2YzM4ZDJiMzJlOQ==
+SHA512:
   metadata.gz: !binary |-
-    NWM2NzNjZmIyN2I1MzAzMjAwNGZmZDZjNjZmMmU2OWJlNDYyMzRjN2RlNmEx
-    MTMwZTkwNTIxMjNmZWM5NzkxYjM2MzM4ZWNlNWRlNGI3NzY4MDQzOTViMmQx
-    NWNlMjQ3YWQ1NTVmMWU5MDk1NjVmNWRlOTA5Mjc4NGE2ZDBkODM=
+    NzNhNjFiZjRmNjllZjQyNmVjZjYzNGFmNTE2OGIxOThhNzUyY2NjMzA2NmE3
+    OGM1YzY4OTRkYzZhNDZmNjE3MzBmMTM0OTk5NzI5NzdkOTczOWQ5NWI0NjU0
+    Y2Q1ZDFmNGNjZDViYTIwZmY0YThlYjEyMTQ5ZjBmMGFiMWQ5OGU=
   data.tar.gz: !binary |-
-    MDc4OWZhNjQ0Njk1OTQ4ZDI5MDAxNGI0YjllNWQyNWUwMTllMGJlYjM4N2Fl
-    ZDQ3MDJlYzRlMDc4NWRiZjU1ZjVlODg0YTBhYjI3NTljOGFlOTc2NjBhN2Jh
-    NTgwYjcwNGJjZjI2NGExODcyZGMwZDFkMTNkOTI5OTlkYTU1Yzc=
+    ZDYxNTQ4MzgxNjhkY2I1OTg3ZTU2MTVkOTliZWQ1Yzg2YTZkNmIwMzU1NTlk
+    MmRkNGUyZGRiY2U4Zjk5NTRhZmU1N2U5ZWM3YTIyMzY5ODJmODUyY2FhMWU2
+    NTYwZWVlM2E2OTA3NzQ3MjU0YWZiNzMxYjI0ZThlMDY2ZTk5NDQ=

data/.gitmodules

@@ -1,6 +1,6 @@
 [submodule "ext/zeromq"]
 	path = ext/zeromq
-	url = https://github.com/zeromq/libzmq
+	url = https://github.com/zeromq/zeromq4-x
 [submodule "ext/czmq"]
 	path = ext/czmq
 	url = https://github.com/zeromq/czmq

data/CHANGELOG.rdoc

@@ -1,5 +1,9 @@
 = Changelog
 
+== 1.7.3 (November 11, 2013)
+
+* Add an array of poll items to ZMQ::Loop so that they are not garbage collected. #25
+
 == 1.7.2 (October 12, 2013)
 
 * Upgrade to libzmq 4.0.1 and czmq 2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rbczmq (1.7.1)
+    rbczmq (1.7.3)
 
 GEM
   remote: https://rubygems.org/

data/ext/czmq/model/sockopts.xml

@@ -4,7 +4,7 @@
      use 'gsl sockopts'
 -->
 <options script = "sockopts">
-    <version major = "4" style = "enum">
+    <version major = "4" style = "macro">
         <!-- New names for deprecated 3.x options -->
         <option name = "ipv6"              type = "int"    mode = "rw" test = "SUB" />
         <option name = "immediate"         type = "int"    mode = "w"  test = "DEALER" />

data/ext/czmq/src/zsockopt.c

@@ -48,8 +48,10 @@
 void
 zsocket_set_ipv6 (void *zocket, int ipv6)
 {
+#   if defined (ZMQ_IPV6)
     int rc = zmq_setsockopt (zocket, ZMQ_IPV6, &ipv6, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -60,10 +62,14 @@ zsocket_set_ipv6 (void *zocket, int ipv6)
 int 
 zsocket_ipv6 (void *zocket)
 {
+#   if defined (ZMQ_IPV6)
     int ipv6;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_IPV6, &ipv6, &option_len);
     return ipv6;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -74,8 +80,10 @@ zsocket_ipv6 (void *zocket)
 void
 zsocket_set_immediate (void *zocket, int immediate)
 {
+#   if defined (ZMQ_IMMEDIATE)
     int rc = zmq_setsockopt (zocket, ZMQ_IMMEDIATE, &immediate, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -86,12 +94,14 @@ zsocket_set_immediate (void *zocket, int immediate)
 void
 zsocket_set_router_raw (void *zocket, int router_raw)
 {
+#   if defined (ZMQ_ROUTER_RAW)
     if (zsocket_type (zocket) != ZMQ_ROUTER) {
         printf ("ZMQ_ROUTER_RAW is not valid on %s sockets\n", zsocket_type_str (zocket));
         assert (false);
     }
     int rc = zmq_setsockopt (zocket, ZMQ_ROUTER_RAW, &router_raw, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -102,8 +112,10 @@ zsocket_set_router_raw (void *zocket, int router_raw)
 void
 zsocket_set_ipv4only (void *zocket, int ipv4only)
 {
+#   if defined (ZMQ_IPV4ONLY)
     int rc = zmq_setsockopt (zocket, ZMQ_IPV4ONLY, &ipv4only, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -114,10 +126,14 @@ zsocket_set_ipv4only (void *zocket, int ipv4only)
 int 
 zsocket_ipv4only (void *zocket)
 {
+#   if defined (ZMQ_IPV4ONLY)
     int ipv4only;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_IPV4ONLY, &ipv4only, &option_len);
     return ipv4only;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -128,8 +144,10 @@ zsocket_ipv4only (void *zocket)
 void
 zsocket_set_delay_attach_on_connect (void *zocket, int delay_attach_on_connect)
 {
+#   if defined (ZMQ_DELAY_ATTACH_ON_CONNECT)
     int rc = zmq_setsockopt (zocket, ZMQ_DELAY_ATTACH_ON_CONNECT, &delay_attach_on_connect, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -140,12 +158,14 @@ zsocket_set_delay_attach_on_connect (void *zocket, int delay_attach_on_connect)
 void
 zsocket_set_router_mandatory (void *zocket, int router_mandatory)
 {
+#   if defined (ZMQ_ROUTER_MANDATORY)
     if (zsocket_type (zocket) != ZMQ_ROUTER) {
         printf ("ZMQ_ROUTER_MANDATORY is not valid on %s sockets\n", zsocket_type_str (zocket));
         assert (false);
     }
     int rc = zmq_setsockopt (zocket, ZMQ_ROUTER_MANDATORY, &router_mandatory, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -156,10 +176,14 @@ zsocket_set_router_mandatory (void *zocket, int router_mandatory)
 int 
 zsocket_probe_router (void *zocket)
 {
+#   if defined (ZMQ_PROBE_ROUTER)
     int probe_router;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_PROBE_ROUTER, &probe_router, &option_len);
     return probe_router;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -170,12 +194,14 @@ zsocket_probe_router (void *zocket)
 void
 zsocket_set_req_relaxed (void *zocket, int req_relaxed)
 {
+#   if defined (ZMQ_REQ_RELAXED)
     if (zsocket_type (zocket) != ZMQ_REQ) {
         printf ("ZMQ_REQ_RELAXED is not valid on %s sockets\n", zsocket_type_str (zocket));
         assert (false);
     }
     int rc = zmq_setsockopt (zocket, ZMQ_REQ_RELAXED, &req_relaxed, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -186,12 +212,14 @@ zsocket_set_req_relaxed (void *zocket, int req_relaxed)
 void
 zsocket_set_req_correlate (void *zocket, int req_correlate)
 {
+#   if defined (ZMQ_REQ_CORRELATE)
     if (zsocket_type (zocket) != ZMQ_REQ) {
         printf ("ZMQ_REQ_CORRELATE is not valid on %s sockets\n", zsocket_type_str (zocket));
         assert (false);
     }
     int rc = zmq_setsockopt (zocket, ZMQ_REQ_CORRELATE, &req_correlate, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -202,6 +230,7 @@ zsocket_set_req_correlate (void *zocket, int req_correlate)
 void
 zsocket_set_conflate (void *zocket, int conflate)
 {
+#   if defined (ZMQ_CONFLATE)
     if (zsocket_type (zocket) != ZMQ_PUSH
     &&  zsocket_type (zocket) != ZMQ_PULL
     &&  zsocket_type (zocket) != ZMQ_PUB
@@ -212,6 +241,7 @@ zsocket_set_conflate (void *zocket, int conflate)
     }
     int rc = zmq_setsockopt (zocket, ZMQ_CONFLATE, &conflate, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -222,8 +252,10 @@ zsocket_set_conflate (void *zocket, int conflate)
 void
 zsocket_set_plain_server (void *zocket, int plain_server)
 {
+#   if defined (ZMQ_PLAIN_SERVER)
     int rc = zmq_setsockopt (zocket, ZMQ_PLAIN_SERVER, &plain_server, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -234,10 +266,14 @@ zsocket_set_plain_server (void *zocket, int plain_server)
 int 
 zsocket_plain_server (void *zocket)
 {
+#   if defined (ZMQ_PLAIN_SERVER)
     int plain_server;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_PLAIN_SERVER, &plain_server, &option_len);
     return plain_server;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -248,8 +284,10 @@ zsocket_plain_server (void *zocket)
 void
 zsocket_set_plain_username (void *zocket, const char * plain_username)
 {
+#   if defined (ZMQ_PLAIN_USERNAME)
     int rc = zmq_setsockopt (zocket, ZMQ_PLAIN_USERNAME, plain_username, strlen (plain_username));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -260,10 +298,14 @@ zsocket_set_plain_username (void *zocket, const char * plain_username)
 char * 
 zsocket_plain_username (void *zocket)
 {
+#   if defined (ZMQ_PLAIN_USERNAME)
     size_t option_len = 255;
     char *plain_username = (char *) zmalloc (option_len);
     zmq_getsockopt (zocket, ZMQ_PLAIN_USERNAME, plain_username, &option_len);
     return (char *) plain_username;
+#   else
+    return NULL;
+#   endif
 }
 
 
@@ -274,8 +316,10 @@ zsocket_plain_username (void *zocket)
 void
 zsocket_set_plain_password (void *zocket, const char * plain_password)
 {
+#   if defined (ZMQ_PLAIN_PASSWORD)
     int rc = zmq_setsockopt (zocket, ZMQ_PLAIN_PASSWORD, plain_password, strlen (plain_password));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -286,10 +330,14 @@ zsocket_set_plain_password (void *zocket, const char * plain_password)
 char * 
 zsocket_plain_password (void *zocket)
 {
+#   if defined (ZMQ_PLAIN_PASSWORD)
     size_t option_len = 255;
     char *plain_password = (char *) zmalloc (option_len);
     zmq_getsockopt (zocket, ZMQ_PLAIN_PASSWORD, plain_password, &option_len);
     return (char *) plain_password;
+#   else
+    return NULL;
+#   endif
 }
 
 
@@ -300,10 +348,12 @@ zsocket_plain_password (void *zocket)
 void
 zsocket_set_curve_server (void *zocket, int curve_server)
 {
+#   if defined (ZMQ_CURVE_SERVER)
 #     if defined (HAVE_LIBSODIUM)
     int rc = zmq_setsockopt (zocket, ZMQ_CURVE_SERVER, &curve_server, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
 #     endif
+#   endif
 }
 
 
@@ -314,10 +364,14 @@ zsocket_set_curve_server (void *zocket, int curve_server)
 int 
 zsocket_curve_server (void *zocket)
 {
+#   if defined (ZMQ_CURVE_SERVER)
     int curve_server;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_CURVE_SERVER, &curve_server, &option_len);
     return curve_server;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -328,10 +382,12 @@ zsocket_curve_server (void *zocket)
 void
 zsocket_set_curve_publickey (void *zocket, const char * curve_publickey)
 {
+#   if defined (ZMQ_CURVE_PUBLICKEY)
 #     if defined (HAVE_LIBSODIUM)
     int rc = zmq_setsockopt (zocket, ZMQ_CURVE_PUBLICKEY, curve_publickey, strlen (curve_publickey));
     assert (rc == 0 || zmq_errno () == ETERM);
 #     endif
+#   endif
 }
 
 
@@ -342,10 +398,12 @@ zsocket_set_curve_publickey (void *zocket, const char * curve_publickey)
 void
 zsocket_set_curve_publickey_bin (void *zocket, const byte *curve_publickey)
 {
+#   if defined (ZMQ_CURVE_PUBLICKEY)
 #     if defined (HAVE_LIBSODIUM)
     int rc = zmq_setsockopt (zocket, ZMQ_CURVE_PUBLICKEY, curve_publickey, 32);
     assert (rc == 0 || zmq_errno () == ETERM);
 #     endif
+#   endif
 }
 
 
@@ -356,10 +414,14 @@ zsocket_set_curve_publickey_bin (void *zocket, const byte *curve_publickey)
 char * 
 zsocket_curve_publickey (void *zocket)
 {
+#   if defined (ZMQ_CURVE_PUBLICKEY)
     size_t option_len = 255;
     char *curve_publickey = (char *) zmalloc (option_len);
     zmq_getsockopt (zocket, ZMQ_CURVE_PUBLICKEY, curve_publickey, &option_len);
     return (char *) curve_publickey;
+#   else
+    return NULL;
+#   endif
 }
 
 
@@ -370,10 +432,12 @@ zsocket_curve_publickey (void *zocket)
 void
 zsocket_set_curve_secretkey (void *zocket, const char * curve_secretkey)
 {
+#   if defined (ZMQ_CURVE_SECRETKEY)
 #     if defined (HAVE_LIBSODIUM)
     int rc = zmq_setsockopt (zocket, ZMQ_CURVE_SECRETKEY, curve_secretkey, strlen (curve_secretkey));
     assert (rc == 0 || zmq_errno () == ETERM);
 #     endif
+#   endif
 }
 
 
@@ -384,10 +448,12 @@ zsocket_set_curve_secretkey (void *zocket, const char * curve_secretkey)
 void
 zsocket_set_curve_secretkey_bin (void *zocket, const byte *curve_secretkey)
 {
+#   if defined (ZMQ_CURVE_SECRETKEY)
 #     if defined (HAVE_LIBSODIUM)
     int rc = zmq_setsockopt (zocket, ZMQ_CURVE_SECRETKEY, curve_secretkey, 32);
     assert (rc == 0 || zmq_errno () == ETERM);
 #     endif
+#   endif
 }
 
 
@@ -398,10 +464,14 @@ zsocket_set_curve_secretkey_bin (void *zocket, const byte *curve_secretkey)
 char * 
 zsocket_curve_secretkey (void *zocket)
 {
+#   if defined (ZMQ_CURVE_SECRETKEY)
     size_t option_len = 255;
     char *curve_secretkey = (char *) zmalloc (option_len);
     zmq_getsockopt (zocket, ZMQ_CURVE_SECRETKEY, curve_secretkey, &option_len);
     return (char *) curve_secretkey;
+#   else
+    return NULL;
+#   endif
 }
 
 
@@ -412,10 +482,12 @@ zsocket_curve_secretkey (void *zocket)
 void
 zsocket_set_curve_serverkey (void *zocket, const char * curve_serverkey)
 {
+#   if defined (ZMQ_CURVE_SERVERKEY)
 #     if defined (HAVE_LIBSODIUM)
     int rc = zmq_setsockopt (zocket, ZMQ_CURVE_SERVERKEY, curve_serverkey, strlen (curve_serverkey));
     assert (rc == 0 || zmq_errno () == ETERM);
 #     endif
+#   endif
 }
 
 
@@ -426,10 +498,12 @@ zsocket_set_curve_serverkey (void *zocket, const char * curve_serverkey)
 void
 zsocket_set_curve_serverkey_bin (void *zocket, const byte *curve_serverkey)
 {
+#   if defined (ZMQ_CURVE_SERVERKEY)
 #     if defined (HAVE_LIBSODIUM)
     int rc = zmq_setsockopt (zocket, ZMQ_CURVE_SERVERKEY, curve_serverkey, 32);
     assert (rc == 0 || zmq_errno () == ETERM);
 #     endif
+#   endif
 }
 
 
@@ -440,10 +514,14 @@ zsocket_set_curve_serverkey_bin (void *zocket, const byte *curve_serverkey)
 char * 
 zsocket_curve_serverkey (void *zocket)
 {
+#   if defined (ZMQ_CURVE_SERVERKEY)
     size_t option_len = 255;
     char *curve_serverkey = (char *) zmalloc (option_len);
     zmq_getsockopt (zocket, ZMQ_CURVE_SERVERKEY, curve_serverkey, &option_len);
     return (char *) curve_serverkey;
+#   else
+    return NULL;
+#   endif
 }
 
 
@@ -454,8 +532,10 @@ zsocket_curve_serverkey (void *zocket)
 void
 zsocket_set_zap_domain (void *zocket, const char * zap_domain)
 {
+#   if defined (ZMQ_ZAP_DOMAIN)
     int rc = zmq_setsockopt (zocket, ZMQ_ZAP_DOMAIN, zap_domain, strlen (zap_domain));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -466,10 +546,14 @@ zsocket_set_zap_domain (void *zocket, const char * zap_domain)
 char * 
 zsocket_zap_domain (void *zocket)
 {
+#   if defined (ZMQ_ZAP_DOMAIN)
     size_t option_len = 255;
     char *zap_domain = (char *) zmalloc (option_len);
     zmq_getsockopt (zocket, ZMQ_ZAP_DOMAIN, zap_domain, &option_len);
     return (char *) zap_domain;
+#   else
+    return NULL;
+#   endif
 }
 
 
@@ -480,10 +564,14 @@ zsocket_zap_domain (void *zocket)
 int 
 zsocket_type (void *zocket)
 {
+#   if defined (ZMQ_TYPE)
     int type;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_TYPE, &type, &option_len);
     return type;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -494,8 +582,10 @@ zsocket_type (void *zocket)
 void
 zsocket_set_sndhwm (void *zocket, int sndhwm)
 {
+#   if defined (ZMQ_SNDHWM)
     int rc = zmq_setsockopt (zocket, ZMQ_SNDHWM, &sndhwm, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -506,10 +596,14 @@ zsocket_set_sndhwm (void *zocket, int sndhwm)
 int 
 zsocket_sndhwm (void *zocket)
 {
+#   if defined (ZMQ_SNDHWM)
     int sndhwm;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_SNDHWM, &sndhwm, &option_len);
     return sndhwm;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -520,8 +614,10 @@ zsocket_sndhwm (void *zocket)
 void
 zsocket_set_rcvhwm (void *zocket, int rcvhwm)
 {
+#   if defined (ZMQ_RCVHWM)
     int rc = zmq_setsockopt (zocket, ZMQ_RCVHWM, &rcvhwm, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -532,10 +628,14 @@ zsocket_set_rcvhwm (void *zocket, int rcvhwm)
 int 
 zsocket_rcvhwm (void *zocket)
 {
+#   if defined (ZMQ_RCVHWM)
     int rcvhwm;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_RCVHWM, &rcvhwm, &option_len);
     return rcvhwm;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -546,9 +646,11 @@ zsocket_rcvhwm (void *zocket)
 void
 zsocket_set_affinity (void *zocket, int affinity)
 {
+#   if defined (ZMQ_AFFINITY)
     uint64_t value = affinity;
     int rc = zmq_setsockopt (zocket, ZMQ_AFFINITY, &value, sizeof (uint64_t));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -559,10 +661,14 @@ zsocket_set_affinity (void *zocket, int affinity)
 int 
 zsocket_affinity (void *zocket)
 {
+#   if defined (ZMQ_AFFINITY)
     uint64_t affinity;
     size_t option_len = sizeof (uint64_t);
     zmq_getsockopt (zocket, ZMQ_AFFINITY, &affinity, &option_len);
     return (int) affinity;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -573,12 +679,14 @@ zsocket_affinity (void *zocket)
 void
 zsocket_set_subscribe (void *zocket, const char * subscribe)
 {
+#   if defined (ZMQ_SUBSCRIBE)
     if (zsocket_type (zocket) != ZMQ_SUB) {
         printf ("ZMQ_SUBSCRIBE is not valid on %s sockets\n", zsocket_type_str (zocket));
         assert (false);
     }
     int rc = zmq_setsockopt (zocket, ZMQ_SUBSCRIBE, subscribe, strlen (subscribe));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -589,12 +697,14 @@ zsocket_set_subscribe (void *zocket, const char * subscribe)
 void
 zsocket_set_unsubscribe (void *zocket, const char * unsubscribe)
 {
+#   if defined (ZMQ_UNSUBSCRIBE)
     if (zsocket_type (zocket) != ZMQ_SUB) {
         printf ("ZMQ_UNSUBSCRIBE is not valid on %s sockets\n", zsocket_type_str (zocket));
         assert (false);
     }
     int rc = zmq_setsockopt (zocket, ZMQ_UNSUBSCRIBE, unsubscribe, strlen (unsubscribe));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -605,6 +715,7 @@ zsocket_set_unsubscribe (void *zocket, const char * unsubscribe)
 void
 zsocket_set_identity (void *zocket, const char * identity)
 {
+#   if defined (ZMQ_IDENTITY)
     if (zsocket_type (zocket) != ZMQ_REQ
     &&  zsocket_type (zocket) != ZMQ_REP
     &&  zsocket_type (zocket) != ZMQ_DEALER
@@ -615,6 +726,7 @@ zsocket_set_identity (void *zocket, const char * identity)
     }
     int rc = zmq_setsockopt (zocket, ZMQ_IDENTITY, identity, strlen (identity));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -625,10 +737,14 @@ zsocket_set_identity (void *zocket, const char * identity)
 char * 
 zsocket_identity (void *zocket)
 {
+#   if defined (ZMQ_IDENTITY)
     size_t option_len = 255;
     char *identity = (char *) zmalloc (option_len);
     zmq_getsockopt (zocket, ZMQ_IDENTITY, identity, &option_len);
     return (char *) identity;
+#   else
+    return NULL;
+#   endif
 }
 
 
@@ -639,8 +755,10 @@ zsocket_identity (void *zocket)
 void
 zsocket_set_rate (void *zocket, int rate)
 {
+#   if defined (ZMQ_RATE)
     int rc = zmq_setsockopt (zocket, ZMQ_RATE, &rate, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -651,10 +769,14 @@ zsocket_set_rate (void *zocket, int rate)
 int 
 zsocket_rate (void *zocket)
 {
+#   if defined (ZMQ_RATE)
     int rate;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_RATE, &rate, &option_len);
     return rate;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -665,8 +787,10 @@ zsocket_rate (void *zocket)
 void
 zsocket_set_recovery_ivl (void *zocket, int recovery_ivl)
 {
+#   if defined (ZMQ_RECOVERY_IVL)
     int rc = zmq_setsockopt (zocket, ZMQ_RECOVERY_IVL, &recovery_ivl, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -677,10 +801,14 @@ zsocket_set_recovery_ivl (void *zocket, int recovery_ivl)
 int 
 zsocket_recovery_ivl (void *zocket)
 {
+#   if defined (ZMQ_RECOVERY_IVL)
     int recovery_ivl;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_RECOVERY_IVL, &recovery_ivl, &option_len);
     return recovery_ivl;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -691,8 +819,10 @@ zsocket_recovery_ivl (void *zocket)
 void
 zsocket_set_sndbuf (void *zocket, int sndbuf)
 {
+#   if defined (ZMQ_SNDBUF)
     int rc = zmq_setsockopt (zocket, ZMQ_SNDBUF, &sndbuf, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -703,10 +833,14 @@ zsocket_set_sndbuf (void *zocket, int sndbuf)
 int 
 zsocket_sndbuf (void *zocket)
 {
+#   if defined (ZMQ_SNDBUF)
     int sndbuf;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_SNDBUF, &sndbuf, &option_len);
     return sndbuf;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -717,8 +851,10 @@ zsocket_sndbuf (void *zocket)
 void
 zsocket_set_rcvbuf (void *zocket, int rcvbuf)
 {
+#   if defined (ZMQ_RCVBUF)
     int rc = zmq_setsockopt (zocket, ZMQ_RCVBUF, &rcvbuf, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -729,10 +865,14 @@ zsocket_set_rcvbuf (void *zocket, int rcvbuf)
 int 
 zsocket_rcvbuf (void *zocket)
 {
+#   if defined (ZMQ_RCVBUF)
     int rcvbuf;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_RCVBUF, &rcvbuf, &option_len);
     return rcvbuf;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -743,8 +883,10 @@ zsocket_rcvbuf (void *zocket)
 void
 zsocket_set_linger (void *zocket, int linger)
 {
+#   if defined (ZMQ_LINGER)
     int rc = zmq_setsockopt (zocket, ZMQ_LINGER, &linger, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -755,10 +897,14 @@ zsocket_set_linger (void *zocket, int linger)
 int 
 zsocket_linger (void *zocket)
 {
+#   if defined (ZMQ_LINGER)
     int linger;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_LINGER, &linger, &option_len);
     return linger;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -769,8 +915,10 @@ zsocket_linger (void *zocket)
 void
 zsocket_set_reconnect_ivl (void *zocket, int reconnect_ivl)
 {
+#   if defined (ZMQ_RECONNECT_IVL)
     int rc = zmq_setsockopt (zocket, ZMQ_RECONNECT_IVL, &reconnect_ivl, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -781,10 +929,14 @@ zsocket_set_reconnect_ivl (void *zocket, int reconnect_ivl)
 int 
 zsocket_reconnect_ivl (void *zocket)
 {
+#   if defined (ZMQ_RECONNECT_IVL)
     int reconnect_ivl;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_RECONNECT_IVL, &reconnect_ivl, &option_len);
     return reconnect_ivl;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -795,8 +947,10 @@ zsocket_reconnect_ivl (void *zocket)
 void
 zsocket_set_reconnect_ivl_max (void *zocket, int reconnect_ivl_max)
 {
+#   if defined (ZMQ_RECONNECT_IVL_MAX)
     int rc = zmq_setsockopt (zocket, ZMQ_RECONNECT_IVL_MAX, &reconnect_ivl_max, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -807,10 +961,14 @@ zsocket_set_reconnect_ivl_max (void *zocket, int reconnect_ivl_max)
 int 
 zsocket_reconnect_ivl_max (void *zocket)
 {
+#   if defined (ZMQ_RECONNECT_IVL_MAX)
     int reconnect_ivl_max;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_RECONNECT_IVL_MAX, &reconnect_ivl_max, &option_len);
     return reconnect_ivl_max;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -821,8 +979,10 @@ zsocket_reconnect_ivl_max (void *zocket)
 void
 zsocket_set_backlog (void *zocket, int backlog)
 {
+#   if defined (ZMQ_BACKLOG)
     int rc = zmq_setsockopt (zocket, ZMQ_BACKLOG, &backlog, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -833,10 +993,14 @@ zsocket_set_backlog (void *zocket, int backlog)
 int 
 zsocket_backlog (void *zocket)
 {
+#   if defined (ZMQ_BACKLOG)
     int backlog;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_BACKLOG, &backlog, &option_len);
     return backlog;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -847,9 +1011,11 @@ zsocket_backlog (void *zocket)
 void
 zsocket_set_maxmsgsize (void *zocket, int maxmsgsize)
 {
+#   if defined (ZMQ_MAXMSGSIZE)
     int64_t value = maxmsgsize;
     int rc = zmq_setsockopt (zocket, ZMQ_MAXMSGSIZE, &value, sizeof (int64_t));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -860,10 +1026,14 @@ zsocket_set_maxmsgsize (void *zocket, int maxmsgsize)
 int 
 zsocket_maxmsgsize (void *zocket)
 {
+#   if defined (ZMQ_MAXMSGSIZE)
     int64_t maxmsgsize;
     size_t option_len = sizeof (int64_t);
     zmq_getsockopt (zocket, ZMQ_MAXMSGSIZE, &maxmsgsize, &option_len);
     return (int) maxmsgsize;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -874,8 +1044,10 @@ zsocket_maxmsgsize (void *zocket)
 void
 zsocket_set_multicast_hops (void *zocket, int multicast_hops)
 {
+#   if defined (ZMQ_MULTICAST_HOPS)
     int rc = zmq_setsockopt (zocket, ZMQ_MULTICAST_HOPS, &multicast_hops, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -886,10 +1058,14 @@ zsocket_set_multicast_hops (void *zocket, int multicast_hops)
 int 
 zsocket_multicast_hops (void *zocket)
 {
+#   if defined (ZMQ_MULTICAST_HOPS)
     int multicast_hops;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_MULTICAST_HOPS, &multicast_hops, &option_len);
     return multicast_hops;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -900,8 +1076,10 @@ zsocket_multicast_hops (void *zocket)
 void
 zsocket_set_rcvtimeo (void *zocket, int rcvtimeo)
 {
+#   if defined (ZMQ_RCVTIMEO)
     int rc = zmq_setsockopt (zocket, ZMQ_RCVTIMEO, &rcvtimeo, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -912,10 +1090,14 @@ zsocket_set_rcvtimeo (void *zocket, int rcvtimeo)
 int 
 zsocket_rcvtimeo (void *zocket)
 {
+#   if defined (ZMQ_RCVTIMEO)
     int rcvtimeo;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_RCVTIMEO, &rcvtimeo, &option_len);
     return rcvtimeo;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -926,8 +1108,10 @@ zsocket_rcvtimeo (void *zocket)
 void
 zsocket_set_sndtimeo (void *zocket, int sndtimeo)
 {
+#   if defined (ZMQ_SNDTIMEO)
     int rc = zmq_setsockopt (zocket, ZMQ_SNDTIMEO, &sndtimeo, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -938,10 +1122,14 @@ zsocket_set_sndtimeo (void *zocket, int sndtimeo)
 int 
 zsocket_sndtimeo (void *zocket)
 {
+#   if defined (ZMQ_SNDTIMEO)
     int sndtimeo;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_SNDTIMEO, &sndtimeo, &option_len);
     return sndtimeo;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -952,12 +1140,14 @@ zsocket_sndtimeo (void *zocket)
 void
 zsocket_set_xpub_verbose (void *zocket, int xpub_verbose)
 {
+#   if defined (ZMQ_XPUB_VERBOSE)
     if (zsocket_type (zocket) != ZMQ_XPUB) {
         printf ("ZMQ_XPUB_VERBOSE is not valid on %s sockets\n", zsocket_type_str (zocket));
         assert (false);
     }
     int rc = zmq_setsockopt (zocket, ZMQ_XPUB_VERBOSE, &xpub_verbose, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -968,8 +1158,10 @@ zsocket_set_xpub_verbose (void *zocket, int xpub_verbose)
 void
 zsocket_set_tcp_keepalive (void *zocket, int tcp_keepalive)
 {
+#   if defined (ZMQ_TCP_KEEPALIVE)
     int rc = zmq_setsockopt (zocket, ZMQ_TCP_KEEPALIVE, &tcp_keepalive, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -980,10 +1172,14 @@ zsocket_set_tcp_keepalive (void *zocket, int tcp_keepalive)
 int 
 zsocket_tcp_keepalive (void *zocket)
 {
+#   if defined (ZMQ_TCP_KEEPALIVE)
     int tcp_keepalive;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_TCP_KEEPALIVE, &tcp_keepalive, &option_len);
     return tcp_keepalive;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -994,8 +1190,10 @@ zsocket_tcp_keepalive (void *zocket)
 void
 zsocket_set_tcp_keepalive_idle (void *zocket, int tcp_keepalive_idle)
 {
+#   if defined (ZMQ_TCP_KEEPALIVE_IDLE)
     int rc = zmq_setsockopt (zocket, ZMQ_TCP_KEEPALIVE_IDLE, &tcp_keepalive_idle, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -1006,10 +1204,14 @@ zsocket_set_tcp_keepalive_idle (void *zocket, int tcp_keepalive_idle)
 int 
 zsocket_tcp_keepalive_idle (void *zocket)
 {
+#   if defined (ZMQ_TCP_KEEPALIVE_IDLE)
     int tcp_keepalive_idle;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_TCP_KEEPALIVE_IDLE, &tcp_keepalive_idle, &option_len);
     return tcp_keepalive_idle;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -1020,8 +1222,10 @@ zsocket_tcp_keepalive_idle (void *zocket)
 void
 zsocket_set_tcp_keepalive_cnt (void *zocket, int tcp_keepalive_cnt)
 {
+#   if defined (ZMQ_TCP_KEEPALIVE_CNT)
     int rc = zmq_setsockopt (zocket, ZMQ_TCP_KEEPALIVE_CNT, &tcp_keepalive_cnt, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -1032,10 +1236,14 @@ zsocket_set_tcp_keepalive_cnt (void *zocket, int tcp_keepalive_cnt)
 int 
 zsocket_tcp_keepalive_cnt (void *zocket)
 {
+#   if defined (ZMQ_TCP_KEEPALIVE_CNT)
     int tcp_keepalive_cnt;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_TCP_KEEPALIVE_CNT, &tcp_keepalive_cnt, &option_len);
     return tcp_keepalive_cnt;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -1046,8 +1254,10 @@ zsocket_tcp_keepalive_cnt (void *zocket)
 void
 zsocket_set_tcp_keepalive_intvl (void *zocket, int tcp_keepalive_intvl)
 {
+#   if defined (ZMQ_TCP_KEEPALIVE_INTVL)
     int rc = zmq_setsockopt (zocket, ZMQ_TCP_KEEPALIVE_INTVL, &tcp_keepalive_intvl, sizeof (int));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -1058,10 +1268,14 @@ zsocket_set_tcp_keepalive_intvl (void *zocket, int tcp_keepalive_intvl)
 int 
 zsocket_tcp_keepalive_intvl (void *zocket)
 {
+#   if defined (ZMQ_TCP_KEEPALIVE_INTVL)
     int tcp_keepalive_intvl;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_TCP_KEEPALIVE_INTVL, &tcp_keepalive_intvl, &option_len);
     return tcp_keepalive_intvl;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -1072,8 +1286,10 @@ zsocket_tcp_keepalive_intvl (void *zocket)
 void
 zsocket_set_tcp_accept_filter (void *zocket, const char * tcp_accept_filter)
 {
+#   if defined (ZMQ_TCP_ACCEPT_FILTER)
     int rc = zmq_setsockopt (zocket, ZMQ_TCP_ACCEPT_FILTER, tcp_accept_filter, strlen (tcp_accept_filter));
     assert (rc == 0 || zmq_errno () == ETERM);
+#   endif
 }
 
 
@@ -1084,10 +1300,14 @@ zsocket_set_tcp_accept_filter (void *zocket, const char * tcp_accept_filter)
 char * 
 zsocket_tcp_accept_filter (void *zocket)
 {
+#   if defined (ZMQ_TCP_ACCEPT_FILTER)
     size_t option_len = 255;
     char *tcp_accept_filter = (char *) zmalloc (option_len);
     zmq_getsockopt (zocket, ZMQ_TCP_ACCEPT_FILTER, tcp_accept_filter, &option_len);
     return (char *) tcp_accept_filter;
+#   else
+    return NULL;
+#   endif
 }
 
 
@@ -1098,10 +1318,14 @@ zsocket_tcp_accept_filter (void *zocket)
 int 
 zsocket_rcvmore (void *zocket)
 {
+#   if defined (ZMQ_RCVMORE)
     int rcvmore;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_RCVMORE, &rcvmore, &option_len);
     return rcvmore;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -1112,10 +1336,14 @@ zsocket_rcvmore (void *zocket)
 int 
 zsocket_fd (void *zocket)
 {
+#   if defined (ZMQ_FD)
     int fd;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_FD, &fd, &option_len);
     return fd;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -1126,10 +1354,14 @@ zsocket_fd (void *zocket)
 int 
 zsocket_events (void *zocket)
 {
+#   if defined (ZMQ_EVENTS)
     int events;
     size_t option_len = sizeof (int);
     zmq_getsockopt (zocket, ZMQ_EVENTS, &events, &option_len);
     return events;
+#   else
+    return 0;
+#   endif
 }
 
 
@@ -1140,10 +1372,14 @@ zsocket_events (void *zocket)
 char * 
 zsocket_last_endpoint (void *zocket)
 {
+#   if defined (ZMQ_LAST_ENDPOINT)
     size_t option_len = 255;
     char *last_endpoint = (char *) zmalloc (option_len);
     zmq_getsockopt (zocket, ZMQ_LAST_ENDPOINT, last_endpoint, &option_len);
     return (char *) last_endpoint;
+#   else
+    return NULL;
+#   endif
 }
 
 
@@ -2712,56 +2948,79 @@ zsockopt_test (bool verbose)
     assert (ctx);
     void *zocket;
 #if (ZMQ_VERSION_MAJOR == 4)
+#     if defined (ZMQ_IPV6)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_ipv6 (zocket, 1);
     assert (zsocket_ipv6 (zocket) == 1);
     zsocket_ipv6 (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_IMMEDIATE)
     zocket = zsocket_new (ctx, ZMQ_DEALER);
     assert (zocket);
     zsocket_set_immediate (zocket, 1);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_ROUTER_RAW)
     zocket = zsocket_new (ctx, ZMQ_ROUTER);
     assert (zocket);
     zsocket_set_router_raw (zocket, 1);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_IPV4ONLY)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_ipv4only (zocket, 1);
     assert (zsocket_ipv4only (zocket) == 1);
     zsocket_ipv4only (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_DELAY_ATTACH_ON_CONNECT)
     zocket = zsocket_new (ctx, ZMQ_PUB);
     assert (zocket);
     zsocket_set_delay_attach_on_connect (zocket, 1);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_ROUTER_MANDATORY)
     zocket = zsocket_new (ctx, ZMQ_ROUTER);
     assert (zocket);
     zsocket_set_router_mandatory (zocket, 1);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_PROBE_ROUTER)
     zocket = zsocket_new (ctx, ZMQ_DEALER);
     assert (zocket);
     zsocket_probe_router (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_REQ_RELAXED)
     zocket = zsocket_new (ctx, ZMQ_REQ);
     assert (zocket);
     zsocket_set_req_relaxed (zocket, 1);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_REQ_CORRELATE)
     zocket = zsocket_new (ctx, ZMQ_REQ);
     assert (zocket);
     zsocket_set_req_correlate (zocket, 1);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_CONFLATE)
     zocket = zsocket_new (ctx, ZMQ_PUSH);
     assert (zocket);
     zsocket_set_conflate (zocket, 1);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_PLAIN_SERVER)
     zocket = zsocket_new (ctx, ZMQ_PUB);
     assert (zocket);
     zsocket_set_plain_server (zocket, 1);
     assert (zsocket_plain_server (zocket) == 1);
     zsocket_plain_server (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_PLAIN_USERNAME)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_plain_username (zocket, "test");
@@ -2769,6 +3028,8 @@ zsockopt_test (bool verbose)
     assert (plain_username);
     free (plain_username);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_PLAIN_PASSWORD)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_plain_password (zocket, "test");
@@ -2776,6 +3037,8 @@ zsockopt_test (bool verbose)
     assert (plain_password);
     free (plain_password);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_CURVE_SERVER)
 #       if defined (HAVE_LIBSODIUM)
     zocket = zsocket_new (ctx, ZMQ_PUB);
     assert (zocket);
@@ -2784,6 +3047,8 @@ zsockopt_test (bool verbose)
     zsocket_curve_server (zocket);
     zsocket_destroy (ctx, zocket);
 #       endif
+#     endif
+#     if defined (ZMQ_CURVE_PUBLICKEY)
 #       if defined (HAVE_LIBSODIUM)
     zocket = zsocket_new (ctx, ZMQ_PUB);
     assert (zocket);
@@ -2793,6 +3058,8 @@ zsockopt_test (bool verbose)
     free (curve_publickey);
     zsocket_destroy (ctx, zocket);
 #       endif
+#     endif
+#     if defined (ZMQ_CURVE_SECRETKEY)
 #       if defined (HAVE_LIBSODIUM)
     zocket = zsocket_new (ctx, ZMQ_PUB);
     assert (zocket);
@@ -2802,6 +3069,8 @@ zsockopt_test (bool verbose)
     free (curve_secretkey);
     zsocket_destroy (ctx, zocket);
 #       endif
+#     endif
+#     if defined (ZMQ_CURVE_SERVERKEY)
 #       if defined (HAVE_LIBSODIUM)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
@@ -2811,6 +3080,8 @@ zsockopt_test (bool verbose)
     free (curve_serverkey);
     zsocket_destroy (ctx, zocket);
 #       endif
+#     endif
+#     if defined (ZMQ_ZAP_DOMAIN)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_zap_domain (zocket, "test");
@@ -2818,36 +3089,50 @@ zsockopt_test (bool verbose)
     assert (zap_domain);
     free (zap_domain);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_TYPE)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_type (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_SNDHWM)
     zocket = zsocket_new (ctx, ZMQ_PUB);
     assert (zocket);
     zsocket_set_sndhwm (zocket, 1);
     assert (zsocket_sndhwm (zocket) == 1);
     zsocket_sndhwm (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_RCVHWM)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_rcvhwm (zocket, 1);
     assert (zsocket_rcvhwm (zocket) == 1);
     zsocket_rcvhwm (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_AFFINITY)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_affinity (zocket, 1);
     assert (zsocket_affinity (zocket) == 1);
     zsocket_affinity (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_SUBSCRIBE)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_subscribe (zocket, "test");
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_UNSUBSCRIBE)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_unsubscribe (zocket, "test");
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_IDENTITY)
     zocket = zsocket_new (ctx, ZMQ_DEALER);
     assert (zocket);
     zsocket_set_identity (zocket, "test");
@@ -2855,106 +3140,142 @@ zsockopt_test (bool verbose)
     assert (identity);
     free (identity);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_RATE)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_rate (zocket, 1);
     assert (zsocket_rate (zocket) == 1);
     zsocket_rate (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_RECOVERY_IVL)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_recovery_ivl (zocket, 1);
     assert (zsocket_recovery_ivl (zocket) == 1);
     zsocket_recovery_ivl (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_SNDBUF)
     zocket = zsocket_new (ctx, ZMQ_PUB);
     assert (zocket);
     zsocket_set_sndbuf (zocket, 1);
     assert (zsocket_sndbuf (zocket) == 1);
     zsocket_sndbuf (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_RCVBUF)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_rcvbuf (zocket, 1);
     assert (zsocket_rcvbuf (zocket) == 1);
     zsocket_rcvbuf (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_LINGER)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_linger (zocket, 1);
     assert (zsocket_linger (zocket) == 1);
     zsocket_linger (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_RECONNECT_IVL)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_reconnect_ivl (zocket, 1);
     assert (zsocket_reconnect_ivl (zocket) == 1);
     zsocket_reconnect_ivl (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_RECONNECT_IVL_MAX)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_reconnect_ivl_max (zocket, 1);
     assert (zsocket_reconnect_ivl_max (zocket) == 1);
     zsocket_reconnect_ivl_max (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_BACKLOG)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_backlog (zocket, 1);
     assert (zsocket_backlog (zocket) == 1);
     zsocket_backlog (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_MAXMSGSIZE)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_maxmsgsize (zocket, 1);
     assert (zsocket_maxmsgsize (zocket) == 1);
     zsocket_maxmsgsize (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_MULTICAST_HOPS)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_multicast_hops (zocket, 1);
     assert (zsocket_multicast_hops (zocket) == 1);
     zsocket_multicast_hops (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_RCVTIMEO)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_rcvtimeo (zocket, 1);
     assert (zsocket_rcvtimeo (zocket) == 1);
     zsocket_rcvtimeo (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_SNDTIMEO)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_sndtimeo (zocket, 1);
     assert (zsocket_sndtimeo (zocket) == 1);
     zsocket_sndtimeo (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_XPUB_VERBOSE)
     zocket = zsocket_new (ctx, ZMQ_XPUB);
     assert (zocket);
     zsocket_set_xpub_verbose (zocket, 1);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_TCP_KEEPALIVE)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_tcp_keepalive (zocket, 1);
     assert (zsocket_tcp_keepalive (zocket) == 1);
     zsocket_tcp_keepalive (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_TCP_KEEPALIVE_IDLE)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_tcp_keepalive_idle (zocket, 1);
     assert (zsocket_tcp_keepalive_idle (zocket) == 1);
     zsocket_tcp_keepalive_idle (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_TCP_KEEPALIVE_CNT)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_tcp_keepalive_cnt (zocket, 1);
     assert (zsocket_tcp_keepalive_cnt (zocket) == 1);
     zsocket_tcp_keepalive_cnt (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_TCP_KEEPALIVE_INTVL)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_tcp_keepalive_intvl (zocket, 1);
     assert (zsocket_tcp_keepalive_intvl (zocket) == 1);
     zsocket_tcp_keepalive_intvl (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_TCP_ACCEPT_FILTER)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_set_tcp_accept_filter (zocket, "127.0.0.1");
@@ -2962,24 +3283,33 @@ zsockopt_test (bool verbose)
     assert (tcp_accept_filter);
     free (tcp_accept_filter);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_RCVMORE)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_rcvmore (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_FD)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_fd (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_EVENTS)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     zsocket_events (zocket);
     zsocket_destroy (ctx, zocket);
+#     endif
+#     if defined (ZMQ_LAST_ENDPOINT)
     zocket = zsocket_new (ctx, ZMQ_SUB);
     assert (zocket);
     char *last_endpoint = zsocket_last_endpoint (zocket);
     assert (last_endpoint);
     free (last_endpoint);
     zsocket_destroy (ctx, zocket);
+#     endif
 
     zocket = zsocket_new (ctx, ZMQ_SUB);
     zsocket_set_hwm (zocket, 1);