Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
ZSOCK(3)			  CZMQ Manual			      ZSOCK(3)

NAME
       zsock - Class for high-level socket API that hides libzmq contexts and
       sockets

SYNOPSIS
       //  This	is a stable class, and may not change except for emergencies. It
       //  is provided in stable builds.
       //  This	class has draft	methods, which may change over time. They are not
       //  in stable releases, by default. Use --enable-drafts to enable.
       //  Create a new	socket.	Returns	the new	socket,	or NULL	if the new socket
       //  could not be	created. Note that the symbol zsock_new	(and other
       //  constructors/destructors for	zsock) are redirected to the *_checked
       //  variant, enabling intelligent socket	leak detection.	This can have
       //  performance implications if you use a LOT of	sockets. To turn off this
       //  redirection behaviour, define ZSOCK_NOCHECK.
       CZMQ_EXPORT zsock_t *
	   zsock_new (int type);

       //  Create a PUB	socket.	Default	action is bind.
       CZMQ_EXPORT zsock_t *
	   zsock_new_pub (const	char *endpoint);

       //  Create a SUB	socket,	and optionally subscribe to some prefix	string.	Default
       //  action is connect.
       CZMQ_EXPORT zsock_t *
	   zsock_new_sub (const	char *endpoint,	const char *subscribe);

       //  Create a REQ	socket.	Default	action is connect.
       CZMQ_EXPORT zsock_t *
	   zsock_new_req (const	char *endpoint);

       //  Create a REP	socket.	Default	action is bind.
       CZMQ_EXPORT zsock_t *
	   zsock_new_rep (const	char *endpoint);

       //  Create a DEALER socket. Default action is connect.
       CZMQ_EXPORT zsock_t *
	   zsock_new_dealer (const char	*endpoint);

       //  Create a ROUTER socket. Default action is bind.
       CZMQ_EXPORT zsock_t *
	   zsock_new_router (const char	*endpoint);

       //  Create a PUSH socket. Default action	is connect.
       CZMQ_EXPORT zsock_t *
	   zsock_new_push (const char *endpoint);

       //  Create a PULL socket. Default action	is bind.
       CZMQ_EXPORT zsock_t *
	   zsock_new_pull (const char *endpoint);

       //  Create an XPUB socket. Default action is bind.
       CZMQ_EXPORT zsock_t *
	   zsock_new_xpub (const char *endpoint);

       //  Create an XSUB socket. Default action is connect.
       CZMQ_EXPORT zsock_t *
	   zsock_new_xsub (const char *endpoint);

       //  Create a PAIR socket. Default action	is connect.
       CZMQ_EXPORT zsock_t *
	   zsock_new_pair (const char *endpoint);

       //  Create a STREAM socket. Default action is connect.
       CZMQ_EXPORT zsock_t *
	   zsock_new_stream (const char	*endpoint);

       //  Destroy the socket. You must	use this for any socket	created	via the
       //  zsock_new method.
       CZMQ_EXPORT void
	   zsock_destroy (zsock_t **self_p);

       //  Bind	a socket to a formatted	endpoint. For tcp:// endpoints,	supports
       //  ephemeral ports, if you specify the port number as "*". By default
       //  zsock uses the IANA designated range	from C000 (49152) to FFFF (65535).
       //  To override this range, follow the "*" with "[first-last]". Either or
       //  both	first and last may be empty. To	bind to	a random port within the
       //  range, use "!" in place of "*".
       //
       //  Examples:
       //      tcp://127.0.0.1:*	   bind	to first free port from	C000 up
       //      tcp://127.0.0.1:!	   bind	to random port from C000 to FFFF
       //      tcp://127.0.0.1:*[60000-]   bind	to first free port from	60000 up
       //      tcp://127.0.0.1:![-60000]   bind	to random port from C000 to 60000
       //      tcp://127.0.0.1:![55000-55999]
       //				   bind	to random port from 55000 to 55999
       //
       //  On success, returns the actual port number used, for	tcp:// endpoints,
       //  and 0 for other transports. On failure, returns -1. Note that when using
       //  ephemeral ports, a port may be reused by different services without
       //  clients being aware.	Protocols that run on ephemeral	ports should take
       //  this	into account.
       CZMQ_EXPORT int
	   zsock_bind (zsock_t *self, const char *format, ...) CHECK_PRINTF (2);

       //  Returns last	bound endpoint,	if any.
       CZMQ_EXPORT const char *
	   zsock_endpoint (zsock_t *self);

       //  Unbind 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
	   zsock_unbind	(zsock_t *self,	const char *format, ...) CHECK_PRINTF (2);

       //  Connect a socket to a formatted endpoint
       //  Returns 0 if	OK, -1 if the endpoint was invalid.
       CZMQ_EXPORT int
	   zsock_connect (zsock_t *self, const char *format, ...) CHECK_PRINTF (2);

       //  Disconnect 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
	   zsock_disconnect (zsock_t *self, const char *format,	...) CHECK_PRINTF (2);

       //  Attach a socket to zero or more endpoints. If endpoints is not null,
       //  parses as list of ZeroMQ endpoints, separated by commas, and	prefixed by
       //  '@' (to bind	the socket) or '>' (to connect the socket). Returns 0 if all
       //  endpoints were valid, or -1 if there	was a syntax error. If the endpoint
       //  does	not start with '@' or '>', the serverish argument defines whether
       //  it is used to bind (serverish = true) or connect (serverish = false).
       CZMQ_EXPORT int
	   zsock_attach	(zsock_t *self,	const char *endpoints, bool serverish);

       //  Returns socket type as printable constant string.
       CZMQ_EXPORT const char *
	   zsock_type_str (zsock_t *self);

       //  Send	a 'picture' message to the socket (or actor). The picture is a
       //  string that defines the type	of each	frame. This makes it easy to send
       //  a complex multiframe	message	in one call. The picture can contain any
       //  of these characters,	each corresponding to one or two arguments:
       //
       //      i = int (signed)
       //      1 = uint8_t
       //      2 = uint16_t
       //      4 = uint32_t
       //      8 = uint64_t
       //      s = char	*
       //      b = byte	*, size_t (2 arguments)
       //      c = zchunk_t *
       //      f = zframe_t *
       //      h = zhashx_t *
       //      l = zlistx_t * (DRAFT)
       //      U = zuuid_t *
       //      p = void	* (sends the pointer value, only meaningful over inproc)
       //      m = zmsg_t * (sends all frames in the zmsg)
       //      z = sends zero-sized frame (0 arguments)
       //      u = uint	(deprecated)
       //
       //  Note	that s,	b, c, and f are	encoded	the same way and the choice is
       //  offered as a	convenience to the sender, which may or	may not	already
       //  have	data in	a zchunk or zframe. Does not change or take ownership of
       //  any arguments. Returns 0 if successful, -1 if sending failed	for any
       //  reason.
       CZMQ_EXPORT int
	   zsock_send (void *self, const char *picture,	...);

       //  Send	a 'picture' message to the socket (or actor). This is a	va_list
       //  version of zsock_send (), so	please consult its documentation for the
       //  details.
       CZMQ_EXPORT int
	   zsock_vsend (void *self, const char *picture, va_list argptr);

       //  Receive a 'picture' message to the socket (or actor). See zsock_send	for
       //  the format and meaning of the picture. Returns the picture elements into
       //  a series of pointers	as provided by the caller:
       //
       //      i = int * (stores signed	integer)
       //      4 = uint32_t * (stores 32-bit unsigned integer)
       //      8 = uint64_t * (stores 64-bit unsigned integer)
       //      s = char	** (allocates new string)
       //      b = byte	**, size_t * (2	arguments) (allocates memory)
       //      c = zchunk_t ** (creates	zchunk)
       //      f = zframe_t ** (creates	zframe)
       //      U = zuuid_t * (creates a	zuuid with the data)
       //      h = zhashx_t ** (creates	zhashx)
       //      l = zlistx_t ** (creates	zlistx)	(DRAFT)
       //      p = void	** (stores pointer)
       //      m = zmsg_t ** (creates a	zmsg with the remaining	frames)
       //      z = null, asserts empty frame (0	arguments)
       //      u = uint	* (stores unsigned integer, deprecated)
       //
       //  Note	that zsock_recv	creates	the returned objects, and the caller must
       //  destroy them	when finished with them. The supplied pointers do not need
       //  to be initialized. Returns 0	if successful, or -1 if	it failed to recv
       //  a message, in which case the	pointers are not modified. When	message
       //  frames are truncated	(a short message), sets	return values to zero/null.
       //  If an argument pointer is NULL, does	not store any value (skips it).
       //  An 'n' picture matches an empty frame; if the message does not match,
       //  the method will return -1.
       CZMQ_EXPORT int
	   zsock_recv (void *self, const char *picture,	...);

       //  Receive a 'picture' message from the	socket (or actor). This	is a
       //  va_list version of zsock_recv (), so	please consult its documentation
       //  for the details.
       CZMQ_EXPORT int
	   zsock_vrecv (void *self, const char *picture, va_list argptr);

       //  Send	a binary encoded 'picture' message to the socket (or actor). This
       //  method is similar to	zsock_send, except the arguments are encoded in	a
       //  binary format that is compatible with zproto, and is	designed to reduce
       //  memory allocations. The pattern argument is a string	that defines the
       //  type	of each	argument. Supports these argument types:
       //
       //   pattern    C type		       zproto type:
       //      1       uint8_t		       type = "number" size = "1"
       //      2       uint16_t		       type = "number" size = "2"
       //      4       uint32_t		       type = "number" size = "3"
       //      8       uint64_t		       type = "number" size = "4"
       //      s       char *, 0-255 chars     type = "string"
       //      S       char *, 0-2^32-1	chars  type = "longstr"
       //      c       zchunk_t	*	       type = "chunk"
       //      f       zframe_t	*	       type = "frame"
       //      u       zuuid_t *	       type = "uuid"
       //      m       zmsg_t *		       type = "msg"
       //      p       void *, sends pointer value, only over inproc
       //
       //  Does	not change or take ownership of	any arguments. Returns 0 if
       //  successful, -1 if sending failed for	any reason.
       CZMQ_EXPORT int
	   zsock_bsend (void *self, const char *picture, ...);

       //  Receive a binary encoded 'picture' message from the socket (or actor).
       //  This	method is similar to zsock_recv, except	the arguments are encoded
       //  in a	binary format that is compatible with zproto, and is designed to
       //  reduce memory allocations. The pattern argument is a	string that defines
       //  the type of each argument. See zsock_bsend for the supported	argument
       //  types. All arguments	must be	pointers; this call sets them to point to
       //  values held on a per-socket basis.
       //  For types 1,	2, 4 and 8 the caller must allocate the	memory itself before
       //  calling zsock_brecv.
       //  For types S,	the caller must	free the value once finished with it, as
       //  zsock_brecv will allocate the buffer.
       //  For type s, the caller must not free	the value as it	is stored in a
       //  local cache for performance purposes.
       //  For types c,	f, u and m the caller must call	the appropriate	destructor
       //  depending on	the object as zsock_brecv will create new objects.
       //  For type p the caller must coordinate with the sender, as it	is just	a
       //  pointer value being passed.
       CZMQ_EXPORT int
	   zsock_brecv (void *self, const char *picture, ...);

       //  Set socket to use unbounded pipes (HWM=0); use this in cases	when you are
       //  totally certain the message volume can fit in memory. This method works
       //  across all versions of ZeroMQ. Takes	a polymorphic socket reference.
       CZMQ_EXPORT void
	   zsock_set_unbounded (void *self);

       //  Send	a signal over a	socket.	A signal is a short message carrying a
       //  success/failure code	(by convention,	0 means	OK). Signals are encoded
       //  to be distinguishable from "normal" messages. Accepts a zsock_t or a
       //  zactor_t argument, and returns 0 if successful, -1 if the signal could
       //  not be sent.	Takes a	polymorphic socket reference.
       CZMQ_EXPORT int
	   zsock_signal	(void *self, byte status);

       //  Wait	on a signal. Use this to coordinate between threads, over pipe
       //  pairs. Blocks until the signal is received. Returns -1 on error, 0 or
       //  greater on success. Accepts a zsock_t or a zactor_t as argument.
       //  Takes a polymorphic socket reference.
       CZMQ_EXPORT int
	   zsock_wait (void *self);

       //  If there is a partial message still waiting on the socket, remove and
       //  discard it. This is useful when reading partial messages, to	get specific
       //  message types.
       CZMQ_EXPORT void
	   zsock_flush (void *self);

       //  Probe the supplied object, and report if it looks like a zsock_t.
       //  Takes a polymorphic socket reference.
       CZMQ_EXPORT bool
	   zsock_is (void *self);

       //  Probe the supplied reference. If it looks like a zsock_t instance, return
       //  the underlying libzmq socket	handle;	else if	it looks like a	file
       //  descriptor, return NULL; else if it looks like a libzmq socket handle,
       //  return the supplied value. Takes a polymorphic socket reference.
       CZMQ_EXPORT void	*
	   zsock_resolve (void *self);

       //  Get socket option `priority`.
       //  Available from libzmq 4.3.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_priority (void	*self);

       //  Set socket option `priority`.
       //  Available from libzmq 4.3.0.
       CZMQ_EXPORT void
	   zsock_set_priority (void *self, int priority);

       //  Get socket option `reconnect_stop`.
       //  Available from libzmq 4.3.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_reconnect_stop	(void *self);

       //  Set socket option `reconnect_stop`.
       //  Available from libzmq 4.3.0.
       CZMQ_EXPORT void
	   zsock_set_reconnect_stop (void *self, int reconnect_stop);

       //  Set socket option `only_first_subscribe`.
       //  Available from libzmq 4.3.0.
       CZMQ_EXPORT void
	   zsock_set_only_first_subscribe (void	*self, int only_first_subscribe);

       //  Set socket option `hello_msg`.
       //  Available from libzmq 4.3.0.
       CZMQ_EXPORT void
	   zsock_set_hello_msg (void *self, zframe_t *hello_msg);

       //  Set socket option `disconnect_msg`.
       //  Available from libzmq 4.3.0.
       CZMQ_EXPORT void
	   zsock_set_disconnect_msg (void *self, zframe_t *disconnect_msg);

       //  Set socket option `wss_trust_system`.
       //  Available from libzmq 4.3.0.
       CZMQ_EXPORT void
	   zsock_set_wss_trust_system (void *self, int wss_trust_system);

       //  Set socket option `wss_hostname`.
       //  Available from libzmq 4.3.0.
       CZMQ_EXPORT void
	   zsock_set_wss_hostname (void	*self, const char *wss_hostname);

       //  Set socket option `wss_trust_pem`.
       //  Available from libzmq 4.3.0.
       CZMQ_EXPORT void
	   zsock_set_wss_trust_pem (void *self,	const char *wss_trust_pem);

       //  Set socket option `wss_cert_pem`.
       //  Available from libzmq 4.3.0.
       CZMQ_EXPORT void
	   zsock_set_wss_cert_pem (void	*self, const char *wss_cert_pem);

       //  Set socket option `wss_key_pem`.
       //  Available from libzmq 4.3.0.
       CZMQ_EXPORT void
	   zsock_set_wss_key_pem (void *self, const char *wss_key_pem);

       //  Get socket option `out_batch_size`.
       //  Available from libzmq 4.3.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_out_batch_size	(void *self);

       //  Set socket option `out_batch_size`.
       //  Available from libzmq 4.3.0.
       CZMQ_EXPORT void
	   zsock_set_out_batch_size (void *self, int out_batch_size);

       //  Get socket option `in_batch_size`.
       //  Available from libzmq 4.3.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_in_batch_size (void *self);

       //  Set socket option `in_batch_size`.
       //  Available from libzmq 4.3.0.
       CZMQ_EXPORT void
	   zsock_set_in_batch_size (void *self,	int in_batch_size);

       //  Get socket option `socks_password`.
       //  Available from libzmq 4.3.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT char	*
	   zsock_socks_password	(void *self);

       //  Set socket option `socks_password`.
       //  Available from libzmq 4.3.0.
       CZMQ_EXPORT void
	   zsock_set_socks_password (void *self, const char *socks_password);

       //  Get socket option `socks_username`.
       //  Available from libzmq 4.3.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT char	*
	   zsock_socks_username	(void *self);

       //  Set socket option `socks_username`.
       //  Available from libzmq 4.3.0.
       CZMQ_EXPORT void
	   zsock_set_socks_username (void *self, const char *socks_username);

       //  Set socket option `xpub_manual_last_value`.
       //  Available from libzmq 4.3.0.
       CZMQ_EXPORT void
	   zsock_set_xpub_manual_last_value (void *self, int xpub_manual_last_value);

       //  Get socket option `router_notify`.
       //  Available from libzmq 4.3.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_router_notify (void *self);

       //  Set socket option `router_notify`.
       //  Available from libzmq 4.3.0.
       CZMQ_EXPORT void
	   zsock_set_router_notify (void *self,	int router_notify);

       //  Get socket option `multicast_loop`.
       //  Available from libzmq 4.3.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_multicast_loop	(void *self);

       //  Set socket option `multicast_loop`.
       //  Available from libzmq 4.3.0.
       CZMQ_EXPORT void
	   zsock_set_multicast_loop (void *self, int multicast_loop);

       //  Get socket option `metadata`.
       //  Available from libzmq 4.3.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT char	*
	   zsock_metadata (void	*self);

       //  Set socket option `metadata`.
       //  Available from libzmq 4.3.0.
       CZMQ_EXPORT void
	   zsock_set_metadata (void *self, const char *metadata);

       //  Get socket option `loopback_fastpath`.
       //  Available from libzmq 4.3.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_loopback_fastpath (void *self);

       //  Set socket option `loopback_fastpath`.
       //  Available from libzmq 4.3.0.
       CZMQ_EXPORT void
	   zsock_set_loopback_fastpath (void *self, int	loopback_fastpath);

       //  Get socket option `zap_enforce_domain`.
       //  Available from libzmq 4.3.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_zap_enforce_domain (void *self);

       //  Set socket option `zap_enforce_domain`.
       //  Available from libzmq 4.3.0.
       CZMQ_EXPORT void
	   zsock_set_zap_enforce_domain	(void *self, int zap_enforce_domain);

       //  Get socket option `gssapi_principal_nametype`.
       //  Available from libzmq 4.3.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_gssapi_principal_nametype (void *self);

       //  Set socket option `gssapi_principal_nametype`.
       //  Available from libzmq 4.3.0.
       CZMQ_EXPORT void
	   zsock_set_gssapi_principal_nametype (void *self, int	gssapi_principal_nametype);

       //  Get socket option `gssapi_service_principal_nametype`.
       //  Available from libzmq 4.3.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_gssapi_service_principal_nametype (void *self);

       //  Set socket option `gssapi_service_principal_nametype`.
       //  Available from libzmq 4.3.0.
       CZMQ_EXPORT void
	   zsock_set_gssapi_service_principal_nametype (void *self, int	gssapi_service_principal_nametype);

       //  Get socket option `bindtodevice`.
       //  Available from libzmq 4.3.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT char	*
	   zsock_bindtodevice (void *self);

       //  Set socket option `bindtodevice`.
       //  Available from libzmq 4.3.0.
       CZMQ_EXPORT void
	   zsock_set_bindtodevice (void	*self, const char *bindtodevice);

       //  Get socket option `heartbeat_ivl`.
       //  Available from libzmq 4.2.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_heartbeat_ivl (void *self);

       //  Set socket option `heartbeat_ivl`.
       //  Available from libzmq 4.2.0.
       CZMQ_EXPORT void
	   zsock_set_heartbeat_ivl (void *self,	int heartbeat_ivl);

       //  Get socket option `heartbeat_ttl`.
       //  Available from libzmq 4.2.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_heartbeat_ttl (void *self);

       //  Set socket option `heartbeat_ttl`.
       //  Available from libzmq 4.2.0.
       CZMQ_EXPORT void
	   zsock_set_heartbeat_ttl (void *self,	int heartbeat_ttl);

       //  Get socket option `heartbeat_timeout`.
       //  Available from libzmq 4.2.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_heartbeat_timeout (void *self);

       //  Set socket option `heartbeat_timeout`.
       //  Available from libzmq 4.2.0.
       CZMQ_EXPORT void
	   zsock_set_heartbeat_timeout (void *self, int	heartbeat_timeout);

       //  Get socket option `use_fd`.
       //  Available from libzmq 4.2.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_use_fd	(void *self);

       //  Set socket option `use_fd`.
       //  Available from libzmq 4.2.0.
       CZMQ_EXPORT void
	   zsock_set_use_fd (void *self, int use_fd);

       //  Set socket option `xpub_manual`.
       //  Available from libzmq 4.2.0.
       CZMQ_EXPORT void
	   zsock_set_xpub_manual (void *self, int xpub_manual);

       //  Set socket option `xpub_welcome_msg`.
       //  Available from libzmq 4.2.0.
       CZMQ_EXPORT void
	   zsock_set_xpub_welcome_msg (void *self, const char *xpub_welcome_msg);

       //  Set socket option `stream_notify`.
       //  Available from libzmq 4.2.0.
       CZMQ_EXPORT void
	   zsock_set_stream_notify (void *self,	int stream_notify);

       //  Get socket option `invert_matching`.
       //  Available from libzmq 4.2.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_invert_matching (void *self);

       //  Set socket option `invert_matching`.
       //  Available from libzmq 4.2.0.
       CZMQ_EXPORT void
	   zsock_set_invert_matching (void *self, int invert_matching);

       //  Set socket option `xpub_verboser`.
       //  Available from libzmq 4.2.0.
       CZMQ_EXPORT void
	   zsock_set_xpub_verboser (void *self,	int xpub_verboser);

       //  Get socket option `connect_timeout`.
       //  Available from libzmq 4.2.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_connect_timeout (void *self);

       //  Set socket option `connect_timeout`.
       //  Available from libzmq 4.2.0.
       CZMQ_EXPORT void
	   zsock_set_connect_timeout (void *self, int connect_timeout);

       //  Get socket option `tcp_maxrt`.
       //  Available from libzmq 4.2.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_tcp_maxrt (void *self);

       //  Set socket option `tcp_maxrt`.
       //  Available from libzmq 4.2.0.
       CZMQ_EXPORT void
	   zsock_set_tcp_maxrt (void *self, int	tcp_maxrt);

       //  Get socket option `thread_safe`.
       //  Available from libzmq 4.2.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_thread_safe (void *self);

       //  Get socket option `multicast_maxtpdu`.
       //  Available from libzmq 4.2.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_multicast_maxtpdu (void *self);

       //  Set socket option `multicast_maxtpdu`.
       //  Available from libzmq 4.2.0.
       CZMQ_EXPORT void
	   zsock_set_multicast_maxtpdu (void *self, int	multicast_maxtpdu);

       //  Get socket option `vmci_buffer_size`.
       //  Available from libzmq 4.2.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_vmci_buffer_size (void	*self);

       //  Set socket option `vmci_buffer_size`.
       //  Available from libzmq 4.2.0.
       CZMQ_EXPORT void
	   zsock_set_vmci_buffer_size (void *self, int vmci_buffer_size);

       //  Get socket option `vmci_buffer_min_size`.
       //  Available from libzmq 4.2.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_vmci_buffer_min_size (void *self);

       //  Set socket option `vmci_buffer_min_size`.
       //  Available from libzmq 4.2.0.
       CZMQ_EXPORT void
	   zsock_set_vmci_buffer_min_size (void	*self, int vmci_buffer_min_size);

       //  Get socket option `vmci_buffer_max_size`.
       //  Available from libzmq 4.2.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_vmci_buffer_max_size (void *self);

       //  Set socket option `vmci_buffer_max_size`.
       //  Available from libzmq 4.2.0.
       CZMQ_EXPORT void
	   zsock_set_vmci_buffer_max_size (void	*self, int vmci_buffer_max_size);

       //  Get socket option `vmci_connect_timeout`.
       //  Available from libzmq 4.2.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_vmci_connect_timeout (void *self);

       //  Set socket option `vmci_connect_timeout`.
       //  Available from libzmq 4.2.0.
       CZMQ_EXPORT void
	   zsock_set_vmci_connect_timeout (void	*self, int vmci_connect_timeout);

       //  Get socket option `tos`.
       //  Available from libzmq 4.1.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_tos (void *self);

       //  Set socket option `tos`.
       //  Available from libzmq 4.1.0.
       CZMQ_EXPORT void
	   zsock_set_tos (void *self, int tos);

       //  Set socket option `router_handover`.
       //  Available from libzmq 4.1.0.
       CZMQ_EXPORT void
	   zsock_set_router_handover (void *self, int router_handover);

       //  Set socket option `connect_rid`.
       //  Available from libzmq 4.1.0.
       CZMQ_EXPORT void
	   zsock_set_connect_rid (void *self, const char *connect_rid);

       //  Set socket option `connect_rid` from	32-octet binary
       //  Available from libzmq 4.1.0.
       CZMQ_EXPORT void
	   zsock_set_connect_rid_bin (void *self, const	byte *connect_rid);

       //  Get socket option `handshake_ivl`.
       //  Available from libzmq 4.1.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_handshake_ivl (void *self);

       //  Set socket option `handshake_ivl`.
       //  Available from libzmq 4.1.0.
       CZMQ_EXPORT void
	   zsock_set_handshake_ivl (void *self,	int handshake_ivl);

       //  Get socket option `socks_proxy`.
       //  Available from libzmq 4.1.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT char	*
	   zsock_socks_proxy (void *self);

       //  Set socket option `socks_proxy`.
       //  Available from libzmq 4.1.0.
       CZMQ_EXPORT void
	   zsock_set_socks_proxy (void *self, const char *socks_proxy);

       //  Set socket option `xpub_nodrop`.
       //  Available from libzmq 4.1.0.
       CZMQ_EXPORT void
	   zsock_set_xpub_nodrop (void *self, int xpub_nodrop);

       //  Set socket option `router_mandatory`.
       //  Available from libzmq 4.0.0.
       CZMQ_EXPORT void
	   zsock_set_router_mandatory (void *self, int router_mandatory);

       //  Set socket option `probe_router`.
       //  Available from libzmq 4.0.0.
       CZMQ_EXPORT void
	   zsock_set_probe_router (void	*self, int probe_router);

       //  Set socket option `req_relaxed`.
       //  Available from libzmq 4.0.0.
       CZMQ_EXPORT void
	   zsock_set_req_relaxed (void *self, int req_relaxed);

       //  Set socket option `req_correlate`.
       //  Available from libzmq 4.0.0.
       CZMQ_EXPORT void
	   zsock_set_req_correlate (void *self,	int req_correlate);

       //  Set socket option `conflate`.
       //  Available from libzmq 4.0.0.
       CZMQ_EXPORT void
	   zsock_set_conflate (void *self, int conflate);

       //  Get socket option `zap_domain`.
       //  Available from libzmq 4.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT char	*
	   zsock_zap_domain (void *self);

       //  Set socket option `zap_domain`.
       //  Available from libzmq 4.0.0.
       CZMQ_EXPORT void
	   zsock_set_zap_domain	(void *self, const char	*zap_domain);

       //  Get socket option `mechanism`.
       //  Available from libzmq 4.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_mechanism (void *self);

       //  Get socket option `plain_server`.
       //  Available from libzmq 4.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_plain_server (void *self);

       //  Set socket option `plain_server`.
       //  Available from libzmq 4.0.0.
       CZMQ_EXPORT void
	   zsock_set_plain_server (void	*self, int plain_server);

       //  Get socket option `plain_username`.
       //  Available from libzmq 4.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT char	*
	   zsock_plain_username	(void *self);

       //  Set socket option `plain_username`.
       //  Available from libzmq 4.0.0.
       CZMQ_EXPORT void
	   zsock_set_plain_username (void *self, const char *plain_username);

       //  Get socket option `plain_password`.
       //  Available from libzmq 4.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT char	*
	   zsock_plain_password	(void *self);

       //  Set socket option `plain_password`.
       //  Available from libzmq 4.0.0.
       CZMQ_EXPORT void
	   zsock_set_plain_password (void *self, const char *plain_password);

       //  Get socket option `curve_server`.
       //  Available from libzmq 4.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_curve_server (void *self);

       //  Set socket option `curve_server`.
       //  Available from libzmq 4.0.0.
       CZMQ_EXPORT void
	   zsock_set_curve_server (void	*self, int curve_server);

       //  Get socket option `curve_publickey`.
       //  Available from libzmq 4.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT char	*
	   zsock_curve_publickey (void *self);

       //  Set socket option `curve_publickey`.
       //  Available from libzmq 4.0.0.
       CZMQ_EXPORT void
	   zsock_set_curve_publickey (void *self, const	char *curve_publickey);

       //  Set socket option `curve_publickey` from 32-octet binary
       //  Available from libzmq 4.0.0.
       CZMQ_EXPORT void
	   zsock_set_curve_publickey_bin (void *self, const byte *curve_publickey);

       //  Get socket option `curve_secretkey`.
       //  Available from libzmq 4.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT char	*
	   zsock_curve_secretkey (void *self);

       //  Set socket option `curve_secretkey`.
       //  Available from libzmq 4.0.0.
       CZMQ_EXPORT void
	   zsock_set_curve_secretkey (void *self, const	char *curve_secretkey);

       //  Set socket option `curve_secretkey` from 32-octet binary
       //  Available from libzmq 4.0.0.
       CZMQ_EXPORT void
	   zsock_set_curve_secretkey_bin (void *self, const byte *curve_secretkey);

       //  Get socket option `curve_serverkey`.
       //  Available from libzmq 4.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT char	*
	   zsock_curve_serverkey (void *self);

       //  Set socket option `curve_serverkey`.
       //  Available from libzmq 4.0.0.
       CZMQ_EXPORT void
	   zsock_set_curve_serverkey (void *self, const	char *curve_serverkey);

       //  Set socket option `curve_serverkey` from 32-octet binary
       //  Available from libzmq 4.0.0.
       CZMQ_EXPORT void
	   zsock_set_curve_serverkey_bin (void *self, const byte *curve_serverkey);

       //  Get socket option `gssapi_server`.
       //  Available from libzmq 4.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_gssapi_server (void *self);

       //  Set socket option `gssapi_server`.
       //  Available from libzmq 4.0.0.
       CZMQ_EXPORT void
	   zsock_set_gssapi_server (void *self,	int gssapi_server);

       //  Get socket option `gssapi_plaintext`.
       //  Available from libzmq 4.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_gssapi_plaintext (void	*self);

       //  Set socket option `gssapi_plaintext`.
       //  Available from libzmq 4.0.0.
       CZMQ_EXPORT void
	   zsock_set_gssapi_plaintext (void *self, int gssapi_plaintext);

       //  Get socket option `gssapi_principal`.
       //  Available from libzmq 4.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT char	*
	   zsock_gssapi_principal (void	*self);

       //  Set socket option `gssapi_principal`.
       //  Available from libzmq 4.0.0.
       CZMQ_EXPORT void
	   zsock_set_gssapi_principal (void *self, const char *gssapi_principal);

       //  Get socket option `gssapi_service_principal`.
       //  Available from libzmq 4.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT char	*
	   zsock_gssapi_service_principal (void	*self);

       //  Set socket option `gssapi_service_principal`.
       //  Available from libzmq 4.0.0.
       CZMQ_EXPORT void
	   zsock_set_gssapi_service_principal (void *self, const char *gssapi_service_principal);

       //  Get socket option `ipv6`.
       //  Available from libzmq 4.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_ipv6 (void *self);

       //  Set socket option `ipv6`.
       //  Available from libzmq 4.0.0.
       CZMQ_EXPORT void
	   zsock_set_ipv6 (void	*self, int ipv6);

       //  Get socket option `immediate`.
       //  Available from libzmq 4.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_immediate (void *self);

       //  Set socket option `immediate`.
       //  Available from libzmq 4.0.0.
       CZMQ_EXPORT void
	   zsock_set_immediate (void *self, int	immediate);

       //  Get socket option `sndhwm`.
       //  Available from libzmq 3.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_sndhwm	(void *self);

       //  Set socket option `sndhwm`.
       //  Available from libzmq 3.0.0.
       CZMQ_EXPORT void
	   zsock_set_sndhwm (void *self, int sndhwm);

       //  Get socket option `rcvhwm`.
       //  Available from libzmq 3.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_rcvhwm	(void *self);

       //  Set socket option `rcvhwm`.
       //  Available from libzmq 3.0.0.
       CZMQ_EXPORT void
	   zsock_set_rcvhwm (void *self, int rcvhwm);

       //  Get socket option `maxmsgsize`.
       //  Available from libzmq 3.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_maxmsgsize (void *self);

       //  Set socket option `maxmsgsize`.
       //  Available from libzmq 3.0.0.
       CZMQ_EXPORT void
	   zsock_set_maxmsgsize	(void *self, int maxmsgsize);

       //  Get socket option `multicast_hops`.
       //  Available from libzmq 3.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_multicast_hops	(void *self);

       //  Set socket option `multicast_hops`.
       //  Available from libzmq 3.0.0.
       CZMQ_EXPORT void
	   zsock_set_multicast_hops (void *self, int multicast_hops);

       //  Set socket option `xpub_verbose`.
       //  Available from libzmq 3.0.0.
       CZMQ_EXPORT void
	   zsock_set_xpub_verbose (void	*self, int xpub_verbose);

       //  Get socket option `tcp_keepalive`.
       //  Available from libzmq 3.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_tcp_keepalive (void *self);

       //  Set socket option `tcp_keepalive`.
       //  Available from libzmq 3.0.0.
       CZMQ_EXPORT void
	   zsock_set_tcp_keepalive (void *self,	int tcp_keepalive);

       //  Get socket option `tcp_keepalive_idle`.
       //  Available from libzmq 3.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_tcp_keepalive_idle (void *self);

       //  Set socket option `tcp_keepalive_idle`.
       //  Available from libzmq 3.0.0.
       CZMQ_EXPORT void
	   zsock_set_tcp_keepalive_idle	(void *self, int tcp_keepalive_idle);

       //  Get socket option `tcp_keepalive_cnt`.
       //  Available from libzmq 3.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_tcp_keepalive_cnt (void *self);

       //  Set socket option `tcp_keepalive_cnt`.
       //  Available from libzmq 3.0.0.
       CZMQ_EXPORT void
	   zsock_set_tcp_keepalive_cnt (void *self, int	tcp_keepalive_cnt);

       //  Get socket option `tcp_keepalive_intvl`.
       //  Available from libzmq 3.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_tcp_keepalive_intvl (void *self);

       //  Set socket option `tcp_keepalive_intvl`.
       //  Available from libzmq 3.0.0.
       CZMQ_EXPORT void
	   zsock_set_tcp_keepalive_intvl (void *self, int tcp_keepalive_intvl);

       //  Get socket option `tcp_accept_filter`.
       //  Available from libzmq 3.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT char	*
	   zsock_tcp_accept_filter (void *self);

       //  Set socket option `tcp_accept_filter`.
       //  Available from libzmq 3.0.0.
       CZMQ_EXPORT void
	   zsock_set_tcp_accept_filter (void *self, const char *tcp_accept_filter);

       //  Get socket option `last_endpoint`.
       //  Available from libzmq 3.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT char	*
	   zsock_last_endpoint (void *self);

       //  Set socket option `router_raw`.
       //  Available from libzmq 3.0.0.
       CZMQ_EXPORT void
	   zsock_set_router_raw	(void *self, int router_raw);

       //  Get socket option `ipv4only`.
       //  Available from libzmq 3.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_ipv4only (void	*self);

       //  Set socket option `ipv4only`.
       //  Available from libzmq 3.0.0.
       CZMQ_EXPORT void
	   zsock_set_ipv4only (void *self, int ipv4only);

       //  Set socket option `delay_attach_on_connect`.
       //  Available from libzmq 3.0.0.
       CZMQ_EXPORT void
	   zsock_set_delay_attach_on_connect (void *self, int delay_attach_on_connect);

       //  Get socket option `hwm`.
       //  Available from libzmq 2.0.0 to 3.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_hwm (void *self);

       //  Set socket option `hwm`.
       //  Available from libzmq 2.0.0 to 3.0.0.
       CZMQ_EXPORT void
	   zsock_set_hwm (void *self, int hwm);

       //  Get socket option `swap`.
       //  Available from libzmq 2.0.0 to 3.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_swap (void *self);

       //  Set socket option `swap`.
       //  Available from libzmq 2.0.0 to 3.0.0.
       CZMQ_EXPORT void
	   zsock_set_swap (void	*self, int swap);

       //  Get socket option `affinity`.
       //  Available from libzmq 2.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_affinity (void	*self);

       //  Set socket option `affinity`.
       //  Available from libzmq 2.0.0.
       CZMQ_EXPORT void
	   zsock_set_affinity (void *self, int affinity);

       //  Get socket option `identity`.
       //  Available from libzmq 2.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT char	*
	   zsock_identity (void	*self);

       //  Set socket option `identity`.
       //  Available from libzmq 2.0.0.
       CZMQ_EXPORT void
	   zsock_set_identity (void *self, const char *identity);

       //  Get socket option `rate`.
       //  Available from libzmq 2.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_rate (void *self);

       //  Set socket option `rate`.
       //  Available from libzmq 2.0.0.
       CZMQ_EXPORT void
	   zsock_set_rate (void	*self, int rate);

       //  Get socket option `recovery_ivl`.
       //  Available from libzmq 2.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_recovery_ivl (void *self);

       //  Set socket option `recovery_ivl`.
       //  Available from libzmq 2.0.0.
       CZMQ_EXPORT void
	   zsock_set_recovery_ivl (void	*self, int recovery_ivl);

       //  Get socket option `recovery_ivl_msec`.
       //  Available from libzmq 2.0.0 to 3.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_recovery_ivl_msec (void *self);

       //  Set socket option `recovery_ivl_msec`.
       //  Available from libzmq 2.0.0 to 3.0.0.
       CZMQ_EXPORT void
	   zsock_set_recovery_ivl_msec (void *self, int	recovery_ivl_msec);

       //  Get socket option `mcast_loop`.
       //  Available from libzmq 2.0.0 to 3.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_mcast_loop (void *self);

       //  Set socket option `mcast_loop`.
       //  Available from libzmq 2.0.0 to 3.0.0.
       CZMQ_EXPORT void
	   zsock_set_mcast_loop	(void *self, int mcast_loop);

       //  Get socket option `rcvtimeo`.
       //  Available from libzmq 2.2.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_rcvtimeo (void	*self);

       //  Set socket option `rcvtimeo`.
       //  Available from libzmq 2.2.0.
       CZMQ_EXPORT void
	   zsock_set_rcvtimeo (void *self, int rcvtimeo);

       //  Get socket option `sndtimeo`.
       //  Available from libzmq 2.2.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_sndtimeo (void	*self);

       //  Set socket option `sndtimeo`.
       //  Available from libzmq 2.2.0.
       CZMQ_EXPORT void
	   zsock_set_sndtimeo (void *self, int sndtimeo);

       //  Get socket option `sndbuf`.
       //  Available from libzmq 2.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_sndbuf	(void *self);

       //  Set socket option `sndbuf`.
       //  Available from libzmq 2.0.0.
       CZMQ_EXPORT void
	   zsock_set_sndbuf (void *self, int sndbuf);

       //  Get socket option `rcvbuf`.
       //  Available from libzmq 2.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_rcvbuf	(void *self);

       //  Set socket option `rcvbuf`.
       //  Available from libzmq 2.0.0.
       CZMQ_EXPORT void
	   zsock_set_rcvbuf (void *self, int rcvbuf);

       //  Get socket option `linger`.
       //  Available from libzmq 2.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_linger	(void *self);

       //  Set socket option `linger`.
       //  Available from libzmq 2.0.0.
       CZMQ_EXPORT void
	   zsock_set_linger (void *self, int linger);

       //  Get socket option `reconnect_ivl`.
       //  Available from libzmq 2.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_reconnect_ivl (void *self);

       //  Set socket option `reconnect_ivl`.
       //  Available from libzmq 2.0.0.
       CZMQ_EXPORT void
	   zsock_set_reconnect_ivl (void *self,	int reconnect_ivl);

       //  Get socket option `reconnect_ivl_max`.
       //  Available from libzmq 2.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_reconnect_ivl_max (void *self);

       //  Set socket option `reconnect_ivl_max`.
       //  Available from libzmq 2.0.0.
       CZMQ_EXPORT void
	   zsock_set_reconnect_ivl_max (void *self, int	reconnect_ivl_max);

       //  Get socket option `backlog`.
       //  Available from libzmq 2.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_backlog (void *self);

       //  Set socket option `backlog`.
       //  Available from libzmq 2.0.0.
       CZMQ_EXPORT void
	   zsock_set_backlog (void *self, int backlog);

       //  Set socket option `subscribe`.
       //  Available from libzmq 2.0.0.
       CZMQ_EXPORT void
	   zsock_set_subscribe (void *self, const char *subscribe);

       //  Set socket option `unsubscribe`.
       //  Available from libzmq 2.0.0.
       CZMQ_EXPORT void
	   zsock_set_unsubscribe (void *self, const char *unsubscribe);

       //  Get socket option `type`.
       //  Available from libzmq 2.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_type (void *self);

       //  Get socket option `rcvmore`.
       //  Available from libzmq 2.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_rcvmore (void *self);

       //  Get socket option `fd`.
       //  Available from libzmq 2.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT SOCKET
	   zsock_fd (void *self);

       //  Get socket option `events`.
       //  Available from libzmq 2.0.0.
       //  Caller owns return value and	must destroy it	when done.
       CZMQ_EXPORT int
	   zsock_events	(void *self);

       //  Self	test of	this class.
       CZMQ_EXPORT void
	   zsock_test (bool verbose);

       #ifdef CZMQ_BUILD_DRAFT_API
       //  *** Draft method, for development use, may change without warning ***
       //  Create a SERVER socket. Default action is bind.
       CZMQ_EXPORT zsock_t *
	   zsock_new_server (const char	*endpoint);

       //  *** Draft method, for development use, may change without warning ***
       //  Create a CLIENT socket. Default action is connect.
       CZMQ_EXPORT zsock_t *
	   zsock_new_client (const char	*endpoint);

       //  *** Draft method, for development use, may change without warning ***
       //  Create a RADIO socket. Default action is bind.
       CZMQ_EXPORT zsock_t *
	   zsock_new_radio (const char *endpoint);

       //  *** Draft method, for development use, may change without warning ***
       //  Create a DISH socket. Default action	is connect.
       CZMQ_EXPORT zsock_t *
	   zsock_new_dish (const char *endpoint);

       //  *** Draft method, for development use, may change without warning ***
       //  Create a GATHER socket. Default action is bind.
       CZMQ_EXPORT zsock_t *
	   zsock_new_gather (const char	*endpoint);

       //  *** Draft method, for development use, may change without warning ***
       //  Create a SCATTER socket. Default action is connect.
       CZMQ_EXPORT zsock_t *
	   zsock_new_scatter (const char *endpoint);

       //  *** Draft method, for development use, may change without warning ***
       //  Create a DGRAM (UDP)	socket.	Default	action is bind.
       //  The endpoint	is a string consisting of a
       //  'transport'`://` followed by	an 'address'. As this is
       //  a UDP socket	the 'transport'	has to be 'udp'. The
       //  'address' specifies the ip address and port to
       //  bind	to. For	example:  udp://127.0.0.1:1234
       //  Note: To send to an endpoint	over UDP you have to
       //  send	a message with the destination endpoint	address
       //  as a	first message!
       CZMQ_EXPORT zsock_t *
	   zsock_new_dgram (const char *endpoint);

       //  *** Draft method, for development use, may change without warning ***
       //  Return socket routing ID if any. This returns 0 if the socket is not
       //  of type ZMQ_SERVER or if no request was already received on it.
       CZMQ_EXPORT uint32_t
	   zsock_routing_id (zsock_t *self);

       //  *** Draft method, for development use, may change without warning ***
       //  Set routing ID on socket. The socket	MUST be	of type	ZMQ_SERVER.
       //  This	will be	used when sending messages on the socket via the zsock API.
       CZMQ_EXPORT void
	   zsock_set_routing_id	(zsock_t *self,	uint32_t routing_id);

       //  *** Draft method, for development use, may change without warning ***
       //  Join	a group	for the	RADIO-DISH pattern. Call only on ZMQ_DISH.
       //  Returns 0 if	OK, -1 if failed.
       CZMQ_EXPORT int
	   zsock_join (void *self, const char *group);

       //  *** Draft method, for development use, may change without warning ***
       //  Leave a group for the RADIO-DISH pattern. Call only on ZMQ_DISH.
       //  Returns 0 if	OK, -1 if failed.
       CZMQ_EXPORT int
	   zsock_leave (void *self, const char *group);

       //  *** Draft method, for development use, may change without warning ***
       //  Check whether the socket has	available message to read.
       CZMQ_EXPORT bool
	   zsock_has_in	(void *self);

       #endif // CZMQ_BUILD_DRAFT_API
       Please add '@interface' section in './../src/zsock.c'.

