git clone git://github.com/zeromq/czmq.git
cd czmq
sh autogen.sh
./configure
make all
sudo make install
sudo ldconfig

./configure --with-zeromq=/usr/local

make check

gcc -lczmq -lzmq myapp.c -o myapp

//  Create new context, returns context object, replaces zmq_init
zctx_t *
    zctx_new (void);

//  Destroy context and all sockets in it, replaces zmq_term
void
    zctx_destroy (zctx_t **self_p);

//  Raise default I/O threads from 1, for crazy heavy applications
void
    zctx_set_iothreads (zctx_t *self, int iothreads);

//  Set msecs to flush sockets when closing them
void
    zctx_set_linger (zctx_t *self, int linger);

//  Create socket within this context, for czmq use only
void *
    zctx__socket_new (zctx_t *self, int type);

//  Destroy socket within this context, for czmq use only
void
    zctx__socket_destroy (zctx_t *self, void *socket);

//  Self test of this class
int
    zctx_test (Bool verbose);

//  Global signal indicator, TRUE when user presses Ctrl-C or the process
//  gets a SIGTERM signal.
extern int zctx_interrupted;

//  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.
//  If the socket is a SUB socket, automatically subscribes to everything.
//  Use this to get automatic management of the socket at shutdown.
void *
    zsocket_new (zctx_t *self, int type);

//  Destroy a socket within our czmq context, replaces zmq_close.
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.
int
    zsocket_bind (void *socket, const char *format, ...);

//  Connect a socket to a formatted endpoint
//  Checks with assertion that the connect was valid
void
    zsocket_connect (void *socket, const char *format, ...);

//  Returns socket type as printable constant string
char *
    zsocket_type_str (void *socket);

//  Self test of this class
int
    zsocket_test (Bool verbose);

#if (ZMQ_VERSION_MAJOR == 2)
//  Get socket options
int  zsockopt_hwm (void *socket);
int  zsockopt_swap (void *socket);
int  zsockopt_affinity (void *socket);
int  zsockopt_rate (void *socket);
int  zsockopt_recovery_ivl (void *socket);
int  zsockopt_recovery_ivl_msec (void *socket);
int  zsockopt_mcast_loop (void *socket);
int  zsockopt_sndbuf (void *socket);
int  zsockopt_rcvbuf (void *socket);
int  zsockopt_linger (void *socket);
int  zsockopt_reconnect_ivl (void *socket);
int  zsockopt_reconnect_ivl_max (void *socket);
int  zsockopt_backlog (void *socket);
int  zsockopt_type (void *socket);
int  zsockopt_rcvmore (void *socket);
int  zsockopt_fd (void *socket);
int  zsockopt_events (void *socket);

//  Set socket options
void zsockopt_set_hwm (void *socket, int hwm);
void zsockopt_set_swap (void *socket, int swap);
void zsockopt_set_affinity (void *socket, int affinity);
void zsockopt_set_identity (void *socket, char * identity);
void zsockopt_set_rate (void *socket, int rate);
void zsockopt_set_recovery_ivl (void *socket, int recovery_ivl);
void zsockopt_set_recovery_ivl_msec (void *socket, int recovery_ivl_msec);
void zsockopt_set_mcast_loop (void *socket, int mcast_loop);
void zsockopt_set_sndbuf (void *socket, int sndbuf);
void zsockopt_set_rcvbuf (void *socket, int rcvbuf);
void zsockopt_set_linger (void *socket, int linger);
void zsockopt_set_reconnect_ivl (void *socket, int reconnect_ivl);
void zsockopt_set_reconnect_ivl_max (void *socket, int reconnect_ivl_max);
void zsockopt_set_backlog (void *socket, int backlog);
void zsockopt_set_subscribe (void *socket, char * subscribe);
void zsockopt_set_unsubscribe (void *socket, char * unsubscribe);
#endif

