rbczmq 1.6.2 → 1.6.4

data/ext/czmq/doc/zsocket.txt

@@ -0,0 +1,110 @@
+zsocket(3)
+==========
+
+NAME
+----
+zsocket - working with 0MQ sockets
+
+SYNOPSIS
+--------
+----
+//  This port range is defined by IANA for dynamic or private ports
+//  We use this when choosing a port for dynamic binding.
+#define ZSOCKET_DYNFROM     0xc000
+#define ZSOCKET_DYNTO       0xffff
+
+//  Create a new socket within our CZMQ context, replaces zmq_socket.
+//  Use this to get automatic management of the socket at shutdown.
+//  Note: SUB sockets do not automatically subscribe to everything; you
+//  must set filters explicitly.
+CZMQ_EXPORT void *
+    zsocket_new (zctx_t *self, int type);
+
+//  Destroy a socket within our CZMQ context, replaces zmq_close.
+CZMQ_EXPORT void
+    zsocket_destroy (zctx_t *self, void *socket);
+
+//  Bind a socket to a formatted endpoint. If the port is specified as
+//  '*', binds to any free port from ZSOCKET_DYNFROM to ZSOCKET_DYNTO
+//  and returns the actual port number used. Otherwise asserts that the
+//  bind succeeded with the specified port number. Always returns the
+//  port number if successful.
+CZMQ_EXPORT int
+    zsocket_bind (void *socket, const char *format, ...);
+
+//  Connect a socket to a formatted endpoint
+//  Returns 0 if OK, -1 if the endpoint was invalid.
+CZMQ_EXPORT int
+    zsocket_connect (void *socket, const char *format, ...);
+
+//  Disonnect a socket from a formatted endpoint
+//  Returns 0 if OK, -1 if the endpoint was invalid or the function
+//  isn't supported.
+CZMQ_EXPORT int
+    zsocket_disconnect (void *socket, const char *format, ...);
+
+//  Poll for input events on the socket. Returns TRUE if there is input
+//  ready on the socket, else FALSE.
+CZMQ_EXPORT bool
+    zsocket_poll (void *socket, int msecs);
+    
+//  Returns socket type as printable constant string
+CZMQ_EXPORT char *
+    zsocket_type_str (void *socket);
+
+//  Self test of this class
+CZMQ_EXPORT int
+    zsocket_test (bool verbose);
+----
+
+DESCRIPTION
+-----------
+
+The zsocket class provides helper functions for 0MQ sockets. It doesn't
+wrap the 0MQ socket type, to avoid breaking all libzmq socket-related
+calls.
+
+
+EXAMPLE
+-------
+.From zsocket_test method
+----
+    zctx_t *ctx = zctx_new ();
+    assert (ctx);
+
+    //  Create a detached thread, let it run
+    char *interf = "*";
+    char *domain = "localhost";
+    int service = 5560;
+
+    void *writer = zsocket_new (ctx, ZMQ_PUSH);
+    assert (writer);
+    void *reader = zsocket_new (ctx, ZMQ_PULL);
+    assert (reader);
+    assert (streq (zsocket_type_str (writer), "PUSH"));
+    assert (streq (zsocket_type_str (reader), "PULL"));
+    int rc = zsocket_bind (writer, "tcp://%s:%d", interf, service);
+    assert (rc == service);
+    rc = zsocket_connect (reader, "tcp://%s:%d", domain, service);
+    assert (rc == 0);
+    zstr_send (writer, "HELLO");
+    char *message = zstr_recv (reader);
+    assert (message);
+    assert (streq (message, "HELLO"));
+    free (message);
+
+    int port = zsocket_bind (writer, "tcp://%s:*", interf);
+    assert (port >= ZSOCKET_DYNFROM && port <= ZSOCKET_DYNTO);
+
+    assert (zsocket_poll (writer, 100) == false);
+
+    rc = zsocket_connect (reader, "txp://%s:%d", domain, service);
+    assert (rc == -1);
+
+    zsocket_destroy (ctx, writer);
+    zctx_destroy (&ctx);
+----
+
+SEE ALSO
+--------
+linkczmq:czmq[7]

