zlist_t *l = zlist_new();
char *s = "hi";
zlist_append(l,s);
printf("%s\n", (char*) zlist_head(l));
printf("%s\n", (char*) zlist_next(l));
printf("%s\n", (char*) zlist_head(l));
printf("%s\n", (char*) zlist_next(l));

 CZMQ: 1.4.0
 ZMQ: 3.2.3

 Example: https://gist.github.com/JustonDavies/5265283

E: (UDP) error 'No such device or address' on siocgifaddr
Assertion failed: false, file zbeacon.c, line 528, function s_handle_io_error

E: (UDP) error 'Error 0' on wlan0 not exist 
Assertion failed: false, file zbeacon.c, line 528, function s_handle_io_error

cc1: warnings being treated as errors
In file included from ../include/czmq_prelude.h:32,
                from zclock.c:45:
/home/jenkins/install/libzmq/gcc/include/zmq.h:342: error: ‘struct iovec’ declared inside parameter list
/home/jenkins/install/libzmq/gcc/include/zmq.h:342: error: its scope is only this definition or declaration, which is probably not what you want
/home/jenkins/install/libzmq/gcc/include/zmq.h:343: error: ‘struct iovec’ declared inside parameter list

testclose: zsockopt.c:888: zsocket_set_linger: Assertion `rc == 0 || (*__errno_location ()) == (156384712 + 53)' failed.
zsh: abort (core dumped)  ./testclose

CZMQ_EXPORT byte *  zcert_secret_key (zcert_t *self);

  zcert_t *cert = zcert_new ();
  byte *secret = zcert_secret_key(cert);

undefined reference to `zcert_secret_key`

$ grep -r zcert_secret_key src/czmq-2.0.1/*
src/czmq-2.0.1/doc/zcert.3:    zcert_secret_key (zcert_t *self);
src/czmq-2.0.1/doc/zcert.txt:    zcert_secret_key (zcert_t *self);
src/czmq-2.0.1/include/zcert.h:    zcert_secret_key (zcert_t *self);

  zcert_t *cert = zcert_new ();
  byte *secret = zcert_secret(cert);

warning: initialization makes pointer from integer without a cast

  zcert_t *cert = zcert_new ();
  byte *secret = zcert_secret(cert);
  byte *public = zcert_public(cert);
  zcert_t *c = zcert_new_from(secret, public);

$ gdb ./cert 
GNU gdb 6.1.1 [FreeBSD]
Copyright 2004 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB.  Type "show warranty" for details.
This GDB was configured as "amd64-marcel-freebsd"...
(gdb) run
Starting program: cert 
[New LWP 100239]
[New Thread 802007400 (LWP 100239/cert)]

Program received signal SIGSEGV, Segmentation fault.
[Switching to Thread 802007400 (LWP 100239/cert)]
0x0000000801032816 in memcpy () from /lib/libc.so.7
(gdb) bt
#0  0x0000000801032816 in memcpy () from /lib/libc.so.7
#1  0x00000008008557ef in zcert_new_from (public_key=0x20180e0 <Error reading address 0x20180e0: Bad address>, 
    secret_key=0x20180c0 <Error reading address 0x20180c0: Bad address>) at zcert.c:99
#2  0x0000000000400a86 in main () at cert.c:33

  zcert_t *cert = zcert_new ();
  byte *secret = cert->secret_key;

error: dereferencing pointer to incomplete type

  zcert_t *cert = zcert_new ();
  uint8_t secret [32];
  uint8_t public [32];
  zmq_z85_decode(secret, zcert_secret_txt(cert));
  zmq_z85_decode(public, zcert_public_txt(cert));
  printf("1st:\ns: %s\np: %s\n", zcert_secret_txt(cert), zcert_public_txt(cert));
  zcert_t *c = zcert_new_from(public, secret);
  printf("\nRecreated:\ns: %s\np: %s\n", zcert_secret_txt(c), zcert_public_txt(c));

1st:
s: Gkk:]X+6t$Qj(C[z>}0s<6yJR17gN-bDj@zS2F#T
p: >O[snXF!/7d{?4hY0{(D}KuUD7hSB[aKEZGY@&zk

Recreated:
s: Gkk:]X+6t$Qj(C[z>}0s<6yJR17gN-bDj@zS2F#T
p: >O[snXF!/7d{?4hY0{(D}KuUD7hSB[aKEZGY@&zk

self->cursor = prev->next;

self->cursor = prev;

/*
    curve-genkey

    Certificate generator for ZeroMQ CURVE security. Produces two files:

    * id_curve25519        - public certificate
    * id_curve25519.secret - secret certificate

    Copyright (C) 2013 iMatix Corporation 
    Copyright (c) 2013 T.Linden

    Licensed under MIT/X11.

    Permission is hereby granted, free of charge, to any person obtaining 
    a copy of this software and associated documentation files (the 
    "Software"), to deal in the Software without restriction, including 
    without limitation the rights to use, copy, modify, merge, publish, 
    distribute, sublicense, and/or sell copies of the Software, and to 
    permit persons to whom the Software is furnished to do so, subject to
    the following conditions:

    The above copyright notice and this permission notice shall be 
    included in all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
    IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 
    CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
    TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#define _BSD_SOURCE

#include <czmq.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <getopt.h>
#include <termios.h>
#include <openssl/evp.h>

/**
  AES functions is public domain code. 
  from http://saju.net.in/code/misc/openssl_aes.c.txt
  Saju Pillai ([email protected])
**/
#define AES_BLOCK_SIZE 256

/**
 * Create an 256 bit key and IV using the supplied key_data. salt can be added for taste.
 * Fills in the encryption and decryption ctx objects and returns 0 on success
 **/
int aes_init(unsigned char *key_data, int key_data_len, unsigned char *salt, EVP_CIPHER_CTX *e_ctx, EVP_CIPHER_CTX *d_ctx) {
  int i, nrounds = 5;
  unsigned char key[32], iv[32];

  /*
   * Gen key & IV for AES 256 CBC mode. A SHA1 digest is used to hash the supplied key material.
   * nrounds is the number of times the we hash the material. More rounds are more secure but
   * slower.
   */
  i = EVP_BytesToKey(EVP_aes_256_cbc(), EVP_sha1(), salt, key_data, key_data_len, nrounds, key, iv);
  if (i != 32) {
    printf("Key size is %d bits - should be 256 bits\n", i);
    return -1;
  }

  EVP_CIPHER_CTX_init(e_ctx);
  EVP_EncryptInit_ex(e_ctx, EVP_aes_256_cbc(), NULL, key, iv);
  EVP_CIPHER_CTX_init(d_ctx);
  EVP_DecryptInit_ex(d_ctx, EVP_aes_256_cbc(), NULL, key, iv);

  return 0;
}

/*
 * Encrypt *len bytes of data
 * All data going in & out is considered binary (unsigned char[])
 */
unsigned char *aes_encrypt(EVP_CIPHER_CTX *e, unsigned char *plaintext, int *len) {
  /* max ciphertext len for a n bytes of plaintext is n + AES_BLOCK_SIZE -1 bytes */
  int c_len = *len + AES_BLOCK_SIZE, f_len = 0;
  unsigned char *ciphertext = malloc(c_len);

  /* allows reusing of 'e' for multiple encryption cycles */
  EVP_EncryptInit_ex(e, NULL, NULL, NULL, NULL);

  /* update ciphertext, c_len is filled with the length of ciphertext generated,
    *len is the size of plaintext in bytes */
  EVP_EncryptUpdate(e, ciphertext, &c_len, plaintext, *len);

  /* update ciphertext with the final remaining bytes */
  EVP_EncryptFinal_ex(e, ciphertext+c_len, &f_len);

  *len = c_len + f_len;
  return ciphertext;
}

/*
 * Decrypt *len bytes of ciphertext
 */
unsigned char *aes_decrypt(EVP_CIPHER_CTX *e, unsigned char *ciphertext, int *len) {
  /* because we have padding ON, we must allocate an extra cipher block size of memory */
  int p_len = *len, f_len = 0;
  unsigned char *plaintext = malloc(p_len + AES_BLOCK_SIZE);

  EVP_DecryptInit_ex(e, NULL, NULL, NULL, NULL);
  EVP_DecryptUpdate(e, plaintext, &p_len, ciphertext, *len);
  EVP_DecryptFinal_ex(e, plaintext+p_len, &f_len);

  *len = p_len + f_len;
  return plaintext;
}



/*
 * (unportable) functions to turn on/off terminal echo
 * using termios functions. might compile however on
 * most unices, tested on FreeBSD only.
 */

static struct termios stored_settings;

void echo_off() {
  struct termios new_settings;
  tcgetattr(0,&stored_settings);
  new_settings = stored_settings;
  new_settings.c_lflag &= (~ECHO);
  tcsetattr(0,TCSANOW,&new_settings);
}

void echo_on() {
  tcsetattr(0,TCSANOW,&stored_settings);
}


/*
 * read a line from stdin, return without
 * trailing \n or NULL if something went
 * wrong
 */
char *get_stdin() {
  char *line = NULL;
  size_t linecap = 0;
  ssize_t linelen;
  linelen = getline(&line, &linecap, stdin);

  if (linelen < 0) {
    return NULL;
  }
  else {
    line[linelen - 1] = '\0'; // remove newline at end
    return line;
  }
}

/*
 * turn off terminal echo, ask for a passphrase
 * and turn it on again
 */
char * get_passphrase(char *prompt) {
  printf("%s: ", prompt);
  echo_off();
  char *line = get_stdin();
  echo_on();
  printf("\n");
  return line;
}

/*
 * Get and store one header in certificate
 */
static int s_get_meta (zcert_t *cert, char *prompt, char *name) {
    printf ("%s ", prompt);
    char *value = get_stdin();

    if (value == NULL)
      return -1;
    else
      zcert_set_meta (cert, name, value);
    return 0;
}

/*
 * (internal debug) function to print a curve key in hex
 */
void prkey(unsigned char *k) {
  int i;

  for (i = 0;i < 32;++i) printf("%02x",(unsigned int) k[i]);

  printf("\n");
}

/*
 * Encrypt the secret key of the given certificate
 * using AES256. Encryption functions are from OpenSSL's
 * libcrypto.
 */
zcert_t *zcert_encrypt_secret(zcert_t *cert, char *key_data) {
  EVP_CIPHER_CTX en, de;
  unsigned int salt[] = {12345, 54321}; // hardcoded salt for the moment
  int i;
  int key_data_len = strlen(key_data);

  /* gen key and iv. init the cipher ctx object */
  if (aes_init(key_data, key_data_len, (unsigned char *)&salt, &en, &de)) {
    fprintf(stderr, "Couldn't initialize AES cipher\n");
    return NULL;
  }

  /* fetch secret and public keys in raw binary form */
  uint8_t secret [32];
  uint8_t public [32];
  zmq_z85_decode(secret, zcert_secret_txt(cert));
  zmq_z85_decode(public, zcert_public_txt(cert));

  unsigned char *ciphertext;
  int len = 33;

  /* actually encrypt the secret */
  unsigned char *encrypted_secret = aes_encrypt(&en, (unsigned char *)secret, &len);

  //prkey(secret);
  //prkey(encrypted_secret);

  // now, we're cheating:
  // we create a new [fake] certificate with the
  // encrypted key:
  zcert_t *c = zcert_new_from(public, encrypted_secret);

  // copy meta from the original
  zcert_set_meta(c, "name",  zcert_meta(cert, "name"));
  zcert_set_meta(c, "email", zcert_meta(cert, "email"));
  zcert_set_meta(c, "org",   zcert_meta(cert, "org"));

  // tell that this one is encrypted
  zcert_set_meta(c, "aes256-encrypted-secret", "enabled");

  return c;
}


/*
 * Decrypt the secret key of the given certificate
 * using AES256. Encryption functions are from OpenSSL's
 * libcrypto.
 */
zcert_t *zcert_decrypt_secret(zcert_t *cert) {
  EVP_CIPHER_CTX en, de;
  unsigned int salt[] = {12345, 54321}; // hardcoded salt for the moment
  int i;
  char *key_data;
  int key_data_len; // = strlen(key_data);

  /* check if it is encrypted anyway */
  char *aes_meta = zcert_meta(cert, "aes256-encrypted-secret");
  if(strncmp(aes_meta, "enabled", 80) != 0) {
    // nope
    return cert;
  }
  else {
    key_data = get_passphrase("Enter passphrase");
    if(key_data == NULL || strlen(key_data) <= 0) {
      fprintf(stderr, "Sorry, you need to enter a passphrase in order to decrypt the secret key!\n");
      return NULL;
    }
  }

  key_data_len = strlen(key_data);

  /* gen key and iv. init the cipher ctx object */
  if (aes_init(key_data, key_data_len, (unsigned char *)&salt, &en, &de)) {
    fprintf(stderr, "Couldn't initialize AES cipher\n");
    return NULL;
  }

  /* fetch secret and public keys in raw binary form */
  uint8_t secret [32];
  uint8_t public [32];
  zmq_z85_decode(secret, zcert_secret_txt(cert));
  zmq_z85_decode(public, zcert_public_txt(cert));

  unsigned char *ciphertext;
  int len = 33;

  /* actually decrypt the secret */
  unsigned char* clear_secret = (char *)aes_decrypt(&de, secret, &len);
  //prkey(secret);
  //prkey(encrypted_secret);

  // now, we're cheating:
  // we create a new [fake] certificate with the
  // encrypted key:
  zcert_t *c = zcert_new_from(public, clear_secret);

  // copy meta from the original
  zcert_set_meta(c, "name",  zcert_meta(cert, "name"));
  zcert_set_meta(c, "email", zcert_meta(cert, "email"));
  zcert_set_meta(c, "org",   zcert_meta(cert, "org"));

  // tell that this one is encrypted
  zcert_set_meta(c, "aes256-encrypted-secret", "disabled");

  return c;
}



void usage() {
  fprintf(stderr, "Usage: curve-genkey [options]\n");
  fprintf(stderr,  "Options:\n");
  fprintf(stderr,  "  -f <keyfile>    Filename for the key, default: 'id_curve25519'.\n");
  fprintf(stderr,  "  -n <name>       Your name\n");
  fprintf(stderr,  "  -m <mail>       Your email address\n");
  fprintf(stderr,  "  -o <org>        Your organization\n");
  fprintf(stderr,  "  -y              Read private key file and print public key, requires -s\n");
  fprintf(stderr,  "  -s <secretfile> File containing a secret key\n");
  fprintf(stderr,  "  -c              Don't encrypt the secret key (CZMQ default)\n");
  exit(EXIT_FAILURE);
}


int main (int argc, char **argv)  {
  int opt;
  char *filename = "id_curve25519";
  char *secretfile = "";
  char *name     = "";
  char *mail     = "";
  char *org      = "";
  int export     = 0;
  int unsecure   = 0;
  int filenamegiven = 0;

  while (1) {
    opt = getopt(argc, argv, "f:n:m:o:hys:");

    if(opt == -1) {
      break;
    }

    switch (opt)  {
      case 'y':
    export = 1;
    break;
      case 'c':
    unsecure = 1;
    break;
      case 'f':
    filename = optarg;
    filenamegiven = 1;
    break;
      case 's':
    secretfile = optarg;
    break;  
      case 'n':
    name = optarg;
    break;
      case 'm':
    mail = optarg;
    break;
      case 'o':
    org = optarg;
    break;
      case 'h':
    usage();
      default:
    usage();
    }
  }

  if(export) {
    // export the public key from a private one
    if(secretfile[0] != '\0' && filename[0] != '0' && filenamegiven) {
      if(! zfile_exists(secretfile)) {
    fprintf(stderr, "Private key file %s doesn't exist!\n", secretfile);
    return -1;
      }
      else {
    zcert_t *priv      = zcert_load(secretfile);
    zcert_t *privclear = zcert_decrypt_secret(priv); // might return the same if unencrypted
    zcert_save_public(privclear, filename);
    printf ("Public key from Curve25519 certificate %s exported to %s\n", secretfile, filename);
    return 0;
      }
    }
    else {
      fprintf(stderr, "Parameter -s <secretkeyfile> (input) and -f <publickeyfile> (output) required for -y!\n");
      return -1;
    }
  }

  /* make sure we don't destroy something */
  if(zfile_exists(filename)) {
    printf("Key file %s already exists. Overwrite [Ny]? ", filename);
    char *c = get_stdin();
    if(strncmp(c, "y", 80) != 0) {
      printf("abort\n");
      return 0;
    }
  }

  printf ("Creating new Curve25519 certificate %s\n", filename);

  zcert_t *cert = zcert_new ();

  if(name[0] == '\0') {
    if(s_get_meta (cert, "Enter your full name:", "name"))
      return -1;
  }
  else {
    zcert_set_meta(cert, "name", name);
  }

  if(mail[0] == '\0') {
    if(s_get_meta (cert, "Enter your email address:", "email"))
      return -1;
  }
  else {
    zcert_set_meta(cert, "email", mail);
  }

  if(org[0] == '\0'){
    if(s_get_meta (cert, "Enter your organization:", "organization"))
      return -1;
  }
  else {
    zcert_set_meta(cert, "org", org);
  }

  char *timestr = zclock_timestr ();
  zcert_set_meta (cert, "created-by", "curve-genkey");
  zcert_set_meta (cert, "date-created", timestr);
  free (timestr);

  char *sec = "Unsecure";

  if (unsecure) {
    /* create an original CZMQ cert with unencrypted secret key */
    zcert_save (cert, filename);
  }
  else {
    char *pass1 = get_passphrase("Enter a passphrase, leave empty for unprotected key");
    if(pass1 != NULL && strlen(pass1) > 0) {
      char *pass2 = get_passphrase("                           Enter a passphrase again");
      if(strncmp(pass1, pass2, 80) == 0) {
    zcert_t *encrypted = zcert_encrypt_secret(cert, pass1);
    if(encrypted != NULL) {
      zcert_save (encrypted, filename);
      sec = "Encrypted";
    }
    else {
      return -1;
    }
      }
      else {
    fprintf(stderr, "Passphrases were not identical, please repeat!\n");
    return -1;
      }
    }
    else {
      /* user just pressed enter, so make default CZMQ unencrypted cert */
      zcert_save (cert, filename);
    }
  }

  printf ("%s Curve25519 certificate created in %s and %s_secret\n", sec, filename, filename);

  zcert_destroy (&cert);

  return 0;
}

Assertion failed: (rc == 0 || errno == ETERM), function zsocket_set_linger, file zsockopt.c, line 888.
Abort trap: 6

cc1: warnings being treated as errors
zsocket.c: In function ‘zsocket_disconnect’:
zsocket.c:139: error: implicit declaration of function ‘zmq_disconnect’
make[2]: *** [zsocket.lo] Error 1
make[2]: Leaving directory `<http://build.zero.mq/job/czmq-master_libzmq2-x_GCC-debian/ws/src'>
make[1]: *** [all] Error 2
make[1]: Leaving directory `<http://build.zero.mq/job/czmq-master_libzmq2-x_GCC-debian/ws/src'>
make: *** [all-recursive] Error 1
Build step 'Execute shell' marked build as failure
Skipping Cobertura coverage report as build was not UNSTABLE or better ...

cmake_minimum_required(VERSION 2.8)

project( czmq )

set(SOURCES_files_Source_Files
  src/zbeacon.c
  src/zclock.c
  src/zconfig.c
  src/zctx.c
  src/zfile.c
  src/zframe.c
  src/zhash.c
  src/zlist.c
  src/zloop.c
  src/zmsg.c
  src/zmutex.c
  src/zsocket.c
  src/zsockopt.c
  src/zstr.c
  src/zsys.c
  src/zthread.c
  src/ztree.c
)
source_group("Source Files" FILES ${SOURCES_files_Source_Files})

set(SOURCES_Source_Files
  ${SOURCES_files_Source_Files}
)

set(SOURCES_files_Header_Files
  include/czmq.h
  include/czmq_prelude.h
  include/zbeacon.h
  include/zclock.h
  include/zconfig.h
  include/zctx.h
  include/zfile.h
  include/zframe.h
  include/zhash.h
  include/zlist.h
  include/zloop.h
  include/zmsg.h
  include/zmutex.h
  include/zsocket.h
  include/zsockopt.h
  include/zstr.h
  include/zsys.h
  include/zthread.h
  include/ztree.h
)
source_group("Header Files" FILES ${SOURCES_files_Header_Files})

set(SOURCES_Header_Files
  ${SOURCES_files_Header_Files}
)

set(SOURCES_
  ${SOURCES_Source_Files}
  ${SOURCES_Header_Files}
)

set( WITH_LIBZMQ . )

include_directories(
  ../libzmq/include
  include
  ${CMAKE_INSTALL_PREFIX}/include
  ${WITH_LIBZMQ}
)

set_source_files_properties(${SOURCES_files_Source_Files} PROPERTIES LANGUAGE CXX )

add_library ( czmq ${SOURCES_} )

install ( TARGETS czmq LIBRARY DESTINATION lib ARCHIVE DESTINATION lib )
install ( FILES ${SOURCES_files_Header_Files} DESTINATION include )

$ ./configure --prefix=/usr/local --with-libzmq=/usr/local
$ make
*snip*
make[2]: Entering directory `/g/Dev/czmq-1.3.1/src'
/bin/sh ../libtool --tag=CC   --mode=compile gcc -std=gnu99 -DHAVE_CONFIG_H -I. -I../include  -Werror -Wall -D_REENTRANT -D_THREAD_SAFE   -I/usr/local/include -g -O2 -MT zclock.lo -MD -MP -MF .deps/zclock.Tpo -c -o zclock.lo zclock.c
libtool: compile:  gcc -std=gnu99 -DHAVE_CONFIG_H -I. -I../include -Werror -Wall -D_REENTRANT -D_THREAD_SAFE -I/usr/local/include -g -O2 -MT zclock.lo -MD -MP -MF .deps/zclock.Tpo -c zclock.c  -DDLL_EXPORT -DPIC -o .libs/zclock.o
libtool: compile:  gcc -std=gnu99 -DHAVE_CONFIG_H -I. -I../include -Werror -Wall -D_REENTRANT -D_THREAD_SAFE -I/usr/local/include -g -O2 -MT zclock.lo -MD -MP -MF .deps/zclock.Tpo -c zclock.c -o zclock.o >/dev/null 2>&1
make[2]: *** [zclock.lo] Error 1