#if (ZMQ_VERSION_MAJOR == 3)
//  Get socket options
int  zsockopt_sndhwm (void *socket);
int  zsockopt_rcvhwm (void *socket);
int  zsockopt_affinity (void *socket);
int  zsockopt_rate (void *socket);
int  zsockopt_recovery_ivl (void *socket);
int  zsockopt_sndbuf (void *socket);
int  zsockopt_rcvbuf (void *socket);
int  zsockopt_linger (void *socket);
int  zsockopt_reconnect_ivl (void *socket);
int  zsockopt_reconnect_ivl_max (void *socket);
int  zsockopt_backlog (void *socket);
int  zsockopt_maxmsgsize (void *socket);
int  zsockopt_type (void *socket);
int  zsockopt_rcvmore (void *socket);
int  zsockopt_fd (void *socket);
int  zsockopt_events (void *socket);

//  Set socket options
void zsockopt_set_sndhwm (void *socket, int sndhwm);
void zsockopt_set_rcvhwm (void *socket, int rcvhwm);
void zsockopt_set_affinity (void *socket, int affinity);
void zsockopt_set_identity (void *socket, char * identity);
void zsockopt_set_rate (void *socket, int rate);
void zsockopt_set_recovery_ivl (void *socket, int recovery_ivl);
void zsockopt_set_sndbuf (void *socket, int sndbuf);
void zsockopt_set_rcvbuf (void *socket, int rcvbuf);
void zsockopt_set_linger (void *socket, int linger);
void zsockopt_set_reconnect_ivl (void *socket, int reconnect_ivl);
void zsockopt_set_reconnect_ivl_max (void *socket, int reconnect_ivl_max);
void zsockopt_set_backlog (void *socket, int backlog);
void zsockopt_set_maxmsgsize (void *socket, int maxmsgsize);
void zsockopt_set_subscribe (void *socket, char * subscribe);
void zsockopt_set_unsubscribe (void *socket, char * unsubscribe);

//  Emulation of widely-used 2.x socket options
void zsockopt_set_hwm (void *socket, int hwm);
#endif

//  Self test of this class
int zsockopt_test (Bool verbose);

//  Receive a string off a socket, caller must free it
char *
    zstr_recv (void *socket);

//  Receive a string off a socket if socket had input waiting
char *
    zstr_recv_nowait (void *socket);

//  Send a string to a socket in ØMQ string format
int
    zstr_send (void *socket, const char *string);

//  Send a string to a socket in ØMQ string format, with MORE flag
int
    zstr_sendm (void *socket, const char *string);

//  Send a formatted string to a socket
int
    zstr_sendf (void *socket, const char *format, ...);

//  Self test of this class
int
    zstr_test (Bool verbose);

//  Delete file. Does not complain if the file is absent
int
    zfile_delete (char *filename);

//  Make directory (maximum one level depending on OS)
int
    zfile_mkdir (char *dirname);

//  Return 1 if file exists, else zero
int
    zfile_exists (char *filename);

//  Return size of file, or -1 if not found
long
    zfile_size (char *filename);

//  Self test of this class
int
    zfile_test (Bool verbose);

#define ZFRAME_MORE     1
#define ZFRAME_REUSE    2

//  Create a new frame with optional size, and optional data
zframe_t *
    zframe_new (const void *data, size_t size);

//  Destroy a frame
void
    zframe_destroy (zframe_t **self_p);

//  Receive a new frame off the socket
zframe_t *
    zframe_recv (void *socket);

//  Send a frame to a socket, destroy frame after sending
void
    zframe_send (zframe_t **self_p, void *socket, int flags);

//  Return number of bytes in frame data
size_t
    zframe_size (zframe_t *self);

//  Return address of frame data
byte *
    zframe_data (zframe_t *self);

//  Create a new frame that duplicates an existing frame
zframe_t *
    zframe_dup (zframe_t *self);

//  Return frame data encoded as printable hex string
char *
    zframe_strhex (zframe_t *self);

//  Return frame data copied into freshly allocated string
char *
    zframe_strdup (zframe_t *self);

//  Return TRUE if frame body is equal to string, excluding terminator
Bool
    zframe_streq (zframe_t *self, char *string);

