laag-libzmq 4.2.3.0

data/vendor/github.com/zeromq/libzmq/src/zmq_draft.h

@@ -0,0 +1,178 @@
+/*
+    Copyright (c) 2007-2016 Contributors as noted in the AUTHORS file
+
+    This file is part of libzmq, the ZeroMQ core engine in C++.
+
+    libzmq is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License (LGPL) as published
+    by the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    As a special exception, the Contributors give you permission to link
+    this library with independent modules to produce an executable,
+    regardless of the license terms of these independent modules, and to
+    copy and distribute the resulting executable under terms of your choice,
+    provided that you also meet, for each linked independent module, the
+    terms and conditions of the license of that module. An independent
+    module is a module which is not derived from or based on this library.
+    If you modify this library, you must extend this exception to your
+    version of the library.
+
+    libzmq is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+    License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __ZMQ_DRAFT_H_INCLUDED__
+#define __ZMQ_DRAFT_H_INCLUDED__
+
+/******************************************************************************/
+/*  These functions are DRAFT and disabled in stable releases, and subject to */
+/*  change at ANY time until declared stable.                                 */
+/******************************************************************************/
+
+#ifndef ZMQ_BUILD_DRAFT_API
+
+/*  DRAFT Socket types.                                                       */
+#define ZMQ_SERVER 12
+#define ZMQ_CLIENT 13
+#define ZMQ_RADIO 14
+#define ZMQ_DISH 15
+#define ZMQ_GATHER 16
+#define ZMQ_SCATTER 17
+#define ZMQ_DGRAM 18
+
+/*  DRAFT Socket options.                                                     */
+#define ZMQ_GSSAPI_PRINCIPAL_NAMETYPE 90
+#define ZMQ_GSSAPI_SERVICE_PRINCIPAL_NAMETYPE 91
+#define ZMQ_BINDTODEVICE 92
+#define ZMQ_ZAP_ENFORCE_DOMAIN 93
+
+/*  DRAFT 0MQ socket events and monitoring                                    */
+/*  Unspecified system errors during handshake. Event value is an errno.      */
+#define ZMQ_EVENT_HANDSHAKE_FAILED_NO_DETAIL   0x0800 
+/*  Handshake complete successfully with successful authentication (if        *
+ *  enabled). Event value is unused.                                          */
+#define ZMQ_EVENT_HANDSHAKE_SUCCEEDED          0x1000
+/*  Protocol errors between ZMTP peers or between server and ZAP handler.     *
+ *  Event value is one of ZMQ_PROTOCOL_ERROR_*                                */
+#define ZMQ_EVENT_HANDSHAKE_FAILED_PROTOCOL    0x2000
+/*  Failed authentication requests. Event value is the numeric ZAP status     *
+ *  code, i.e. 300, 400 or 500.                                               */
+#define ZMQ_EVENT_HANDSHAKE_FAILED_AUTH        0x4000
+
+#define ZMQ_PROTOCOL_ERROR_ZMTP_UNSPECIFIED 0x10000000
+#define ZMQ_PROTOCOL_ERROR_ZMTP_UNEXPECTED_COMMAND 0x10000001
+#define ZMQ_PROTOCOL_ERROR_ZMTP_INVALID_SEQUENCE 0x10000002
+#define ZMQ_PROTOCOL_ERROR_ZMTP_KEY_EXCHANGE 0x10000003
+#define ZMQ_PROTOCOL_ERROR_ZMTP_MALFORMED_COMMAND_UNSPECIFIED 0x10000011
+#define ZMQ_PROTOCOL_ERROR_ZMTP_MALFORMED_COMMAND_MESSAGE 0x10000012
+#define ZMQ_PROTOCOL_ERROR_ZMTP_MALFORMED_COMMAND_HELLO 0x10000013
+#define ZMQ_PROTOCOL_ERROR_ZMTP_MALFORMED_COMMAND_INITIATE 0x10000014
+#define ZMQ_PROTOCOL_ERROR_ZMTP_MALFORMED_COMMAND_ERROR 0x10000015
+#define ZMQ_PROTOCOL_ERROR_ZMTP_MALFORMED_COMMAND_READY 0x10000016
+#define ZMQ_PROTOCOL_ERROR_ZMTP_MALFORMED_COMMAND_WELCOME 0x10000017
+#define ZMQ_PROTOCOL_ERROR_ZMTP_INVALID_METADATA 0x10000018
+
+// the following two may be due to erroneous configuration of a peer
+#define ZMQ_PROTOCOL_ERROR_ZMTP_CRYPTOGRAPHIC 0x11000001
+#define ZMQ_PROTOCOL_ERROR_ZMTP_MECHANISM_MISMATCH 0x11000002
+
+#define ZMQ_PROTOCOL_ERROR_ZAP_UNSPECIFIED     0x20000000
+#define ZMQ_PROTOCOL_ERROR_ZAP_MALFORMED_REPLY 0x20000001
+#define ZMQ_PROTOCOL_ERROR_ZAP_BAD_REQUEST_ID 0x20000002
+#define ZMQ_PROTOCOL_ERROR_ZAP_BAD_VERSION 0x20000003
+#define ZMQ_PROTOCOL_ERROR_ZAP_INVALID_STATUS_CODE 0x20000004
+#define ZMQ_PROTOCOL_ERROR_ZAP_INVALID_METADATA 0x20000005
+
+/*  DRAFT Context options                                                     */
+#define ZMQ_MSG_T_SIZE 6
+#define ZMQ_THREAD_AFFINITY_CPU_ADD 7
+#define ZMQ_THREAD_AFFINITY_CPU_REMOVE 8
+#define ZMQ_THREAD_NAME_PREFIX 9
+
+/*  DRAFT Socket methods.                                                     */
+int zmq_join (void *s, const char *group);
+int zmq_leave (void *s, const char *group);
+
+/*  DRAFT Msg methods.                                                        */
+int zmq_msg_set_routing_id(zmq_msg_t *msg, uint32_t routing_id);
+uint32_t zmq_msg_routing_id(zmq_msg_t *msg);
+int zmq_msg_set_group(zmq_msg_t *msg, const char *group);
+const char *zmq_msg_group(zmq_msg_t *msg);
+
+/*  DRAFT Msg property names.                                                 */
+#define ZMQ_MSG_PROPERTY_ROUTING_ID    "Routing-Id"
+#define ZMQ_MSG_PROPERTY_SOCKET_TYPE   "Socket-Type"
+#define ZMQ_MSG_PROPERTY_USER_ID       "User-Id"
+#define ZMQ_MSG_PROPERTY_PEER_ADDRESS  "Peer-Address"
+
+/******************************************************************************/
+/*  Poller polling on sockets,fd and thread-safe sockets                      */
+/******************************************************************************/
+
+typedef struct zmq_poller_event_t
+{
+    void *socket;
+#if defined _WIN32
+    SOCKET fd;
+#else
+    int fd;
+#endif
+    void *user_data;
+    short events;
+} zmq_poller_event_t;
+
+void *zmq_poller_new (void);
+int  zmq_poller_destroy (void **poller_p);
+int  zmq_poller_add (void *poller, void *socket, void *user_data, short events);
+int  zmq_poller_modify (void *poller, void *socket, short events);
+int  zmq_poller_remove (void *poller, void *socket);
+int  zmq_poller_wait (void *poller, zmq_poller_event_t *event, long timeout);
+int  zmq_poller_wait_all (void *poller, zmq_poller_event_t *events, int n_events, long timeout);
+
+#if defined _WIN32
+int zmq_poller_add_fd (void *poller, SOCKET fd, void *user_data, short events);
+int zmq_poller_modify_fd (void *poller, SOCKET fd, short events);
+int zmq_poller_remove_fd (void *poller, SOCKET fd);
+#else
+int zmq_poller_add_fd (void *poller, int fd, void *user_data, short events);
+int zmq_poller_modify_fd (void *poller, int fd, short events);
+int zmq_poller_remove_fd (void *poller, int fd);
+#endif
+
+int zmq_socket_get_peer_state (void *socket,
+                               const void *routing_id,
+                               size_t routing_id_size);
+
+/******************************************************************************/
+/*  Scheduling timers                                                         */
+/******************************************************************************/
+
+typedef void (zmq_timer_fn)(int timer_id, void *arg);
+
+void *zmq_timers_new (void);
+int   zmq_timers_destroy (void **timers_p);
+int   zmq_timers_add (void *timers, size_t interval, zmq_timer_fn handler, void *arg);
+int   zmq_timers_cancel (void *timers, int timer_id);
+int   zmq_timers_set_interval (void *timers, int timer_id, size_t interval);
+int   zmq_timers_reset (void *timers, int timer_id);
+long  zmq_timers_timeout (void *timers);
+int   zmq_timers_execute (void *timers);
+
+/******************************************************************************/
+/*  GSSAPI definitions                                                        */
+/******************************************************************************/
+
+/*  GSSAPI principal name types                                               */
+#define ZMQ_GSSAPI_NT_HOSTBASED 0
+#define ZMQ_GSSAPI_NT_USER_NAME 1
+#define ZMQ_GSSAPI_NT_KRB5_PRINCIPAL 2
+
+#endif // ZMQ_BUILD_DRAFT_API
+
+#endif //ifndef __ZMQ_DRAFT_H_INCLUDED__