zclock.c:70:1: error: 'zclock_sleep' redeclared without dllimport attribute: previous dllimport ignored [-Werror=attributes]
zclock.c:97:1: error: 'zclock_time' redeclared without dllimport attribute: previous dllimport ignored [-Werror=attributes]
zclock.c:117:1: error: 'zclock_log' redeclared without dllimport attribute: previous dllimport ignored [-Werror=attributes]
cc1.exe: all warnings being treated as errors

 ./test
Starting
^CSend to pipe
txt: This text should never be printed to stdout!
zmsg_recv error: Context was terminated
Context was terminated
Exit

#include <czmq.h>
/* CLIENT */
int main (void) {
  zctx_t *ctx = zctx_new ();
  assert (ctx);
  void *client = zsocket_new (ctx, ZMQ_PULL);
  assert (client);
  int rc = zsocket_connect (client, "tcp://127.0.0.1:9000");
  assert (rc == 0);
  char *message = zstr_recv (client);
  assert (streq (message, "Hello"));
  free (message);
  puts ("Ironhouse test OK");
  zctx_destroy (&ctx);
  return 0;
}

#include <czmq.h>
/* SERVER */
int main (void) {
  zctx_t *ctx = zctx_new ();
  assert(ctx);
  zctx_set_linger (ctx, 100);
  zauth_t *auth = zauth_new (ctx);
  assert(auth);
  zauth_set_verbose (auth, true);
  zauth_allow (auth, "127.0.0.2");
  void *server = zsocket_new (ctx, ZMQ_PUSH);
  assert (server);
  int rc = zsocket_bind (server, "tcp://*:9000");
  assert (rc != -1);
  zstr_send (server, "Hello");
  zauth_destroy (&auth);
  zctx_destroy (&ctx);
  return 0;
}