//  Return frame 'more' property
int
    zframe_more (zframe_t *self);

//  Return TRUE if two frames have identical size and data
//  If either frame is NULL, equality is always false.
Bool
    zframe_eq (zframe_t *self, zframe_t *other);

//  Print contents of frame to stderr
void
    zframe_print (zframe_t *self, char *prefix);

//  Set new contents for frame
void
    zframe_reset (zframe_t *self, const void *data, size_t size);

//  Self test of this class
int
    zframe_test (Bool verbose);

//  Create a new empty message object
zmsg_t *
    zmsg_new (void);

//  Destroy a message object and all frames it contains
void
    zmsg_destroy (zmsg_t **self_p);

//  Read 1 or more frames off the socket, into a new message object
zmsg_t *
    zmsg_recv (void *socket);

//  Send a message to the socket, and then destroy it
void
    zmsg_send (zmsg_t **self_p, void *socket);

//  Return number of frames in message
size_t
    zmsg_size (zmsg_t *self);

//  Return combined size of all frames in message
size_t
    zmsg_content_size (zmsg_t *self);

//  Push frame to front of message, before first frame
void
    zmsg_push (zmsg_t *self, zframe_t *frame);

//  Pop frame off front of message, caller now owns frame
zframe_t *
    zmsg_pop (zmsg_t *self);

//  Add frame to end of message, after last frame
void
    zmsg_add (zmsg_t *self, zframe_t *frame);

//  Push block of memory as new frame to front of message
void
    zmsg_pushmem (zmsg_t *self, const void *src, size_t size);

//  Push block of memory as new frame to end of message
void
    zmsg_addmem (zmsg_t *self, const void *src, size_t size);

//  Push string as new frame to front of message
void
    zmsg_pushstr (zmsg_t *self, const char *string);

//  Push string as new frame to end of message
void
    zmsg_addstr (zmsg_t *self, const char *string);

//  Pop frame off front of message, return as fresh string
char *
    zmsg_popstr (zmsg_t *self);

//  Push frame to front of message, before first frame
//  Pushes an empty frame in front of frame
void
    zmsg_wrap (zmsg_t *self, zframe_t *frame);

//  Pop frame off front of message, caller now owns frame
//  If next frame is empty, pops and destroys that empty frame.
zframe_t *
    zmsg_unwrap (zmsg_t *self);

//  Remove frame from message, at any position, caller owns it
void
    zmsg_remove (zmsg_t *self, zframe_t *frame);

//  Return first frame in message, or null
zframe_t *
    zmsg_first (zmsg_t *self);

//  Return next frame in message, or null
zframe_t *
    zmsg_next (zmsg_t *self);

//  Return last frame in message, or null
zframe_t *
    zmsg_last (zmsg_t *self);

//  Save message to an open file, return 0 if OK, else -1.
int
    zmsg_save (zmsg_t *self, FILE *file);

//  Load a message from an open file
zmsg_t *
    zmsg_load (FILE *file);

//  Create copy of message, as new message object
zmsg_t *
    zmsg_dup (zmsg_t *self);

//  Print message to stderr, for debugging
void
    zmsg_dump (zmsg_t *self);

//  Self test of this class
int
    zmsg_test (Bool verbose);

//  Callback function for reactor events
typedef int (zloop_fn) (zloop_t *loop, zmq_pollitem_t *item, void *arg);

//  Create a new zloop reactor
zloop_t *
    zloop_new (void);

//  Destroy a reactor
void
    zloop_destroy (zloop_t **self_p);

//  Register a socket reader, on one socket
int
    zloop_poller (zloop_t *self, zmq_pollitem_t *item, zloop_fn handler, void *arg);

//  Cancel the reader on the specified socket or fd, if any
void
    zloop_cancel (zloop_t *self, zmq_pollitem_t *item);

//  Register a timer that will go off after 'delay' msecs, and will
//  repeat 'times' times, unless 'times' is zero, meaning repeat forever.
int
    zloop_timer (zloop_t *self, size_t delay, size_t times, zloop_fn handler, void *arg);

