laag-libczmq 4.1.0.0

data/vendor/github.com/zeromq/czmq/src/zargs.c

@@ -0,0 +1,289 @@
+/*  =========================================================================
+    zargs - Platform independent command line argument parsing helpers
+
+    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/.           
+    =========================================================================
+*/
+
+/*
+@header
+    zargs - Platform independent command line argument parsing helpers
+
+    Platform independent command line argument parsing helpers
+
+    There are two kind of elements provided by this class
+    foo --named-parameter --parameter with_value positional arguments -a gain-parameter
+    zargs keeps poision only for arguments, parameters are to be accessed like hash.
+
+    It DOES:
+    * provide easy to use CLASS compatible API for accessing argv
+    * is platform independent
+    * provide getopt_long style -- argument, which delimits parameters from arguments
+    * makes parameters positon independent
+
+    It does NOT
+    * change argv
+    * provide a "declarative" way to define command line interface
+
+    In future it SHALL
+    * hide several formats of command line to one (-Idir, --include=dir,
+      --include dir are the same from API pov)
+@discuss
+@end
+*/
+
+#include "czmq_classes.h"
+
+//  Structure of our class
+static char *ZARG_PARAM_EMPTY = "";
+
+struct _zargs_t {
+    char *progname;	 // program name aka argv [0]
+    zlist_t *arguments;  // positional arguments
+    zhash_t *parameters; // --named parameters
+};
+
+
+//  --------------------------------------------------------------------------
+//  Create a new zargs
+
+zargs_t *
+zargs_new (int argc, char **argv)
+{
+    assert (argc > 0);
+    assert (argv);
+    zargs_t *self = (zargs_t *) zmalloc (sizeof (zargs_t));
+    assert (self);
+    //  Initialize class properties here
+    self->progname = argv [0];
+    assert (self->progname);
+    self->arguments = zlist_new ();
+    assert (self->arguments);
+    self->parameters = zhash_new ();
+    assert (self->parameters);
+
+    if (argc == 1)
+        return self;
+
+    int idx = 1;
+    bool params_only = false;
+    while (argv [idx]) {
+        if (params_only || argv [idx][0] != '-')
+            zlist_append (self->arguments, argv [idx]);
+        else {
+	    if (streq (argv [idx], "--")) {
+	        params_only = true;
+            idx ++;
+            continue;
+	    }
+	    else
+            if (argv [idx+1] && argv [idx+1][0] != '-') {
+                zhash_insert (self->parameters, argv [idx], argv [idx+1]);
+                idx ++;
+            }
+            else {
+                zhash_insert (self->parameters, argv [idx], ZARG_PARAM_EMPTY);
+            }
+        }
+        idx ++;
+    }
+
+    return self;
+}
+
+//  --------------------------------------------------------------------------
+//  Destroy the zargs
+
+void
+zargs_destroy (zargs_t **self_p)
+{
+    assert (self_p);
+    if (*self_p) {
+        zargs_t *self = *self_p;
+        //  Free class properties here
+        //  Free object itself
+        zlist_destroy (&self->arguments);
+        zhash_destroy (&self->parameters);
+        free (self);
+        *self_p = NULL;
+    }
+}
+
+//  --------------------------------------------------------------------------
+//  Return the program name (argv[0]) 
+
+const char *
+zargs_progname (zargs_t *self) {
+    assert (self);
+    return self->progname;
+}
+
+//  --------------------------------------------------------------------------
+//  Return the number of command line arguments
+
+size_t
+zargs_arguments (zargs_t *self) {
+    assert (self);
+    return zlist_size (self->arguments);
+}
+
+//  --------------------------------------------------------------------------
+//  Return first command line argument
+
+const char *
+zargs_first (zargs_t *self) {
+    assert (self);
+    return (const char*) zlist_first (self->arguments);
+}
+
+//  --------------------------------------------------------------------------
+//  Return next command line argument
+
+const char *
+zargs_next (zargs_t *self) {
+    assert (self);
+    return (const char*) zlist_next (self->arguments);
+}
+
+//  --------------------------------------------------------------------------
+//  Return first command line parameter value
+
+const char *
+zargs_param_first (zargs_t *self) {
+    assert (self);
+    return (const char*) zhash_first (self->parameters);
+}
+
+//  --------------------------------------------------------------------------
+//  Return next command line parameter value
+
+const char *
+zargs_param_next (zargs_t *self) {
+    assert (self);
+    return (const char*) zhash_next (self->parameters);
+}
+
+//  --------------------------------------------------------------------------
+//  Return current command line parameter name
+
+const char *
+zargs_param_name (zargs_t *self) {
+    assert (self);
+    return (const char*) zhash_cursor (self->parameters);
+}
+
+//  --------------------------------------------------------------------------
+//	Return value of named parameter, NULL if no given parameter has
+//	been specified, or special value for wich zargs_param_empty ()
+//	returns true.
+
+const char *
+zargs_param_lookup (zargs_t *self, const char *name) {
+    assert (self);
+    assert (name);
+    const char *ret = NULL;
+    ret = (const char*) zhash_lookup (self->parameters, name);
+    return ret;
+}
+
+//  --------------------------------------------------------------------------
+//	Return value of named parameter(s), NULL if no given parameter has
+//	been specified, or special value for wich zargs_param_empty ()
+//	returns true.
+
+const char *
+zargs_param_lookupx (zargs_t *self, const char *name, ...) {
+    assert (self);
+    const char *ret = NULL;
+    va_list args;
+    va_start (args, name);
+    while (name) {
+        ret = zargs_param_lookup (self, name);
+	    if (ret)
+	        break;
+	    name = va_arg (args, const char *);
+    }
+    va_end (args);
+    return ret;
+}
+
+//  --------------------------------------------------------------------------
+
+bool
+zargs_has_help (zargs_t *self) {
+    return zargs_param_lookupx (self, "--help", "-h", NULL) != NULL;
+}
+
+//  --------------------------------------------------------------------------
+//  check if argument had a value or not
+
+bool
+zargs_param_empty (const char* arg) {
+    return arg && arg == ZARG_PARAM_EMPTY;
+}
+
+//  --------------------------------------------------------------------------
+//  Print the zargs instance
+
+void
+zargs_print (zargs_t *self) {
+    assert (self);
+    fprintf (stderr, "%s ", self->progname);
+    for (const char *pvalue = zargs_param_first (self);
+                    pvalue != NULL;
+                    pvalue = zargs_param_next (self)) {
+        const char *pname = zargs_param_name (self);
+        if (pvalue == ZARG_PARAM_EMPTY)
+            fprintf (stderr, "%s : None ", pname);
+        else
+            fprintf (stderr, "%s : %s ", pname, pvalue);
+	fprintf (stderr, ", ");
+    }
+    for (const char *arg = zargs_first (self);
+                     arg != NULL;
+                     arg = zargs_next (self)) {
+        fprintf (stderr, "%s ", arg);
+    }
+    fputs ("", stderr);
+}
+//  --------------------------------------------------------------------------
+//  Self test of this class
+
+void
+zargs_test (bool verbose)
+{
+    zsys_init ();
+    printf (" * zargs: ");
+
+    //  @selftest
+    //  Simple create/destroy test
+    
+    char *argv1[] = {"progname", "--named1", "-n1", "val1", "positional1", "--with", "value", "--with2=value2", "-W3value3", "--", "--thisis", "considered", "positional", NULL};
+
+    zargs_t *self = zargs_new (13, argv1);
+    assert (self);
+
+    assert (streq (zargs_progname (self), "progname"));
+    assert (streq (zargs_first (self), "positional1"));
+    assert (streq (zargs_next (self), "--thisis"));
+    assert (streq (zargs_next (self), "considered"));
+    assert (streq (zargs_next (self), "positional"));
+    assert (!zargs_next (self));
+
+    assert (zargs_param_empty (zargs_param_lookup (self, "--named1")));
+    assert (!zargs_param_empty (zargs_param_lookup (self, "-n1")));
+    assert (streq (zargs_param_lookupx (self, "--not at all", "-n1", NULL), "val1"));
+    // TODO: this does not look like an easy hack w/o allocating extra memory
+    //       ???
+    //assert (streq (zargs_param_lookup (self, "--with", NULL), "value2"));
+
+    zargs_destroy (&self);
+    //  @end
+    printf ("OK\n");
+}