DESCRIPTION
       The zsock class wraps the libzmq	socket handle (a void *) with a	proper
       structure that follows the CLASS	rules for construction and
       destruction. Some zsock methods take a void * "polymorphic" reference,
       which can be either a zsock_t or	a zactor_t reference, or a libzmq void
       *.

       Please add @discuss section in ./../src/zsock.c.

EXAMPLE
       From zsock_test method.

	   zsock_t *writer = zsock_new (ZMQ_PUSH);
	   assert (writer);
	   int port = zsock_bind (writer, "tcp://127.0.0.1:*");
	   assert (port	!= -1);
	   assert (zsock_resolve (writer) != writer);
	   assert (streq (zsock_type_str (writer), "PUSH"));

	   int rc;
	   #if (ZMQ_VERSION >= ZMQ_MAKE_VERSION	(3, 2, 0))
	   //  Check unbind
	   rc =	zsock_unbind (writer, "tcp://127.0.0.1:%d", port);
	   assert (rc == 0);

	   //  In some cases and especially when running under Valgrind, doing
	   //  a bind immediately after	an unbind causes an EADDRINUSE error.
	   //  Even a short sleep allows the OS	to release the port for	reuse.
	   zclock_sleep	(100);

	   //  Bind again
	   rc =	zsock_bind (writer, "tcp://127.0.0.1:%d", port);
	   assert (rc == port);
	   char	endpoint [40];
	   sprintf (endpoint, "tcp://127.0.0.1:%d", port);
	   assert (streq (zsock_endpoint (writer), endpoint));
	   #endif

	   zsock_t *reader = zsock_new (ZMQ_PULL);
	   assert (reader);
	   rc =	zsock_connect (reader, "tcp://127.0.0.1:%d", port);
	   assert (rc != -1);
	   assert (zsock_resolve (reader) != reader);
	   assert (streq (zsock_type_str (reader), "PULL"));

	   //  Basic Hello, World
	   zstr_send (writer, "Hello, World");
	   zmsg_t *msg = zmsg_recv (reader);
	   assert (msg);
	   char	*string	= zmsg_popstr (msg);
	   assert (streq (string, "Hello, World"));
	   freen (string);
	   zmsg_destroy	(&msg);

	   //  Test resolve libzmq socket
	   #if (ZMQ_VERSION >= ZMQ_MAKE_VERSION	(3, 2, 0))
	   void	*zmq_ctx = zmq_ctx_new ();
	   #else
	   void	*zmq_ctx = zmq_ctx_new (1);
	   #endif
	   assert (zmq_ctx);
	   void	*zmq_sock = zmq_socket (zmq_ctx, ZMQ_PUB);
	   assert (zmq_sock);
	   assert (zsock_resolve (zmq_sock) == zmq_sock);
	   zmq_close (zmq_sock);
	   zmq_ctx_term	(zmq_ctx);

	   //  Test resolve zsock
	   zsock_t *resolve = zsock_new_pub("@tcp://127.0.0.1:*");
	   assert (resolve);
	   assert (zsock_resolve (resolve) == resolve->handle);
	   zsock_destroy (&resolve);

	   //  Test resolve FD
	   SOCKET fd = zsock_fd	(reader);
	   assert (zsock_resolve ((void	*) &fd)	== NULL);

	   //  Test binding to ephemeral ports,	sequential and random
	   port	= zsock_bind (writer, "tcp://127.0.0.1:*");
	   assert (port	>= DYNAMIC_FIRST && port <= DYNAMIC_LAST);
	   port	= zsock_bind (writer, "tcp://127.0.0.1:*[50000-]");
	   assert (port	>= 50000 && port <= DYNAMIC_LAST);
	   port	= zsock_bind (writer, "tcp://127.0.0.1:*[-50001]");
	   assert (port	>= DYNAMIC_FIRST && port <= 50001);
	   port	= zsock_bind (writer, "tcp://127.0.0.1:*[60000-60500]");
	   assert (port	>= 60000 && port <= 60500);

	   port	= zsock_bind (writer, "tcp://127.0.0.1:!");
	   assert (port	>= DYNAMIC_FIRST && port <= DYNAMIC_LAST);
	   port	= zsock_bind (writer, "tcp://127.0.0.1:![50000-]");
	   assert (port	>= 50000 && port <= DYNAMIC_LAST);
	   port	= zsock_bind (writer, "tcp://127.0.0.1:![-50001]");
	   assert (port	>= DYNAMIC_FIRST && port <= 50001);
	   port	= zsock_bind (writer, "tcp://127.0.0.1:![60000-60500]");
	   assert (port	>= 60000 && port <= 60500);

	   //  Test zsock_attach method
	   zsock_t *dealer = zsock_new (ZMQ_DEALER);
	   assert (dealer);
	   rc =	zsock_attach (dealer, "@inproc://myendpoint,tcp://127.0.0.1:*,inproc://others",	true);
	   assert (rc == 0);
	   rc =	zsock_attach (dealer, "", false);
	   assert (rc == 0);
	   rc =	zsock_attach (dealer, NULL, true);
	   assert (rc == 0);
	   rc =	zsock_attach (dealer, ">a,@b, c,, ", false);
	   assert (rc == -1);
	   zsock_destroy (&dealer);

	   //  Test zsock_endpoint method
	   rc =	zsock_bind (writer, "inproc://test.%s",	"writer");
	   assert (rc == 0);
	   assert (streq (zsock_endpoint (writer), "inproc://test.writer"));

	   //  Test error state	when connecting	to an invalid socket type
	   //  ('txp://' instead of 'tcp://', typo intentional)
	   rc =	zsock_connect (reader, "txp://127.0.0.1:5560");
	   assert (rc == -1);

	   //  Test signal/wait	methods
	   rc =	zsock_signal (writer, 123);
	   assert (rc == 0);
	   rc =	zsock_wait (reader);
	   assert (rc == 123);

	   //  Test zsock_send/recv pictures
	   uint8_t  number1 = 123;
	   uint16_t number2 = 123 * 123;
	   uint32_t number4 = 123 * 123;
	   number4 *= 123;
	   uint32_t number4_MAX	= UINT32_MAX;
	   uint64_t number8 = 123 * 123;
	   number8 *= 123;
	   number8 *= 123;
	   uint64_t number8_MAX	= UINT64_MAX;

	   zchunk_t *chunk = zchunk_new	("HELLO", 5);
	   assert (chunk);
	   zframe_t *frame = zframe_new	("WORLD", 5);
	   assert (frame);
	   zhashx_t *hash = zhashx_new ();
	   assert (hash);
	   #ifdef CZMQ_BUILD_DRAFT_API
	   zlistx_t *list = zlistx_new ();
	   assert (list);
	   #endif
	   zuuid_t *uuid = zuuid_new ();
	   assert (uuid);
	   zhashx_set_destructor (hash,	(zhashx_destructor_fn *) zstr_free);
	   zhashx_set_duplicator (hash,	(zhashx_duplicator_fn *) strdup);
	   zhashx_insert (hash,	"1", "value A");
	   zhashx_insert (hash,	"2", "value B");
	   #ifdef CZMQ_BUILD_DRAFT_API
	   zlistx_set_destructor (list,	(zlistx_destructor_fn *) zstr_free);
	   zlistx_set_duplicator (list,	(zlistx_duplicator_fn *) strdup);
	   zlistx_add_end (list, "1");
	   zlistx_add_end (list, "2");
	   #endif
	   char	*original = "pointer";

	   //  Test zsock_recv into each supported type
	   #ifdef CZMQ_BUILD_DRAFT_API
	   zsock_send (writer, "i124488zsbcfUhlp",
	   #else
	   zsock_send (writer, "i124488zsbcfUhp",
	   #endif
		       -12345, number1,	number2, number4, number4_MAX,
		       number8,	number8_MAX,
		       "This is	a string", "ABCDE", 5,
	   #ifdef CZMQ_BUILD_DRAFT_API
		       chunk, frame, uuid, hash, list, original);
	   #else
		       chunk, frame, uuid, hash, original);
	   #endif
	   char	*uuid_str = strdup (zuuid_str (uuid));
	   zchunk_destroy (&chunk);
	   zframe_destroy (&frame);
	   zuuid_destroy (&uuid);
	   zhashx_destroy (&hash);
	   #ifdef CZMQ_BUILD_DRAFT_API
	   zlistx_destroy (&list);
	   #endif

	   int integer;
	   byte	*data;
	   size_t size;
	   char	*pointer;
	   number8_MAX = number8 = number4_MAX = number4 = number2 = number1 = 0ULL;
	   #ifdef CZMQ_BUILD_DRAFT_API
	   rc =	zsock_recv (reader, "i124488zsbcfUhlp",
	   #else
	   rc =	zsock_recv (reader, "i124488zsbcfUhp",
	   #endif
			    &integer, &number1,	&number2, &number4, &number4_MAX,
			    &number8, &number8_MAX, &string, &data, &size, &chunk,
	   #ifdef CZMQ_BUILD_DRAFT_API
			    &frame, &uuid, &hash, &list, &pointer);
	   #else
			    &frame, &uuid, &hash, &pointer);
	   #endif
	   assert (rc == 0);
	   assert (integer == -12345);
	   assert (number1 == 123);
	   assert (number2 == 123 * 123);
	   assert (number4 == 123 * 123	* 123);
	   assert (number4_MAX == UINT32_MAX);
	   assert (number8 == 123 * 123	* 123 *	123);
	   assert (number8_MAX == UINT64_MAX);
	   assert (streq (string, "This	is a string"));
	   assert (memcmp (data, "ABCDE", 5) ==	0);
	   assert (size	== 5);
	   assert (memcmp (zchunk_data (chunk),	"HELLO", 5) == 0);
	   assert (zchunk_size (chunk) == 5);
	   assert (streq (uuid_str, zuuid_str (uuid)));
	   assert (memcmp (zframe_data (frame),	"WORLD", 5) == 0);
	   assert (zframe_size (frame) == 5);
	   char	*value = (char *) zhashx_lookup	(hash, "1");
	   assert (streq (value, "value	A"));
	   value = (char *) zhashx_lookup (hash, "2");
	   assert (streq (value, "value	B"));
	   #ifdef CZMQ_BUILD_DRAFT_API
	   value = (char *) zlistx_first (list);
	   assert (streq (value, "1"));
	   value = (char *) zlistx_last	(list);
	   assert (streq (value, "2"));
	   #endif
	   assert (original == pointer);
	   freen (string);
	   freen (data);
	   freen (uuid_str);
	   zframe_destroy (&frame);
	   zchunk_destroy (&chunk);
	   zhashx_destroy (&hash);
	   #ifdef CZMQ_BUILD_DRAFT_API
	   zlistx_destroy (&list);
	   #endif
	   zuuid_destroy (&uuid);

	   //  Test zsock_recv of short	message; this lets us return a failure
	   //  with a status code and then nothing else; the receiver will get
	   //  the status code and NULL/zero for all other values
	   zsock_send (writer, "i", -1);
	   zsock_recv (reader, "izsbcfp",
	       &integer, &string, &data, &size,	&chunk,	&frame,	&pointer);
	   assert (integer == -1);
	   assert (string == NULL);
	   assert (data	== NULL);
	   assert (size	== 0);
	   assert (chunk == NULL);
	   assert (frame == NULL);
	   assert (pointer == NULL);

	   msg = zmsg_new ();
	   zmsg_addstr (msg, "frame 1");
	   zmsg_addstr (msg, "frame 2");
	   zsock_send (writer, "szm", "header",	msg);
	   zmsg_destroy	(&msg);

	   zsock_recv (reader, "szm", &string, &msg);

	   assert (streq ("header", string));
	   assert (zmsg_size (msg) == 2);
	   assert (zframe_streq	(zmsg_first (msg), "frame 1"));
	   assert (zframe_streq	(zmsg_next (msg), "frame 2"));
	   zstr_free (&string);
	   zmsg_destroy	(&msg);

	   //  Test zsock_recv with null arguments
	   chunk = zchunk_new ("HELLO",	5);
	   assert (chunk);
	   frame = zframe_new ("WORLD",	5);
	   assert (frame);
	   zsock_send (writer, "izsbcfp",
		       -12345, "This is	a string", "ABCDE", 5, chunk, frame, original);
	   zframe_destroy (&frame);
	   zchunk_destroy (&chunk);
	   zsock_recv (reader, "izsbcfp", &integer, NULL, NULL,	NULL, &chunk, NULL, NULL);
	   assert (integer == -12345);
	   assert (memcmp (zchunk_data (chunk),	"HELLO", 5) == 0);
	   assert (zchunk_size (chunk) == 5);
	   zchunk_destroy (&chunk);

	   //  Test zsock_bsend/brecv pictures with binary encoding
	   frame = zframe_new ("Hello",	5);
	   chunk = zchunk_new ("World",	5);

	   msg = zmsg_new ();
	   zmsg_addstr (msg, "Hello");
	   zmsg_addstr (msg, "World");

	   zsock_bsend (writer,	"1248sSpcfm",
			number1, number2, number4, number8,
			"Hello,	World",
			"Goodbye cruel World!",
			original,
			chunk, frame, msg);
	   zchunk_destroy (&chunk);
	   zframe_destroy (&frame);
	   zmsg_destroy	(&msg);

	   number8 = number4 = number2 = number1 = 0;
	   char	*longstr;
	   zsock_brecv (reader,	"1248sSpcfm",
			&number1, &number2, &number4, &number8,
			&string, &longstr,
			&pointer,
			&chunk,	&frame,	&msg);
	   assert (number1 == 123);
	   assert (number2 == 123 * 123);
	   assert (number4 == 123 * 123	* 123);
	   assert (number8 == 123 * 123	* 123 *	123);
	   assert (streq (string, "Hello, World"));
	   assert (streq (longstr, "Goodbye cruel World!"));
	   assert (pointer == original);
	   zstr_free (&longstr);
	   zchunk_destroy (&chunk);
	   zframe_destroy (&frame);
	   zmsg_destroy	(&msg);

	   #ifdef ZMQ_SERVER

	   //  Test zsock_bsend/brecv pictures with binary encoding on SERVER and CLIENT sockets
	   zsock_t *server = zsock_new (ZMQ_SERVER);
	   assert (server);
	   port	= zsock_bind (server, "tcp://127.0.0.1:*");
	   assert (port	!= -1);
	   zsock_t* client = zsock_new (ZMQ_CLIENT);
	   assert (client);
	   rc =	zsock_connect (client, "tcp://127.0.0.1:%d", port);
	   assert (rc != -1);

	   //  From client to server
	   chunk = zchunk_new ("World",	5);
	   zsock_bsend (client,	"1248sSpc",
			number1, number2, number4, number8,
			"Hello,	World",
			"Goodbye cruel World!",
			original,
			chunk);
	   zchunk_destroy (&chunk);

	   number8 = number4 = number2 = number1 = 0;
	   zsock_brecv (server,	"1248sSpc",
			&number1, &number2, &number4, &number8,
			&string, &longstr,
			&pointer,
			&chunk);
	   assert (number1 == 123);
	   assert (number2 == 123 * 123);
	   assert (number4 == 123 * 123	* 123);
	   assert (number8 == 123 * 123	* 123 *	123);
	   assert (streq (string, "Hello, World"));
	   assert (streq (longstr, "Goodbye cruel World!"));
	   assert (pointer == original);
	   assert (zsock_routing_id (server));
	   zstr_free (&longstr);
	   zchunk_destroy (&chunk);

	   //  From server to client
	   chunk = zchunk_new ("World",	5);
	   zsock_bsend (server,	"1248sSpc",
			number1, number2, number4, number8,
			"Hello,	World",
			"Goodbye cruel World!",
			original,
			chunk);
	   zchunk_destroy (&chunk);

	   number8 = number4 = number2 = number1 = 0;
	   zsock_brecv (client,	"1248sSpc",
			&number1, &number2, &number4, &number8,
			&string, &longstr,
			&pointer,
			&chunk);
	   assert (number1 == 123);
	   assert (number2 == 123 * 123);
	   assert (number4 == 123 * 123	* 123);
	   assert (number8 == 123 * 123	* 123 *	123);
	   assert (streq (string, "Hello, World"));
	   assert (streq (longstr, "Goodbye cruel World!"));
	   assert (pointer == original);
	   assert (zsock_routing_id (client) ==	0);
	   zstr_free (&longstr);
	   zchunk_destroy (&chunk);

	   zsock_destroy (&client);
	   zsock_destroy (&server);

	   #else
	   errno = 0;
	   zsock_t* server = zsock_new_server (NULL);
	   assert(server == NULL);
	   assert(errno	== ENOTSUP);

	   errno = 0;
	   zsock_t* client = zsock_new_client (NULL);
	   assert(client == NULL);
	   assert(errno	== ENOTSUP);
	   #endif

	   #ifdef ZMQ_SCATTER

	   zsock_t* gather = zsock_new_gather ("inproc://test-gather-scatter");
	   assert (gather);
	   zsock_t* scatter = zsock_new_scatter	("inproc://test-gather-scatter");
	   assert (scatter);

	   rc =	zstr_send (scatter, "HELLO");
	   assert (rc == 0);

	   char* message;
	   message = zstr_recv (gather);
	   assert (streq(message, "HELLO"));
	   zstr_free (&message);

	   zsock_destroy (&gather);
	   zsock_destroy (&scatter);
	   #else
	   errno = 0;
	   zsock_t* scatter = zsock_new_scatter	(NULL);
	   assert(scatter == NULL);
	   assert(errno	== ENOTSUP);

	   errno = 0;
	   zsock_t* gather = zsock_new_gather (NULL);
	   assert(gather == NULL);
	   assert(errno	== ENOTSUP);
	   #endif

	   #ifndef ZMQ_RADIO
	   errno = 0;
	   zsock_t* radio = zsock_new_radio (NULL);
	   assert(radio	== NULL);
	   assert(errno	== ENOTSUP);

	   errno = 0;
	   zsock_t* dish = zsock_new_dish (NULL);
	   assert(dish == NULL);
	   assert(errno	== ENOTSUP);

	   errno = 0;
	   zsock_t* sock = zsock_new_req (NULL); // any	supported socket type
	   rc =	zsock_join (sock, "group1");
	   assert(rc ==	-1);
	   assert(errno	== ENOTSUP);
	   errno = 0;
	   rc =	zsock_leave (sock, "group1");
	   assert(rc ==	-1);
	   assert(errno	== ENOTSUP);
	   zsock_destroy (&sock);
	   #endif

	   //  Check that we can send a	zproto format message
	   zsock_bsend (writer,	"1111sS4", 0xAA, 0xA0, 0x02, 0x01, "key", "value", 1234);
	   zgossip_msg_t *gossip = zgossip_msg_new ();
	   zgossip_msg_recv (gossip, reader);
	   assert (zgossip_msg_id (gossip) == ZGOSSIP_MSG_PUBLISH);
	   zgossip_msg_destroy (&gossip);

	   zsock_destroy (&reader);
	   zsock_destroy (&writer);

	   #ifdef ZMQ_DGRAM
	   // ZMQ_DGRAM	ipv4 unicast test
	   zsock_t* dgramr = zsock_new_dgram ("udp://*:7777");
	   assert (dgramr);
	   assert ( streq( "DGRAM", zsys_sockname(ZMQ_DGRAM)) );
	   //zsock_t* dgrams = zsock_new_dgram ("udp://*:*");
	   zsock_t* dgrams = zsock_new (ZMQ_DGRAM);
	   zsock_bind (dgrams, "udp://127.0.0.1:7778" );

	   assert (dgrams);
	   // perhaps sleep a little for sockets to setup?

	   rc =	zstr_sendm( dgrams, "127.0.0.1:7777" );
	   assert (rc == 0);
	   rc =	zstr_send (dgrams, "HELLO");
	   assert (rc == 0);

	   char	*dmessage, *addr;

	   zmsg_t *dmsg	= zmsg_recv( dgramr );
	   assert (dmsg);
	   addr	= zmsg_popstr (dmsg);
	   dmessage = zmsg_popstr (dmsg);
	   assert (streq(dmessage, "HELLO"));
	   zmsg_destroy	( &dmsg	);
	   zsock_destroy (&dgrams);
	   zsock_destroy (&dgramr);
	   zstr_free (&dmessage);
	   zstr_free (&addr);
	   zstr_free (&message);

	   // ZMQ_DGRAM	ipv4 multicast test
	   zsock_t* mdgramr = zsock_new_dgram ("udp://225.25.25.25:7777");
	   assert (mdgramr);
	   zsock_t* mdgrams = zsock_new_dgram ("udp://*:*");
	   assert (mdgrams);

	   rc =	zstr_sendm( mdgrams, "225.25.25.25:7777" );
	   assert (rc == 0);
	   rc =	zstr_send (mdgrams, "HELLO");
	   assert (rc == 0);

	   char	*mdmessage, *maddr;

	   zmsg_t *mdmsg = zmsg_recv( mdgramr );
	   assert (mdmsg);
	   maddr = zmsg_popstr (mdmsg);
	   mdmessage = zmsg_popstr (mdmsg);
	   assert (streq(mdmessage, "HELLO"));
	   zmsg_destroy	( &mdmsg );
	   zsock_destroy (&mdgrams);
	   zsock_destroy (&mdgramr);
	   zstr_free (&mdmessage);
	   zstr_free (&maddr);
	   zstr_free (&mdmessage);

	   //	 // ipv6 (not supported	yet)
	   //	 zsys_set_ipv6(1);
	   //	 zsock_t* dgramr6 = zsock_new_dgram ("udp://*:7777");
	   //	 assert	(dgramr6);
	   //	 zsock_t* dgrams6 = zsock_new_dgram ("udp://*:*");
	   //	 assert	(dgrams6);
	   //	 // perhaps sleep a little for sockets to setup?
	   //	 zclock_sleep(100);

	   //	 rc = zstr_sendm( dgrams6, "::1:7777" );
	   //	 assert	(rc == 0);
	   //	 rc = zstr_send	(dgrams6, "HELLO");
	   //	 assert	(rc == 0);

	   //	 char *dmessage6, *addr6;
	   //	 zmsg_t	*dmsg6 = zmsg_recv( dgramr6 );
	   //	 assert	(dmsg6);
	   //	 addr6 = zmsg_popstr (dmsg6);
	   //	 dmessage6 = zmsg_popstr(dmsg6);
	   //	 assert	(streq(dmessage6, "HELLO"));
	   //	 zmsg_destroy( &dmsg6 );
	   //	 zsock_destroy (&dgrams6);
	   //	 zsock_destroy (&dgramr6);

	   //	 zstr_free (&dmessage6);
	   //	 zstr_free (&addr6);
	   //	 zstr_free (&dmessage6);
	   #endif

AUTHORS
       The czmq	manual was written by the authors in the AUTHORS file.

RESOURCES
       Main web	site:

       Report bugs to the email	<zeromq-dev@lists.zeromq.org[1]>

COPYRIGHT
       Copyright (c) the Contributors as noted in the AUTHORS file. This file
       is part of CZMQ,	the high-level C binding for 0MQ:
       http://czmq.zeromq.org. This Source Code	Form is	subject	to the terms
       of the Mozilla Public License, v. 2.0. If a copy	of the MPL was not
       distributed with	this file, You can obtain one at
       http://mozilla.org/MPL/2.0/. LICENSE included with the czmq
       distribution.

NOTES
	1. zeromq-dev@lists.zeromq.org
	   mailto:zeromq-dev@lists.zeromq.org

CZMQ 4.2.1			  11/01/2025			      ZSOCK(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=zsock&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help