//  Set verbose tracing of reactor on/off
void
    zloop_set_verbose (zloop_t *self, Bool verbose);

//  Start the reactor, ends if a callback function returns -1, or the process
//  received SIGINT or SIGTERM.
int
    zloop_start (zloop_t *self);

//  Self test of this class
int
    zloop_test (Bool verbose);

//  Detached threads follow POSIX pthreads API
typedef void *(zthread_detached_fn) (void *args);

//  Attached threads get context and pipe from parent
typedef void (zthread_attached_fn) (void *args, zctx_t *ctx, void *pipe);

//  Create a detached thread. A detached thread operates autonomously
//  and is used to simulate a separate process. It gets no ctx, and no
//  pipe.
void
    zthread_new (zctx_t *self, zthread_detached_fn *thread_fn, void *args);

//  Create an attached thread. An attached thread gets a ctx and a PAIR
//  pipe back to its parent. It must monitor its pipe, and exit if the
//  pipe becomes unreadable.
void *
    zthread_fork (zctx_t *self, zthread_attached_fn *thread_fn, void *args);

//  Self test of this class
int
    zthread_test (Bool verbose);

//  Callback function for zhash_foreach method
typedef int (zhash_foreach_fn) (char *key, void *item, void *argument);
//  Callback function for zhash_freefn method
typedef void (zhash_free_fn) (void *data);

//  Create a new, empty hash container
zhash_t *
    zhash_new (void);

//  Destroy a hash container and all items in it
void
    zhash_destroy (zhash_t **self_p);

//  Insert an item into the hash container using the specified key
int
    zhash_insert (zhash_t *self, char *key, void *item);

//  Insert or update the item for the specified key
void
    zhash_update (zhash_t *self, char *key, void *item);

//  Destroy the item at the specified key, if any
void
    zhash_delete (zhash_t *self, char *key);

//  Return the item at the specified key, or null
void *
    zhash_lookup (zhash_t *self, char *key);

//  Set a free function for the item at the specified key
void *
    zhash_freefn (zhash_t *self, char *key, zhash_free_fn *free_fn);

//  Return the number of keys/items in the hash table
size_t
    zhash_size (zhash_t *self);

//  Iterate over the hash table and apply the function to each item
int
    zhash_foreach (zhash_t *self, zhash_foreach_fn *callback, void *argument);

//  Self test of this class
void
    zhash_test (int verbose);

//  Create a new list container
zlist_t *
    zlist_new (void);

//  Destroy a list container
void
    zlist_destroy (zlist_t **self_p);

//  Return first item in the list, or null
void *
    zlist_first (zlist_t *self);

//  Return next item in the list, or null
void *
    zlist_next (zlist_t *self);

//  Append an item to the end of the list
void
    zlist_append (zlist_t *self, void *item);

//  Push an item to the start of the list
void
    zlist_push (zlist_t *self, void *item);

//  Pop the item off the start of the list, if any
void *
    zlist_pop (zlist_t *self);

//  Remove the specified item from the list if present
void
    zlist_remove (zlist_t *self, void *item);

//  Copy the entire list, return the copy
zlist_t *
    zlist_copy (zlist_t *self);

//  Return number of items in the list
size_t
    zlist_size (zlist_t *self);

//  Self test of this class
void
    zlist_test (int verbose);

//  Sleep for a number of milliseconds
void
    zclock_sleep (int msecs);

//  Return current system clock as milliseconds
int64_t
    zclock_time (void);

//  Print formatted string to stdout, prefixed by date/time and
//  terminated with a newline.
void
    zclock_log (const char *format, ...);

//  Self test of this class
int
    zclock_test (Bool verbose);

zclassname_methodname

zblob_t *file_buffer;       /*  Buffer for our file */
... (100 lines of code)
file_buffer = zblob_new ();
...

zblob_t *file_buffer = zblob_new ();

int rc = some_function (arguments);
assert (rc == 0);

assert (some_function (arguments) == 0);