data/vendor/github.com/zeromq/czmq/src/zarmour.c

@@ -0,0 +1,941 @@
+/*  =========================================================================
+    zarmour - armoured text encoding and decoding
+
+    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/.
+    =========================================================================
+*/
+
+/*
+@header
+    zarmour - armoured text encoding and decoding
+@discuss
+    The zarmour class implements encoding and decoding of armoured text data.
+    The following codecs are implemented:
+    * RFC 4648 (http://www.ietf.org/rfc/rfc4648.txt)
+      - base64
+      - base64url
+      - base32
+      - base32hex
+      - base16
+    * Z85 (http://rfc.zeromq.org/spec:32)
+    All RFC4648 base64 and base32 variants support padding the output. The pad
+    character is configurable. Default is padding on, with character '='.
+    Additionally, in some cases (e.g. MIME), splitting the output into lines of a
+    specific length is required. This feature is also supported, though
+    turned off by default.
+    The z85 mode does neither padding nor line breaks; it is merely a wrapping
+    of the corresponding libzmq methods. Encoding will assert if input length is
+    not divisible by 4 and decoding will assert if input length is not
+    divisible by 5.
+@end
+*/
+
+#include "czmq_classes.h"
+
+#if (ZMQ_VERSION >= ZMQ_MAKE_VERSION (3, 3, 0))
+#   define _INCLUDE_Z85
+#endif
+
+//  Structure of our class
+
+struct _zarmour_t {
+    int mode;                   //  The current mode (Base64/32/16/Z85, STD/URL)
+    bool pad;                   //  Should output be padded?
+    char pad_char;              //  The pad character
+    bool line_breaks;           //  Should output be broken into lines?
+    size_t line_length;         //  The line length to use
+    char *line_end;
+};
+
+
+//  Textual names of modes
+
+static char
+*s_mode_names [] = {
+    "base64", "base64url", "base32", "base32hex", "base16", "z85"
+};
+
+
+//  --------------------------------------------------------------------------
+//  Create a new zarmour
+
+zarmour_t *
+zarmour_new (void)
+{
+    zarmour_t *self = (zarmour_t *) zmalloc (sizeof (zarmour_t));
+    assert (self);
+
+    //  Setup default as RFC4648 paragraph 4
+    self->mode = ZARMOUR_MODE_BASE64_STD;
+    self->pad = true;
+    self->pad_char = '=';
+    self->line_breaks = false;
+    self->line_length = 72;
+    self->line_end = strdup ("\n");
+    assert (self->line_end);
+    return self;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Destroy the zarmour
+
+void
+zarmour_destroy (zarmour_t **self_p)
+{
+    assert (self_p);
+    if (*self_p) {
+        zarmour_t *self = *self_p;
+        freen (self->line_end);
+        freen (self);
+        *self_p = NULL;
+    }
+}
+
+
+//  --------------------------------------------------------------------------
+//  Helper macros for encoding/decoding
+
+#define _NO_CONVERT(c) (c)
+#define _UPPER_CASE(c) ((c) & ((c) & 0x40? 0xdf: 0xff))
+
+#define _NEXT_CHAR(i, n, c, a, u) \
+    while ((n) < (c) && !strchr ((a), (u (*(n))))) \
+        ++ (n); \
+    (i) = (byte) ((n) < (c)? (strchr ((a), (u (*(n)))) - (a)): 0xff); \
+    ++ (n)
+
+
+//  RFC 4648 Paragraph 4 (standard base64 alphabet)
+static char  //        0----5----0----5----0----5----0----5----0----5----0----5----0---
+s_base64_alphabet [] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+//  RFC 4648 Paragraph 5 (URL & filename friendly base64 alphabet)
+static char  //           0----5----0----5----0----5----0----5----0----5----0----5----0---
+s_base64url_alphabet [] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+
+static char *
+s_base64_encode (const byte *data, size_t length, const char *alphabet, bool pad, char pad_char)
+{
+    size_t extra_chars = ((length % 3)? length % 3 + 1: 0);
+    size_t pad_chars = (pad && extra_chars)? 4 - extra_chars: 0;
+    size_t str_chars = 4 *(length / 3) + extra_chars + pad_chars;
+    char *str = (char *) zmalloc (str_chars + 1);
+    if (!str)
+        return NULL;
+
+    char *enc = str;
+    const byte *needle = data, *ceiling = data + length;
+    while (needle < ceiling) {
+        *enc++ = alphabet [(*needle) >> 2];
+        if (needle + 1 < ceiling) {
+            *enc++ = alphabet [((*needle << 4) & 0x30) | (*(needle + 1) >> 4)];
+            if (needle + 2 < ceiling) {
+                *enc++ = alphabet [((*(needle + 1) << 2) & 0x3c) | (*(needle + 2) >> 6)];
+                *enc++ = alphabet [*(needle + 2) & 0x3f];
+            }
+            else
+                *enc++ = alphabet [(*(needle + 1) << 2) & 0x3c];
+        }
+        else
+            *enc++ = alphabet [(*needle << 4) & 0x30];
+        needle += 3;
+    }
+    while (pad && enc < str + str_chars)
+        *enc++ = pad_char;
+    *enc = 0;
+    return str;
+}
+
+
+static byte *
+s_base64_decode (const char *data, size_t *size, const char *alphabet, size_t linebreakchars)
+{
+    size_t length = strlen (data);
+    while (length > 0 && !strchr (alphabet, data [length - 1]))
+        --length;
+    const byte *needle = (const byte *) data;
+    const byte *ceiling = (const byte *) (data + length);
+
+    length -= linebreakchars;
+    *size = 3 * (length / 4) + ((length % 4)? length % 4 - 1 : 0) + 1;
+    byte *bytes = (byte *) zmalloc (*size);
+    if (!bytes)
+        return NULL;
+
+    byte *dec = bytes;
+    byte i1, i2, i3, i4;
+    while (needle < ceiling) {
+        _NEXT_CHAR (i1, needle, ceiling, alphabet, _NO_CONVERT);
+        _NEXT_CHAR (i2, needle, ceiling, alphabet, _NO_CONVERT);
+        if (i1 != 0xff && i2 != 0xff)
+            *dec++ = i1 << 2 | i2 >> 4;
+        _NEXT_CHAR (i3, needle, ceiling, alphabet, _NO_CONVERT);
+        if (i2 != 0xff && i3 != 0xff)
+            *dec++ = i2 << 4 | i3 >> 2;
+        _NEXT_CHAR (i4, needle, ceiling, alphabet, _NO_CONVERT);
+        if (i3 != 0xff && i4 != 0xff)
+            *dec++ = i3 << 6 | i4;
+    }
+    *dec = 0;
+    return bytes;
+}
+
+
+//  RFC 4648 Paragraph 6 (standard base32 alphabet)
+
+static char  //        0----5----0----5----0----5----0-
+s_base32_alphabet [] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+
+//  RFC 4648 Paragraph 7 (base32hex alphabet)
+
+static char  //           0----5----0----5----0----5----0-
+s_base32hex_alphabet [] = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
+
+static char *
+s_base32_encode (const byte *data, size_t length, const char *alphabet, bool pad, char pad_char)
+{
+    size_t extra_bytes = length % 5, extra_chars = 0;
+    switch (extra_bytes) {
+        case 1: extra_chars = 2; break;
+        case 2: extra_chars = 4; break;
+        case 3: extra_chars = 5; break;
+        case 4: extra_chars = 7; break;
+    }
+    size_t pad_chars = (pad && extra_chars)? 8 - extra_chars: 0;
+    size_t str_chars = 8 *(length / 5) + extra_chars + pad_chars;
+    char *str = (char *) zmalloc (str_chars + 1);
+    if (!str)
+        return NULL;
+
+    char *enc = str;
+    const byte *needle = data, *ceiling = data + length;
+    while (needle < ceiling) {
+        *enc++ = alphabet [(*needle) >> 3];
+        if (needle + 1 < ceiling) {
+            *enc++ = alphabet [((*needle << 2) & 0x1c) | (*(needle + 1) >> 6)];
+            *enc++ = alphabet [(*(needle + 1) >> 1) & 0x1f];
+            if (needle + 2 < ceiling) {
+                *enc++ = alphabet [((*(needle + 1) << 4) & 0x10) | (*(needle + 2) >> 4)];
+                if (needle + 3 < ceiling) {
+                    *enc++ = alphabet [((*(needle + 2) << 1) & 0x1e) | (*(needle + 3) >> 7)];
+                    *enc++ = alphabet [(*(needle + 3) >> 2) & 0x1f];
+                    if (needle + 4 < ceiling) {
+                        *enc++ = alphabet [((*(needle + 3) << 3) & 0x18) | (*(needle + 4) >> 5)];
+                        *enc++ = alphabet [*(needle + 4) & 0x1f];
+                    }
+                    else
+                        *enc++ = alphabet [(*(needle + 3) << 3) & 0x18];
+                }
+                else
+                    *enc++ = alphabet [(*(needle + 2) << 1) & 0x1e];
+            }
+            else
+                *enc++ = alphabet [(*(needle + 1) << 4) & 0x10];
+        }
+        else
+            *enc++ = alphabet [(*needle << 2) & 0x1c];
+        needle += 5;
+    }
+    while (enc < str + str_chars)
+        *enc++ = pad_char;
+    *enc = 0;
+    return str;
+}
+
+
+static byte *
+s_base32_decode (const char *data, size_t *size, const char *alphabet, size_t linebreakchars)
+{
+    size_t length = strlen (data);
+    while (length > 0 && !strchr (alphabet, _UPPER_CASE (data [length - 1]))) --length;
+    const byte *needle = (const byte *) data, *ceiling = (const byte *) (data + length);
+    length -= linebreakchars;
+    size_t extra_chars = length % 8, extra_bytes = 0;
+    switch (extra_chars) {
+        case 0: break;
+        case 2: extra_bytes = 1; break;
+        case 4: extra_bytes = 2; break;
+        case 5: extra_bytes = 3; break;
+        case 7: extra_bytes = 4; break;
+        default: assert (false); break;
+    }
+    *size = 5 *(length / 8) + extra_bytes + 1;
+    byte *bytes = (byte *) zmalloc (*size);
+    if (!bytes)
+        return NULL;
+
+    byte *dec = bytes;
+    byte i1, i2, i3, i4, i5, i6, i7, i8;
+    while (needle < ceiling) {
+        _NEXT_CHAR (i1, needle, ceiling, alphabet, _UPPER_CASE);
+        _NEXT_CHAR (i2, needle, ceiling, alphabet, _UPPER_CASE);
+        if (i1 != 0xff && i2 != 0xff)
+            *dec++ = i1 << 3 | i2 >> 2;
+        _NEXT_CHAR (i3, needle, ceiling, alphabet, _UPPER_CASE);
+        _NEXT_CHAR (i4, needle, ceiling, alphabet, _UPPER_CASE);
+        if (i2 != 0xff && i3 != 0xff && i4 != 0xff)
+            *dec++ = i2 << 6 | i3 << 1 | i4 >> 4;
+        _NEXT_CHAR (i5, needle, ceiling, alphabet, _UPPER_CASE);
+        if (i4 != 0xff && i5 != 0xff)
+            *dec++ = i4 << 4 | i5 >> 1;
+        _NEXT_CHAR (i6, needle, ceiling, alphabet, _UPPER_CASE);
+        _NEXT_CHAR (i7, needle, ceiling, alphabet, _UPPER_CASE);
+        if (i5 != 0xff && i6 != 0xff && i7 != 0xff)
+            *dec++ = i5 << 7 | i6 << 2 | i7 >> 3;
+        _NEXT_CHAR (i8, needle, ceiling, alphabet, _UPPER_CASE);
+        if (i7 != 0xff && i8 != 0xff)
+            *dec++ = i7 << 5 | i8;
+    }
+    *dec = 0;
+    return bytes;
+}
+
+
+//  RFC 4648 Paragraph 8 (standard base16 alphabet)
+
+static char  //        0----5----0----5
+s_base16_alphabet [] = "0123456789ABCDEF";
+
+static char *
+s_base16_encode (const byte *data, size_t length, const char *alphabet)
+{
+    char *str = (char *) zmalloc (2 * length + 1);
+    if (!str)
+        return NULL;
+
+    char *enc = str;
+    const byte *needle = data, *ceiling = data + length;
+    while (needle < ceiling) {
+        *enc++ = alphabet [(*needle) >> 4];
+        *enc++ = alphabet [(*needle++) & 0x0f];
+    }
+    *enc = 0;
+    return str;
+}
+
+static byte *
+s_base16_decode (const char *data, size_t *size, const char *alphabet, size_t linebreakchars)
+{
+    size_t length = strlen (data);
+    const byte *needle = (const byte *) data, *ceiling = (const byte *) (data + length);
+    length -= linebreakchars;
+    *size = length / 2 + 1;
+    byte *bytes = (byte *) zmalloc (*size);
+    if (!bytes)
+        return NULL;
+
+    byte *dec = bytes;
+    byte i1, i2;
+    while (needle < ceiling) {
+        _NEXT_CHAR (i1, needle, ceiling, alphabet, _UPPER_CASE);
+        _NEXT_CHAR (i2, needle, ceiling, alphabet, _UPPER_CASE);
+        if (i1 != 0xff && i2 != 0xff)
+            *dec++ = i1 << 4 | i2;
+    }
+    *dec = 0;
+    return bytes;
+}
+
+
+//  Z85 encoding/decoding
+
+static char *
+s_z85_encode (const byte *data, size_t length)
+{
+    assert (data != NULL);
+    assert (length % 4 == 0);
+#ifdef _INCLUDE_Z85
+    char *str = (char *) zmalloc (5 * length / 4 + 1);
+    char *result = zmq_z85_encode (str, (uint8_t *) data, length);
+    if (result == NULL) {
+        freen (str);
+        str = NULL;
+    }
+    return str;
+#else
+    return NULL;
+#endif
+}
+
+static byte *
+s_z85_decode (const char *data, size_t *size)
+{
+    assert (data);
+    assert (size);
+#ifdef _INCLUDE_Z85
+    size_t length = strlen (data);
+    assert (length % 5 == 0);
+    *size = 4 * length / 5 + 1;
+    byte *bytes = (byte *) zmalloc (*size);
+    uint8_t *result = zmq_z85_decode (bytes, (char *) data);
+    if (result == NULL) {
+        freen (bytes);
+        bytes = NULL;
+    }
+    return bytes;
+#else
+    return NULL;
+#endif
+}
+
+
+//  --------------------------------------------------------------------------
+//  Decode an armoured string into a string of bytes.
+//  The decoded output is null-terminated, so it may be treated
+//  as a string, if that's what it was prior to encoding.
+//  The caller is responsible for destroying the return value when finished with it.
+
+char *
+zarmour_encode (zarmour_t *self, const byte *data, size_t data_size)
+{
+    assert (self);
+    assert (data);
+
+    char *encoded = NULL;
+    switch (self->mode) {
+        case ZARMOUR_MODE_BASE64_STD:
+            encoded = s_base64_encode (data, data_size, s_base64_alphabet, self->pad, self->pad_char);
+            break;
+        case ZARMOUR_MODE_BASE64_URL:
+            encoded = s_base64_encode (data, data_size, s_base64url_alphabet, self->pad, self->pad_char);
+            break;
+        case ZARMOUR_MODE_BASE32_STD:
+            encoded = s_base32_encode (data, data_size, s_base32_alphabet, self->pad, self->pad_char);
+            break;
+        case ZARMOUR_MODE_BASE32_HEX:
+            encoded = s_base32_encode (data, data_size, s_base32hex_alphabet, self->pad, self->pad_char);
+            break;
+        case ZARMOUR_MODE_BASE16:
+            encoded = s_base16_encode (data, data_size, s_base16_alphabet);
+            break;
+        case ZARMOUR_MODE_Z85:
+            encoded = s_z85_encode (data, data_size);
+            break;
+    }
+    if (!encoded)
+        return NULL;
+
+    if (self->line_breaks
+    &&  self->line_length > 0
+    &&  strlen (encoded) > self->line_length
+    &&  self->mode != ZARMOUR_MODE_Z85) {
+        char *line_end = self->line_end;
+        size_t nbr_lines = strlen (encoded) / self->line_length;
+        size_t new_length =
+            nbr_lines *(self->line_length + strlen (line_end)) +
+            strlen (encoded) % self->line_length;
+        char *src = encoded;
+        char *temp = encoded;
+        encoded = (char *) zmalloc (new_length + 1);
+
+        char *dest = encoded;
+        while (strlen (src) >= self->line_length) {
+            memcpy (dest, src, self->line_length);
+            src += self->line_length;
+            dest += self->line_length;
+            if (*src) {
+                memcpy (dest, line_end, strlen (line_end));
+                dest += strlen (line_end);
+            }
+        }
+        if (*src) {
+            memcpy (dest, src, strlen (src));
+            dest += strlen (src);
+        }
+        freen (temp);
+        *dest = 0;
+    }
+    return encoded;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Decode an armoured string into a chunk. The decoded output is
+//  null-terminated, so it may be treated as a string, if that's what
+//  it was prior to encoding.
+//  Caller owns return value and must destroy it when done.
+
+zchunk_t *
+zarmour_decode (zarmour_t *self, const char *data)
+{
+    assert (self);
+    assert (data);
+
+    size_t linebreakchars = 0;
+    char *line_end = self->line_end;
+    const char *pos = data;
+    while ((pos = strstr (pos, line_end))) {
+        linebreakchars += strlen (line_end);
+        pos += strlen (line_end);
+    }
+    byte *decoded = NULL;
+    size_t size = 0;
+
+    switch (self->mode) {
+        case ZARMOUR_MODE_BASE64_STD:
+            decoded = s_base64_decode (data, &size, s_base64_alphabet, linebreakchars);
+            break;
+        case ZARMOUR_MODE_BASE64_URL:
+            decoded = s_base64_decode (data, &size, s_base64url_alphabet, linebreakchars);
+            break;
+        case ZARMOUR_MODE_BASE32_STD:
+            decoded = s_base32_decode (data, &size, s_base32_alphabet, linebreakchars);
+            break;
+        case ZARMOUR_MODE_BASE32_HEX:
+            decoded = s_base32_decode (data, &size, s_base32hex_alphabet, linebreakchars);
+            break;
+        case ZARMOUR_MODE_BASE16:
+            decoded = s_base16_decode (data, &size, s_base16_alphabet, linebreakchars);
+            break;
+        case ZARMOUR_MODE_Z85:
+            decoded = s_z85_decode (data, &size);
+            break;
+    }
+    zchunk_t *ret = zchunk_new (decoded, size);
+    freen (decoded);
+    return ret;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Get the mode property.
+
+int
+zarmour_mode (zarmour_t *self)
+{
+    assert (self);
+    return self->mode;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Get printable string for mode.
+
+const char *
+zarmour_mode_str (zarmour_t *self)
+{
+    assert (self);
+    return s_mode_names [(int) self->mode];
+}
+
+
+//  --------------------------------------------------------------------------
+//  Set the mode property.
+
+void
+zarmour_set_mode (zarmour_t *self, int mode)
+{
+    assert (self);
+    self->mode = mode;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Return true if padding is turned on.
+
+bool
+zarmour_pad (zarmour_t *self)
+{
+    assert (self);
+    return self->pad;
+}
+
+//  --------------------------------------------------------------------------
+//  Turn padding on or off. Default is on.
+
+void
+zarmour_set_pad (zarmour_t *self, bool pad)
+{
+    assert (self);
+    self->pad = pad;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Get the padding character.
+
+char
+zarmour_pad_char (zarmour_t *self)
+{
+    assert (self);
+    return self->pad_char;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Set the padding character.
+
+void
+zarmour_set_pad_char (zarmour_t *self, char pad_char)
+{
+    assert (self);
+    self->pad_char = pad_char;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Return if splitting output into lines is turned on. Default is off.
+
+bool
+zarmour_line_breaks (zarmour_t *self)
+{
+    assert (self);
+    return self->line_breaks;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Turn splitting output into lines on or off.
+
+void
+zarmour_set_line_breaks (zarmour_t *self, bool line_breaks)
+{
+    assert (self);
+    self->line_breaks = line_breaks;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Get the line length used for splitting lines.
+
+size_t
+zarmour_line_length (zarmour_t *self)
+{
+    assert (self);
+    return self->line_length;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Set the line length used for splitting lines.
+
+void
+zarmour_set_line_length (zarmour_t *self, size_t line_length)
+{
+    assert (self);
+    self->line_length = line_length;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Print properties of object
+
+void
+zarmour_print (zarmour_t *self)
+{
+    assert (self);
+
+    zsys_debug ("zarmour:");
+    zsys_debug ("    mode:        %s", zarmour_mode_str (self));
+    zsys_debug ("    pad:         %s", self->pad? "true": "false");
+    zsys_debug ("    pad_char:    '%c'", self->pad_char);
+    zsys_debug ("    line_breaks: %s", self->line_breaks? "true": "false");
+    zsys_debug ("    line_length: %d", self->line_length);
+}
+
+
+//  ---------------------------------------------------------------------------
+//  Self test support functions
+
+static void
+s_armour_decode (zarmour_t *self, const char *test_string, const char *expected, bool verbose)
+{
+    assert (self);
+    assert (test_string);
+    assert (expected);
+
+    zchunk_t *chunk = zarmour_decode (self, test_string);
+    assert (chunk);
+    if (verbose)
+        zsys_debug ("    decoded '%s' into '%s'", test_string, (char *) zchunk_data (chunk));
+    assert (zchunk_size (chunk) == strlen (expected) + 1);
+    assert (streq ((char *) zchunk_data (chunk), expected));
+    zchunk_destroy (&chunk);
+}
+
+static void
+s_armour_test (zarmour_t *self, const char *test_string, const char *expected, bool verbose)
+{
+    assert (self);
+    assert (test_string);
+    assert (expected);
+
+    char *encoded = zarmour_encode (self, (byte *) test_string, strlen (test_string));
+    assert (encoded);
+    if (verbose)
+        zsys_debug ("    encoded '%s' into '%s' ('%s')", test_string, encoded, expected);
+    assert (strlen (encoded) == strlen (expected));
+    assert (streq (encoded, expected));
+    s_armour_decode (self, encoded, test_string, verbose);
+    freen (encoded);
+}
+
+static void
+s_armour_test_long (zarmour_t *self, byte *test_data, size_t length, bool verbose)
+{
+    if (verbose)
+        zarmour_print (self);
+
+    char *test_string = zarmour_encode (self, test_data, length);
+    assert (test_string);
+    if (verbose)
+        zsys_debug ("    encoded %d bytes array to:\n%s", length, test_string);
+
+    zchunk_t *chunk = zarmour_decode (self, test_string);
+    assert (chunk);
+    assert (zchunk_size (chunk) == length + 1);
+    uint index;
+    for (index = 0; index < length; index++)
+        assert (zchunk_data (chunk)[index] == index);
+    zchunk_destroy (&chunk);
+    if (verbose)
+        zsys_debug ("    decoded %d bytes, all match", length);
+    freen (test_string);
+}
+
+
+//  --------------------------------------------------------------------------
+//  Selftest
+
+void
+zarmour_test (bool verbose)
+{
+    printf (" * zarmour: ");
+
+    if (verbose)
+        printf ("\n");
+
+    //  @selftest
+    zarmour_t *self = zarmour_new ();
+    assert (self);
+
+    int mode = zarmour_mode (self);
+    assert (mode == ZARMOUR_MODE_BASE64_STD);
+
+    zarmour_set_mode (self, ZARMOUR_MODE_BASE64_URL);
+    mode = zarmour_mode (self);
+    assert (mode == ZARMOUR_MODE_BASE64_URL);
+
+    assert (zarmour_pad (self));
+    zarmour_set_pad (self, false);
+    assert (!zarmour_pad (self));
+
+    assert (zarmour_pad_char (self) == '=');
+    zarmour_set_pad_char (self, '!');
+    assert (zarmour_pad_char (self) == '!');
+    zarmour_set_pad_char (self, '=');
+    assert (zarmour_pad_char (self) == '=');
+
+    assert (!zarmour_line_breaks (self));
+    zarmour_set_line_breaks (self, true);
+    assert (zarmour_line_breaks (self));
+
+    assert (zarmour_line_length (self) == 72);
+    zarmour_set_line_length (self, 64);
+    assert (zarmour_line_length (self) == 64);
+
+    //  Test against test vectors from RFC4648.
+    zarmour_set_mode (self, ZARMOUR_MODE_BASE64_STD);
+    if (verbose)
+        zarmour_print (self);
+
+    s_armour_test (self, "", "", verbose);
+    s_armour_test (self, "f", "Zg", verbose);
+    s_armour_test (self, "fo", "Zm8", verbose);
+    s_armour_test (self, "foo", "Zm9v", verbose);
+    s_armour_test (self, "foob", "Zm9vYg", verbose);
+    s_armour_test (self, "fooba", "Zm9vYmE", verbose);
+    s_armour_test (self, "foobar", "Zm9vYmFy", verbose);
+    zarmour_set_pad (self, true);
+    if (verbose)
+        zarmour_print (self);
+
+    s_armour_test (self, "", "", verbose);
+    s_armour_test (self, "f", "Zg==", verbose);
+    s_armour_test (self, "fo", "Zm8=", verbose);
+    s_armour_test (self, "foo", "Zm9v", verbose);
+    s_armour_test (self, "foob", "Zm9vYg==", verbose);
+    s_armour_test (self, "fooba", "Zm9vYmE=", verbose);
+    s_armour_test (self, "foobar", "Zm9vYmFy", verbose);
+
+    zarmour_set_pad (self, false);
+    zarmour_set_mode (self, ZARMOUR_MODE_BASE64_URL);
+    if (verbose)
+        zarmour_print (self);
+
+    s_armour_test (self, "", "", verbose);
+    s_armour_test (self, "f", "Zg", verbose);
+    s_armour_test (self, "fo", "Zm8", verbose);
+    s_armour_test (self, "foo", "Zm9v", verbose);
+    s_armour_test (self, "foob", "Zm9vYg", verbose);
+    s_armour_test (self, "fooba", "Zm9vYmE", verbose);
+    s_armour_test (self, "foobar", "Zm9vYmFy", verbose);
+    zarmour_set_pad (self, true);
+    if (verbose)
+        zarmour_print (self);
+
+    s_armour_test (self, "", "", verbose);
+    s_armour_test (self, "f", "Zg==", verbose);
+    s_armour_test (self, "fo", "Zm8=", verbose);
+    s_armour_test (self, "foo", "Zm9v", verbose);
+    s_armour_test (self, "foob", "Zm9vYg==", verbose);
+    s_armour_test (self, "fooba", "Zm9vYmE=", verbose);
+    s_armour_test (self, "foobar", "Zm9vYmFy", verbose);
+
+    zarmour_set_pad (self, false);
+    zarmour_set_mode (self, ZARMOUR_MODE_BASE32_STD);
+    if (verbose)
+        zarmour_print (self);
+
+    s_armour_test (self, "", "", verbose);
+    s_armour_test (self, "f", "MY", verbose);
+    s_armour_test (self, "fo", "MZXQ", verbose);
+    s_armour_test (self, "foo", "MZXW6", verbose);
+    s_armour_test (self, "foob", "MZXW6YQ", verbose);
+    s_armour_test (self, "fooba", "MZXW6YTB", verbose);
+    s_armour_test (self, "foobar", "MZXW6YTBOI", verbose);
+    s_armour_decode (self, "my", "f", verbose);
+    s_armour_decode (self, "mzxq", "fo", verbose);
+    s_armour_decode (self, "mzxw6", "foo", verbose);
+    s_armour_decode (self, "mzxw6yq", "foob", verbose);
+    s_armour_decode (self, "mzxw6ytb", "fooba", verbose);
+    s_armour_decode (self, "mzxw6ytboi", "foobar", verbose);
+    zarmour_set_pad (self, true);
+    if (verbose)
+        zarmour_print (self);
+
+    s_armour_test (self, "", "", verbose);
+    s_armour_test (self, "f", "MY======", verbose);
+    s_armour_test (self, "fo", "MZXQ====", verbose);
+    s_armour_test (self, "foo", "MZXW6===", verbose);
+    s_armour_test (self, "foob", "MZXW6YQ=", verbose);
+    s_armour_test (self, "fooba", "MZXW6YTB", verbose);
+    s_armour_test (self, "foobar", "MZXW6YTBOI======", verbose);
+    s_armour_decode (self, "my======", "f", verbose);
+    s_armour_decode (self, "mzxq====", "fo", verbose);
+    s_armour_decode (self, "mzxw6===", "foo", verbose);
+    s_armour_decode (self, "mzxw6yq=", "foob", verbose);
+    s_armour_decode (self, "mzxw6ytb", "fooba", verbose);
+    s_armour_decode (self, "mzxw6ytboi======", "foobar", verbose);
+
+    zarmour_set_pad (self, false);
+    zarmour_set_mode (self, ZARMOUR_MODE_BASE32_HEX);
+    if (verbose)
+        zarmour_print (self);
+
+    s_armour_test (self, "", "", verbose);
+    s_armour_test (self, "f", "CO", verbose);
+    s_armour_test (self, "fo", "CPNG", verbose);
+    s_armour_test (self, "foo", "CPNMU", verbose);
+    s_armour_test (self, "foob", "CPNMUOG", verbose);
+    s_armour_test (self, "fooba", "CPNMUOJ1", verbose);
+    s_armour_test (self, "foobar", "CPNMUOJ1E8", verbose);
+    s_armour_decode (self, "co", "f", verbose);
+    s_armour_decode (self, "cpng", "fo", verbose);
+    s_armour_decode (self, "cpnmu", "foo", verbose);
+    s_armour_decode (self, "cpnmuog", "foob", verbose);
+    s_armour_decode (self, "cpnmuoj1", "fooba", verbose);
+    s_armour_decode (self, "cpnmuoj1e8", "foobar", verbose);
+    zarmour_set_pad (self, true);
+    if (verbose)
+        zarmour_print (self);
+
+    s_armour_test (self, "", "", verbose);
+    s_armour_test (self, "f", "CO======", verbose);
+    s_armour_test (self, "fo", "CPNG====", verbose);
+    s_armour_test (self, "foo", "CPNMU===", verbose);
+    s_armour_test (self, "foob", "CPNMUOG=", verbose);
+    s_armour_test (self, "fooba", "CPNMUOJ1", verbose);
+    s_armour_test (self, "foobar", "CPNMUOJ1E8======", verbose);
+    s_armour_decode (self, "co======", "f", verbose);
+    s_armour_decode (self, "cpng====", "fo", verbose);
+    s_armour_decode (self, "cpnmu===", "foo", verbose);
+    s_armour_decode (self, "cpnmuog=", "foob", verbose);
+    s_armour_decode (self, "cpnmuoj1", "fooba", verbose);
+    s_armour_decode (self, "cpnmuoj1e8======", "foobar", verbose);
+    zarmour_set_pad (self, true);
+
+    zarmour_set_mode (self, ZARMOUR_MODE_BASE16);
+    if (verbose)
+        zarmour_print (self);
+
+    s_armour_test (self, "", "", verbose);
+    s_armour_test (self, "f", "66", verbose);
+    s_armour_test (self, "fo", "666F", verbose);
+    s_armour_test (self, "foo", "666F6F", verbose);
+    s_armour_test (self, "foob", "666F6F62", verbose);
+    s_armour_test (self, "fooba", "666F6F6261", verbose);
+    s_armour_test (self, "foobar", "666F6F626172", verbose);
+    s_armour_decode (self, "666f", "fo", verbose);
+    s_armour_decode (self, "666f6f", "foo", verbose);
+    s_armour_decode (self, "666f6f62", "foob", verbose);
+    s_armour_decode (self, "666f6f6261", "fooba", verbose);
+    s_armour_decode (self, "666f6f626172", "foobar", verbose);
+
+#ifdef _INCLUDE_Z85
+    //  Z85 test is homemade; using 0, 4 and 8 bytes, with precalculated
+    //  test vectors created with a libzmq test.
+    //  ----------------------------------------------------------------
+
+    //  Make a fake curve key from hex (base16) string, making sure
+    //  there are no null bytes inside, so we can use our test utility
+    zarmour_set_mode (self, ZARMOUR_MODE_BASE16);
+    zarmour_set_line_breaks (self, false);
+
+    zchunk_t *chunk = zarmour_decode (self,
+        "4E6F87E2FB6EB22A1EF5E257B75D79124949565F0B8B36A878A4F03111C96E0B");
+    assert (chunk);
+
+    zarmour_set_mode (self, ZARMOUR_MODE_Z85);  //  Z85 mode does not support padding or line breaks
+    zarmour_set_pad (self, false);              //  so these two are superfluous;
+    zarmour_set_line_breaks (self, false);      //  just for consistency
+    if (verbose)
+        zarmour_print (self);
+
+    s_armour_test (self, "", "", verbose);
+    s_armour_test (self, "foob", "w]zP%", verbose);
+    s_armour_test (self, "foobar!!", "w]zP%vr9Im", verbose);
+    s_armour_test (self, (char *) zchunk_data (chunk),
+                   "ph+{E}!&X?9}!I]W{sm(nL8@&3Yu{wC+<*-5Y[[#", verbose);
+    zchunk_destroy (&chunk);
+#endif
+
+    //  Armouring longer byte array to test line breaks
+    zarmour_set_pad (self, true);
+    zarmour_set_line_breaks (self, true);
+    byte test_data [256];
+    int index;
+    for (index = 0; index < 256; index++)
+        test_data [index] = index;
+
+    zarmour_set_mode (self, ZARMOUR_MODE_BASE64_STD);
+    s_armour_test_long (self, test_data, 256, verbose);
+    zarmour_set_mode (self, ZARMOUR_MODE_BASE64_URL);
+    s_armour_test_long (self, test_data, 256, verbose);
+    zarmour_set_mode (self, ZARMOUR_MODE_BASE32_STD);
+    s_armour_test_long (self, test_data, 256, verbose);
+    zarmour_set_mode (self, ZARMOUR_MODE_BASE32_HEX);
+    s_armour_test_long (self, test_data, 256, verbose);
+    zarmour_set_mode (self, ZARMOUR_MODE_BASE16);
+    s_armour_test_long (self, test_data, 256, verbose);
+#ifdef _INCLUDE_Z85
+    zarmour_set_mode (self, ZARMOUR_MODE_Z85);
+    s_armour_test_long (self, test_data, 256, verbose);
+#endif
+
+    zarmour_destroy (&self);
+
+#if defined (__WINDOWS__)
+    zsys_shutdown();
+#endif
+    //  @end
+
+    printf ("OK\n");
+}