data/vendor/github.com/zeromq/libzmq/src/zmq_utils.cpp

@@ -0,0 +1,318 @@
+/*
+    Copyright (c) 2007-2017 Contributors as noted in the AUTHORS file
+
+    This file is part of libzmq, the ZeroMQ core engine in C++.
+
+    libzmq is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License (LGPL) as published
+    by the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    As a special exception, the Contributors give you permission to link
+    this library with independent modules to produce an executable,
+    regardless of the license terms of these independent modules, and to
+    copy and distribute the resulting executable under terms of your choice,
+    provided that you also meet, for each linked independent module, the
+    terms and conditions of the license of that module. An independent
+    module is a module which is not derived from or based on this library.
+    If you modify this library, you must extend this exception to your
+    version of the library.
+
+    libzmq is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+    License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "precompiled.hpp"
+
+#include "macros.hpp"
+#include "clock.hpp"
+#include "err.hpp"
+#include "thread.hpp"
+#include "atomic_counter.hpp"
+#include "atomic_ptr.hpp"
+#include "random.hpp"
+#include <assert.h>
+#include <new>
+
+#if !defined ZMQ_HAVE_WINDOWS
+#include <unistd.h>
+#endif
+
+#if defined (ZMQ_USE_TWEETNACL)
+#include "tweetnacl.h"
+#elif defined (ZMQ_USE_LIBSODIUM)
+#include "sodium.h"
+#endif
+
+void zmq_sleep (int seconds_)
+{
+#if defined ZMQ_HAVE_WINDOWS
+    Sleep (seconds_ * 1000);
+#else
+    sleep (seconds_);
+#endif
+}
+
+void *zmq_stopwatch_start ()
+{
+    uint64_t *watch = (uint64_t*) malloc (sizeof (uint64_t));
+    alloc_assert (watch);
+    *watch = zmq::clock_t::now_us ();
+    return (void*) watch;
+}
+
+unsigned long zmq_stopwatch_stop (void *watch_)
+{
+    uint64_t end = zmq::clock_t::now_us ();
+    uint64_t start = *(uint64_t*) watch_;
+    free (watch_);
+    return (unsigned long) (end - start);
+}
+
+void *zmq_threadstart(zmq_thread_fn* func, void* arg)
+{
+    zmq::thread_t* thread = new (std::nothrow) zmq::thread_t;
+    alloc_assert(thread);
+    thread->start(func, arg);
+    return thread;
+}
+
+void zmq_threadclose(void* thread)
+{
+    zmq::thread_t* pThread = static_cast<zmq::thread_t*>(thread);
+    pThread->stop();
+    LIBZMQ_DELETE(pThread);
+}
+
+//  Z85 codec, taken from 0MQ RFC project, implements RFC32 Z85 encoding
+
+//  Maps base 256 to base 85
+static char encoder [85 + 1] = {
+    "0123456789" "abcdefghij" "klmnopqrst" "uvwxyzABCD"
+    "EFGHIJKLMN" "OPQRSTUVWX" "YZ.-:+=^!/" "*?&<>()[]{"
+    "}@%$#"
+};
+
+//  Maps base 85 to base 256
+//  We chop off lower 32 and higher 128 ranges
+//  0xFF denotes invalid characters within this range
+static uint8_t decoder [96] = {
+    0xFF, 0x44, 0xFF, 0x54, 0x53, 0x52, 0x48, 0xFF, 
+    0x4B, 0x4C, 0x46, 0x41, 0xFF, 0x3F, 0x3E, 0x45, 
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
+    0x08, 0x09, 0x40, 0xFF, 0x49, 0x42, 0x4A, 0x47, 
+    0x51, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 
+    0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 
+    0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 
+    0x3B, 0x3C, 0x3D, 0x4D, 0xFF, 0x4E, 0x43, 0xFF, 
+    0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 
+    0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 
+    0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 
+    0x21, 0x22, 0x23, 0x4F, 0xFF, 0x50, 0xFF, 0xFF
+};
+
+//  --------------------------------------------------------------------------
+//  Encode a binary frame as a string; destination string MUST be at least
+//  size * 5 / 4 bytes long plus 1 byte for the null terminator. Returns
+//  dest. Size must be a multiple of 4.
+//  Returns NULL and sets errno = EINVAL for invalid input.
+
+char *zmq_z85_encode (char *dest, const uint8_t *data, size_t size)
+{
+    if (size % 4 != 0) {
+        errno = EINVAL;
+        return NULL;
+    }
+    unsigned int char_nbr = 0;
+    unsigned int byte_nbr = 0;
+    uint32_t value = 0;
+    while (byte_nbr < size) {
+        //  Accumulate value in base 256 (binary)
+        value = value * 256 + data [byte_nbr++];
+        if (byte_nbr % 4 == 0) {
+            //  Output value in base 85
+            unsigned int divisor = 85 * 85 * 85 * 85;
+            while (divisor) {
+                dest [char_nbr++] = encoder [value / divisor % 85];
+                divisor /= 85;
+            }
+            value = 0;
+        }
+    }
+    assert (char_nbr == size * 5 / 4);
+    dest [char_nbr] = 0;
+    return dest;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Decode an encoded string into a binary frame; dest must be at least
+//  strlen (string) * 4 / 5 bytes long. Returns dest. strlen (string)
+//  must be a multiple of 5.
+//  Returns NULL and sets errno = EINVAL for invalid input.
+
+uint8_t *zmq_z85_decode (uint8_t *dest, const char *string)
+{
+    unsigned int byte_nbr = 0;
+    unsigned int char_nbr = 0;
+    uint32_t value = 0;
+    while (string[char_nbr]) {
+        //  Accumulate value in base 85
+        if (UINT32_MAX / 85 < value) {
+            //  Invalid z85 encoding, represented value exceeds 0xffffffff
+            goto error_inval;
+        }
+        value *= 85;
+        uint8_t index = string [char_nbr++] - 32;
+        if (index >= sizeof(decoder)) {
+            //  Invalid z85 encoding, character outside range
+            goto error_inval;
+        }
+        uint32_t summand = decoder [index];
+        if (summand == 0xFF || summand > (UINT32_MAX - value)) {
+            //  Invalid z85 encoding, invalid character or represented value exceeds 0xffffffff
+            goto error_inval;
+        }
+        value += summand;
+        if (char_nbr % 5 == 0) {
+            //  Output value in base 256
+            unsigned int divisor = 256 * 256 * 256;
+            while (divisor) {
+                dest [byte_nbr++] = value / divisor % 256;
+                divisor /= 256;
+            }
+            value = 0;
+        }
+    }
+    if (char_nbr % 5 != 0) {
+        goto error_inval;
+    }
+    assert (byte_nbr == strlen (string) * 4 / 5);
+    return dest;
+
+error_inval:
+    errno = EINVAL;
+    return NULL;
+}
+
+//  --------------------------------------------------------------------------
+//  Generate a public/private keypair with tweetnacl or libsodium.
+//  Generated keys will be 40 byte z85-encoded strings.
+//  Returns 0 on success, -1 on failure, setting errno.
+//  Sets errno = ENOTSUP in the absence of a CURVE library.
+
+int zmq_curve_keypair (char *z85_public_key, char *z85_secret_key)
+{
+#if defined (ZMQ_HAVE_CURVE)
+#   if crypto_box_PUBLICKEYBYTES != 32 \
+    || crypto_box_SECRETKEYBYTES != 32
+#       error "CURVE encryption library not built correctly"
+#   endif
+
+    uint8_t public_key [32];
+    uint8_t secret_key [32];
+
+    zmq::random_open ();
+
+    int res = crypto_box_keypair (public_key, secret_key);
+    zmq_z85_encode (z85_public_key, public_key, 32);
+    zmq_z85_encode (z85_secret_key, secret_key, 32);
+
+    zmq::random_close ();
+
+    return res;
+#else
+    (void) z85_public_key, (void) z85_secret_key;
+    errno = ENOTSUP;
+    return -1;
+#endif
+}
+
+//  --------------------------------------------------------------------------
+//  Derive the public key from a private key using tweetnacl or libsodium.
+//  Derived key will be 40 byte z85-encoded string.
+//  Returns 0 on success, -1 on failure, setting errno.
+//  Sets errno = ENOTSUP in the absence of a CURVE library.
+
+int zmq_curve_public (char *z85_public_key, const char *z85_secret_key)
+{
+#if defined (ZMQ_HAVE_CURVE)
+#   if crypto_box_PUBLICKEYBYTES != 32 \
+    || crypto_box_SECRETKEYBYTES != 32
+#       error "CURVE encryption library not built correctly"
+#   endif
+
+    uint8_t public_key[32];
+    uint8_t secret_key[32];
+
+    zmq::random_open ();
+
+    if (zmq_z85_decode (secret_key, z85_secret_key) == NULL)
+        return -1;
+
+    // Return codes are suppressed as none of these can actually fail.
+    crypto_scalarmult_base (public_key, secret_key);
+    zmq_z85_encode (z85_public_key, public_key, 32);
+
+    zmq::random_close ();
+
+    return 0;
+#else
+    (void) z85_public_key, (void) z85_secret_key;
+    errno = ENOTSUP;
+    return -1;
+#endif
+}
+
+
+//  --------------------------------------------------------------------------
+//  Initialize a new atomic counter, which is set to zero
+
+void *zmq_atomic_counter_new (void)
+{
+    zmq::atomic_counter_t *counter = new (std::nothrow) zmq::atomic_counter_t;
+    alloc_assert (counter);
+    return counter;
+}
+
+//  Se the value of the atomic counter
+
+void zmq_atomic_counter_set (void *counter_, int value_)
+{
+    ((zmq::atomic_counter_t *) counter_)->set (value_);
+}
+
+//  Increment the atomic counter, and return the old value
+
+int zmq_atomic_counter_inc (void *counter_)
+{
+    return ((zmq::atomic_counter_t *) counter_)->add (1);
+}
+
+//  Decrement the atomic counter and return 1 (if counter >= 1), or
+//  0 if counter hit zero.
+
+int zmq_atomic_counter_dec (void *counter_)
+{
+    return ((zmq::atomic_counter_t *) counter_)->sub (1)? 1: 0;
+}
+
+//  Return actual value of atomic counter
+
+int zmq_atomic_counter_value (void *counter_)
+{
+    return ((zmq::atomic_counter_t *) counter_)->get ();
+}
+
+//  Destroy atomic counter, and set reference to NULL
+
+void zmq_atomic_counter_destroy (void **counter_p_)
+{
+    delete ((zmq::atomic_counter_t *) *counter_p_);
+    *counter_p_ = NULL;
+}