data/ext/czmq/doc/zsockopt.txt

@@ -0,0 +1,528 @@
+zsockopt(3)
+===========
+
+NAME
+----
+zsockopt - get/set 0MQ socket options
+
+SYNOPSIS
+--------
+----
+#if (ZMQ_VERSION_MAJOR == 2)
+//  Get socket options
+CZMQ_EXPORT int zsocket_hwm (void *zocket);
+CZMQ_EXPORT int zsocket_swap (void *zocket);
+CZMQ_EXPORT int zsocket_affinity (void *zocket);
+//  Returns freshly allocated string, free when done
+CZMQ_EXPORT char * zsocket_identity (void *zocket);
+CZMQ_EXPORT int zsocket_rate (void *zocket);
+CZMQ_EXPORT int zsocket_recovery_ivl (void *zocket);
+CZMQ_EXPORT int zsocket_recovery_ivl_msec (void *zocket);
+CZMQ_EXPORT int zsocket_mcast_loop (void *zocket);
+#   if (ZMQ_VERSION_MINOR == 2)
+CZMQ_EXPORT int zsocket_rcvtimeo (void *zocket);
+#   endif
+#   if (ZMQ_VERSION_MINOR == 2)
+CZMQ_EXPORT int zsocket_sndtimeo (void *zocket);
+#   endif
+CZMQ_EXPORT int zsocket_sndbuf (void *zocket);
+CZMQ_EXPORT int zsocket_rcvbuf (void *zocket);
+CZMQ_EXPORT int zsocket_linger (void *zocket);
+CZMQ_EXPORT int zsocket_reconnect_ivl (void *zocket);
+CZMQ_EXPORT int zsocket_reconnect_ivl_max (void *zocket);
+CZMQ_EXPORT int zsocket_backlog (void *zocket);
+CZMQ_EXPORT int zsocket_type (void *zocket);
+CZMQ_EXPORT int zsocket_rcvmore (void *zocket);
+CZMQ_EXPORT int zsocket_fd (void *zocket);
+CZMQ_EXPORT int zsocket_events (void *zocket);
+
+//  Set socket options
+CZMQ_EXPORT void zsocket_set_hwm (void *zocket, int hwm);
+CZMQ_EXPORT void zsocket_set_swap (void *zocket, int swap);
+CZMQ_EXPORT void zsocket_set_affinity (void *zocket, int affinity);
+CZMQ_EXPORT void zsocket_set_identity (void *zocket, const char * identity);
+CZMQ_EXPORT void zsocket_set_rate (void *zocket, int rate);
+CZMQ_EXPORT void zsocket_set_recovery_ivl (void *zocket, int recovery_ivl);
+CZMQ_EXPORT void zsocket_set_recovery_ivl_msec (void *zocket, int recovery_ivl_msec);
+CZMQ_EXPORT void zsocket_set_mcast_loop (void *zocket, int mcast_loop);
+#   if (ZMQ_VERSION_MINOR == 2)
+CZMQ_EXPORT void zsocket_set_rcvtimeo (void *zocket, int rcvtimeo);
+#   endif
+#   if (ZMQ_VERSION_MINOR == 2)
+CZMQ_EXPORT void zsocket_set_sndtimeo (void *zocket, int sndtimeo);
+#   endif
+CZMQ_EXPORT void zsocket_set_sndbuf (void *zocket, int sndbuf);
+CZMQ_EXPORT void zsocket_set_rcvbuf (void *zocket, int rcvbuf);
+CZMQ_EXPORT void zsocket_set_linger (void *zocket, int linger);
+CZMQ_EXPORT void zsocket_set_reconnect_ivl (void *zocket, int reconnect_ivl);
+CZMQ_EXPORT void zsocket_set_reconnect_ivl_max (void *zocket, int reconnect_ivl_max);
+CZMQ_EXPORT void zsocket_set_backlog (void *zocket, int backlog);
+CZMQ_EXPORT void zsocket_set_subscribe (void *zocket, const char * subscribe);
+CZMQ_EXPORT void zsocket_set_unsubscribe (void *zocket, const char * unsubscribe);
+#endif
+
+#if (ZMQ_VERSION_MAJOR == 3)
+//  Get socket options
+CZMQ_EXPORT int zsocket_type (void *zocket);
+CZMQ_EXPORT int zsocket_sndhwm (void *zocket);
+CZMQ_EXPORT int zsocket_rcvhwm (void *zocket);
+CZMQ_EXPORT int zsocket_affinity (void *zocket);
+//  Returns freshly allocated string, free when done
+CZMQ_EXPORT char * zsocket_identity (void *zocket);
+CZMQ_EXPORT int zsocket_rate (void *zocket);
+CZMQ_EXPORT int zsocket_recovery_ivl (void *zocket);
+CZMQ_EXPORT int zsocket_sndbuf (void *zocket);
+CZMQ_EXPORT int zsocket_rcvbuf (void *zocket);
+CZMQ_EXPORT int zsocket_linger (void *zocket);
+CZMQ_EXPORT int zsocket_reconnect_ivl (void *zocket);
+CZMQ_EXPORT int zsocket_reconnect_ivl_max (void *zocket);
+CZMQ_EXPORT int zsocket_backlog (void *zocket);
+CZMQ_EXPORT int zsocket_maxmsgsize (void *zocket);
+CZMQ_EXPORT int zsocket_multicast_hops (void *zocket);
+CZMQ_EXPORT int zsocket_rcvtimeo (void *zocket);
+CZMQ_EXPORT int zsocket_sndtimeo (void *zocket);
+CZMQ_EXPORT int zsocket_ipv4only (void *zocket);
+CZMQ_EXPORT int zsocket_rcvmore (void *zocket);
+CZMQ_EXPORT int zsocket_fd (void *zocket);
+CZMQ_EXPORT int zsocket_events (void *zocket);
+//  Returns freshly allocated string, free when done
+CZMQ_EXPORT char * zsocket_last_endpoint (void *zocket);
+
+//  Set socket options
+CZMQ_EXPORT void zsocket_set_sndhwm (void *zocket, int sndhwm);
+CZMQ_EXPORT void zsocket_set_rcvhwm (void *zocket, int rcvhwm);
+CZMQ_EXPORT void zsocket_set_affinity (void *zocket, int affinity);
+CZMQ_EXPORT void zsocket_set_subscribe (void *zocket, const char * subscribe);
+CZMQ_EXPORT void zsocket_set_unsubscribe (void *zocket, const char * unsubscribe);
+CZMQ_EXPORT void zsocket_set_identity (void *zocket, const char * identity);
+CZMQ_EXPORT void zsocket_set_rate (void *zocket, int rate);
+CZMQ_EXPORT void zsocket_set_recovery_ivl (void *zocket, int recovery_ivl);
+CZMQ_EXPORT void zsocket_set_sndbuf (void *zocket, int sndbuf);
+CZMQ_EXPORT void zsocket_set_rcvbuf (void *zocket, int rcvbuf);
+CZMQ_EXPORT void zsocket_set_linger (void *zocket, int linger);
+CZMQ_EXPORT void zsocket_set_reconnect_ivl (void *zocket, int reconnect_ivl);
+CZMQ_EXPORT void zsocket_set_reconnect_ivl_max (void *zocket, int reconnect_ivl_max);
+CZMQ_EXPORT void zsocket_set_backlog (void *zocket, int backlog);
+CZMQ_EXPORT void zsocket_set_maxmsgsize (void *zocket, int maxmsgsize);
+CZMQ_EXPORT void zsocket_set_multicast_hops (void *zocket, int multicast_hops);
+CZMQ_EXPORT void zsocket_set_rcvtimeo (void *zocket, int rcvtimeo);
+CZMQ_EXPORT void zsocket_set_sndtimeo (void *zocket, int sndtimeo);
+CZMQ_EXPORT void zsocket_set_ipv4only (void *zocket, int ipv4only);
+CZMQ_EXPORT void zsocket_set_delay_attach_on_connect (void *zocket, int delay_attach_on_connect);
+CZMQ_EXPORT void zsocket_set_router_mandatory (void *zocket, int router_mandatory);
+CZMQ_EXPORT void zsocket_set_router_raw (void *zocket, int router_raw);
+CZMQ_EXPORT void zsocket_set_xpub_verbose (void *zocket, int xpub_verbose);
+
+//  Emulation of widely-used 2.x socket options
+void zsocket_set_hwm (void *zocket, int hwm);
+#endif
+
+//  Self test of this class
+CZMQ_EXPORT int zsockopt_test (bool verbose);
+----
+
+DESCRIPTION
+-----------
+
+The zsockopt class provides access to the 0MQ getsockopt/setsockopt API.
+
+This class is generated, using the GSL code generator. See the sockopts
+XML file, which provides the metadata, and the sockopts.gsl template,
+which does the work.
+
+EXAMPLE
+-------
+.From zsockopt_test method
+----
+    zctx_t *ctx = zctx_new ();
+    assert (ctx);
+    void *zocket;
+#if (ZMQ_VERSION_MAJOR == 2)
+#       if defined (ZMQ_HWM)
+    zocket = zsocket_new (ctx, ZMQ_SUB);
+    assert (zocket);
+    zsocket_set_hwm (zocket, 1);
+    assert (zsocket_hwm (zocket) == 1);
+    zsocket_hwm (zocket);
+    zsocket_destroy (ctx, zocket);
+#       endif
+#       if defined (ZMQ_SWAP)
+    zocket = zsocket_new (ctx, ZMQ_SUB);
+    assert (zocket);
+    zsocket_set_swap (zocket, 1);
+    assert (zsocket_swap (zocket) == 1);
+    zsocket_swap (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_IDENTITY)
+    zocket = zsocket_new (ctx, ZMQ_SUB);
+    assert (zocket);
+    zsocket_set_identity (zocket, "test");
+    char *identity = zsocket_identity (zocket);
+    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_RECOVERY_IVL_MSEC)
+    zocket = zsocket_new (ctx, ZMQ_SUB);
+    assert (zocket);
+    zsocket_set_recovery_ivl_msec (zocket, 1);
+    assert (zsocket_recovery_ivl_msec (zocket) == 1);
+    zsocket_recovery_ivl_msec (zocket);
+    zsocket_destroy (ctx, zocket);
+#       endif
+#       if defined (ZMQ_MCAST_LOOP)
+    zocket = zsocket_new (ctx, ZMQ_SUB);
+    assert (zocket);
+    zsocket_set_mcast_loop (zocket, 1);
+    assert (zsocket_mcast_loop (zocket) == 1);
+    zsocket_mcast_loop (zocket);
+    zsocket_destroy (ctx, zocket);
+#       endif
+#   if (ZMQ_VERSION_MINOR == 2)
+#       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
+#   endif
+#   if (ZMQ_VERSION_MINOR == 2)
+#       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
+#   endif
+#       if defined (ZMQ_SNDBUF)
+    zocket = zsocket_new (ctx, ZMQ_SUB);
+    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_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_TYPE)
+    zocket = zsocket_new (ctx, ZMQ_SUB);
+    assert (zocket);
+    zsocket_type (zocket);
+    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
+#endif
+
+#if (ZMQ_VERSION_MAJOR == 3)
+#       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");
+    char *identity = zsocket_identity (zocket);
+    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_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_ROUTER_RAW)
+    zocket = zsocket_new (ctx, ZMQ_ROUTER);
+    assert (zocket);
+    zsocket_set_router_raw (zocket, 1);
+    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_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);
+#endif
+
+    zctx_destroy (&ctx);
+----
+
+SEE ALSO
+--------
+linkczmq:czmq[7]