laag-libzmq 4.2.3.0

data/vendor/github.com/zeromq/libzmq/src/object.hpp

@@ -0,0 +1,156 @@
+/*
+    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_OBJECT_HPP_INCLUDED__
+#define __ZMQ_OBJECT_HPP_INCLUDED__
+
+#include <string>
+#include "stdint.hpp"
+
+namespace zmq
+{
+
+    struct i_engine;
+    struct endpoint_t;
+    struct pending_connection_t;
+    struct command_t;
+    class ctx_t;
+    class pipe_t;
+    class socket_base_t;
+    class session_base_t;
+    class io_thread_t;
+    class own_t;
+
+    //  Base class for all objects that participate in inter-thread
+    //  communication.
+
+    class object_t
+    {
+    public:
+
+        object_t (zmq::ctx_t *ctx_, uint32_t tid_);
+        object_t (object_t *parent_);
+        virtual ~object_t ();
+
+        uint32_t get_tid ();
+        void set_tid(uint32_t id);
+        ctx_t *get_ctx ();
+        void process_command (zmq::command_t &cmd_);
+        void send_inproc_connected (zmq::socket_base_t *socket_);
+        void send_bind (zmq::own_t *destination_, zmq::pipe_t *pipe_, bool inc_seqnum_ = true);
+
+    protected:
+
+        //  Using following function, socket is able to access global
+        //  repository of inproc endpoints.
+        int register_endpoint (const char *addr_,
+                const zmq::endpoint_t &endpoint_);
+        int unregister_endpoint (
+                const std::string &addr_, socket_base_t *socket_);
+        void unregister_endpoints (zmq::socket_base_t *socket_);
+        zmq::endpoint_t find_endpoint (const char *addr_);
+        void pend_connection (const std::string &addr_,
+                const endpoint_t &endpoint, pipe_t **pipes_);
+        void connect_pending (const char *addr_, zmq::socket_base_t *bind_socket_);
+
+        void destroy_socket (zmq::socket_base_t *socket_);
+
+        //  Logs an message.
+        void log (const char *format_, ...);
+
+        //  Chooses least loaded I/O thread.
+        zmq::io_thread_t *choose_io_thread (uint64_t affinity_);
+
+        //  Derived object can use these functions to send commands
+        //  to other objects.
+        void send_stop ();
+        void send_plug (zmq::own_t *destination_,
+            bool inc_seqnum_ = true);
+        void send_own (zmq::own_t *destination_,
+            zmq::own_t *object_);
+        void send_attach (zmq::session_base_t *destination_,
+             zmq::i_engine *engine_, bool inc_seqnum_ = true);
+        void send_activate_read (zmq::pipe_t *destination_);
+        void send_activate_write (zmq::pipe_t *destination_,
+             uint64_t msgs_read_);
+        void send_hiccup (zmq::pipe_t *destination_, void *pipe_);
+        void send_pipe_term (zmq::pipe_t *destination_);
+        void send_pipe_term_ack (zmq::pipe_t *destination_);
+        void send_pipe_hwm (zmq::pipe_t *destination_, int inhwm_, int outhwm_);
+        void send_term_req (zmq::own_t *destination_,
+            zmq::own_t *object_);
+        void send_term (zmq::own_t *destination_, int linger_);
+        void send_term_ack (zmq::own_t *destination_);
+        void send_term_endpoint (own_t *destination_, std::string *endpoint_);
+        void send_reap (zmq::socket_base_t *socket_);
+        void send_reaped ();
+        void send_done ();
+
+        //  These handlers can be overridden by the derived objects. They are
+        //  called when command arrives from another thread.
+        virtual void process_stop ();
+        virtual void process_plug ();
+        virtual void process_own (zmq::own_t *object_);
+        virtual void process_attach (zmq::i_engine *engine_);
+        virtual void process_bind (zmq::pipe_t *pipe_);
+        virtual void process_activate_read ();
+        virtual void process_activate_write (uint64_t msgs_read_);
+        virtual void process_hiccup (void *pipe_);
+        virtual void process_pipe_term ();
+        virtual void process_pipe_term_ack ();
+        virtual void process_pipe_hwm (int inhwm_, int outhwm_);
+        virtual void process_term_req (zmq::own_t *object_);
+        virtual void process_term (int linger_);
+        virtual void process_term_ack ();
+        virtual void process_term_endpoint (std::string *endpoint_);
+        virtual void process_reap (zmq::socket_base_t *socket_);
+        virtual void process_reaped ();
+
+        //  Special handler called after a command that requires a seqnum
+        //  was processed. The implementation should catch up with its counter
+        //  of processed commands here.
+        virtual void process_seqnum ();
+
+    private:
+
+        //  Context provides access to the global state.
+        zmq::ctx_t *ctx;
+
+        //  Thread ID of the thread the object belongs to.
+        uint32_t tid;
+
+        void send_command (command_t &cmd_);
+
+        object_t (const object_t&);
+        const object_t &operator = (const object_t&);
+    };
+
+}
+
+#endif

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

@@ -0,0 +1,1089 @@
+/*
+    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/>.
+*/
+
+#include "precompiled.hpp"
+#include <string.h>
+
+#include "options.hpp"
+#include "err.hpp"
+#include "macros.hpp"
+
+#ifndef ZMQ_HAVE_WINDOWS
+#include <net/if.h>
+#endif
+
+#if defined IFNAMSIZ
+#define BINDDEVSIZ IFNAMSIZ
+#else
+#define BINDDEVSIZ 16
+#endif
+
+zmq::options_t::options_t () :
+    sndhwm (1000),
+    rcvhwm (1000),
+    affinity (0),
+    routing_id_size (0),
+    rate (100),
+    recovery_ivl (10000),
+    multicast_hops (1),
+    multicast_maxtpdu (1500),
+    sndbuf (-1),
+    rcvbuf (-1),
+    tos (0),
+    type (-1),
+    linger (-1),
+    connect_timeout (0),
+    tcp_maxrt (0),
+    reconnect_ivl (100),
+    reconnect_ivl_max (0),
+    backlog (100),
+    maxmsgsize (-1),
+    rcvtimeo (-1),
+    sndtimeo (-1),
+    ipv6 (0),
+    immediate (0),
+    filter (false),
+    invert_matching(false),
+    recv_routing_id (false),
+    raw_socket (false),
+    raw_notify (true),
+    tcp_keepalive (-1),
+    tcp_keepalive_cnt (-1),
+    tcp_keepalive_idle (-1),
+    tcp_keepalive_intvl (-1),
+    mechanism (ZMQ_NULL),
+    as_server (0),
+    gss_principal_nt (ZMQ_GSSAPI_NT_HOSTBASED),
+    gss_service_principal_nt (ZMQ_GSSAPI_NT_HOSTBASED),
+    gss_plaintext (false),
+    socket_id (0),
+    conflate (false),
+    handshake_ivl (30000),
+    connected (false),
+    heartbeat_ttl (0),
+    heartbeat_interval (0),
+    heartbeat_timeout (-1),
+    use_fd (-1),
+    zap_enforce_domain (false)
+{
+    memset (curve_public_key, 0, CURVE_KEYSIZE);
+    memset (curve_secret_key, 0, CURVE_KEYSIZE);
+    memset (curve_server_key, 0, CURVE_KEYSIZE);
+#if defined ZMQ_HAVE_VMCI
+    vmci_buffer_size = 0;
+    vmci_buffer_min_size = 0;
+    vmci_buffer_max_size = 0;
+    vmci_connect_timeout = -1;
+#endif
+}
+
+int zmq::options_t::set_curve_key(uint8_t * destination, const void * optval_, size_t optvallen_)
+{
+    switch (optvallen_) {
+
+        case CURVE_KEYSIZE:
+            memcpy (destination, optval_, optvallen_);
+            mechanism = ZMQ_CURVE;
+            return 0;
+
+        case CURVE_KEYSIZE_Z85 + 1:
+            if (zmq_z85_decode (destination, (char *) optval_)) {
+                mechanism = ZMQ_CURVE;
+                return 0;
+            }
+            break;
+
+        case CURVE_KEYSIZE_Z85:
+            char z85_key [CURVE_KEYSIZE_Z85 + 1];
+            memcpy (z85_key, (char *) optval_, optvallen_);
+            z85_key [CURVE_KEYSIZE_Z85] = 0;
+            if (zmq_z85_decode (destination, z85_key)) {
+                mechanism = ZMQ_CURVE;
+                return 0;
+            }
+            break;
+
+        default:
+            break;
+    }
+    return -1;
+}
+
+int zmq::options_t::setsockopt (int option_, const void *optval_,
+    size_t optvallen_)
+{
+    bool is_int = (optvallen_ == sizeof (int));
+    int value = 0;
+    if (is_int) memcpy(&value, optval_, sizeof (int));
+#if defined (ZMQ_ACT_MILITANT)
+    bool malformed = true;          //  Did caller pass a bad option value?
+#endif
+
+    switch (option_) {
+        case ZMQ_SNDHWM:
+            if (is_int && value >= 0) {
+                sndhwm = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_RCVHWM:
+            if (is_int && value >= 0) {
+                rcvhwm = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_AFFINITY:
+            if (optvallen_ == sizeof (uint64_t)) {
+                affinity = *((uint64_t*) optval_);
+                return 0;
+            }
+            break;
+
+        case ZMQ_ROUTING_ID:
+            //  Routing id is any binary string from 1 to 255 octets
+            if (optvallen_ > 0 && optvallen_ < 256) {
+                routing_id_size = (unsigned char) optvallen_;
+                memcpy (routing_id, optval_, routing_id_size);
+                return 0;
+            }
+            break;
+
+        case ZMQ_RATE:
+            if (is_int && value > 0) {
+                rate = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_RECOVERY_IVL:
+            if (is_int && value >= 0) {
+                recovery_ivl = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_SNDBUF:
+            if (is_int && value >= -1) {
+                sndbuf = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_RCVBUF:
+            if (is_int && value >= -1) {
+                rcvbuf = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_TOS:
+            if (is_int && value >= 0) {
+                tos = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_LINGER:
+            if (is_int && value >= -1) {
+                linger = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_CONNECT_TIMEOUT:
+            if (is_int && value >= 0) {
+                connect_timeout = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_TCP_MAXRT:
+            if (is_int && value >= 0) {
+                tcp_maxrt = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_RECONNECT_IVL:
+            if (is_int && value >= -1) {
+                reconnect_ivl = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_RECONNECT_IVL_MAX:
+            if (is_int && value >= 0) {
+                reconnect_ivl_max = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_BACKLOG:
+            if (is_int && value >= 0) {
+                backlog = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_MAXMSGSIZE:
+            if (optvallen_ == sizeof (int64_t)) {
+                maxmsgsize = *((int64_t *) optval_);
+                return 0;
+            }
+            break;
+
+        case ZMQ_MULTICAST_HOPS:
+            if (is_int && value > 0) {
+                multicast_hops = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_MULTICAST_MAXTPDU:
+            if (is_int && value > 0) {
+                multicast_maxtpdu = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_RCVTIMEO:
+            if (is_int && value >= -1) {
+                rcvtimeo = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_SNDTIMEO:
+            if (is_int && value >= -1) {
+                sndtimeo = value;
+                return 0;
+            }
+            break;
+
+        /*  Deprecated in favor of ZMQ_IPV6  */
+        case ZMQ_IPV4ONLY:
+            if (is_int && (value == 0 || value == 1)) {
+                ipv6 = (value == 0);
+                return 0;
+            }
+            break;
+
+        /*  To replace the somewhat surprising IPV4ONLY */
+        case ZMQ_IPV6:
+            if (is_int && (value == 0 || value == 1)) {
+                ipv6 = (value != 0);
+                return 0;
+            }
+            break;
+
+        case ZMQ_SOCKS_PROXY:
+            if (optval_ == NULL && optvallen_ == 0) {
+                socks_proxy_address.clear ();
+                return 0;
+            }
+            else
+            if (optval_ != NULL && optvallen_ > 0 ) {
+                socks_proxy_address =
+                    std::string ((const char *) optval_, optvallen_);
+                return 0;
+            }
+            break;
+
+        case ZMQ_TCP_KEEPALIVE:
+            if (is_int && (value == -1 || value == 0 || value == 1)) {
+                tcp_keepalive = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_TCP_KEEPALIVE_CNT:
+            if (is_int && (value == -1 || value >= 0)) {
+                tcp_keepalive_cnt = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_TCP_KEEPALIVE_IDLE:
+            if (is_int && (value == -1 || value >= 0)) {
+                tcp_keepalive_idle = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_TCP_KEEPALIVE_INTVL:
+            if (is_int && (value == -1 || value >= 0)) {
+                tcp_keepalive_intvl = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_IMMEDIATE:
+            if (is_int && (value == 0 || value == 1)) {
+                immediate = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_TCP_ACCEPT_FILTER:
+            if (optvallen_ == 0 && optval_ == NULL) {
+                tcp_accept_filters.clear ();
+                return 0;
+            }
+            else
+            if (optvallen_ > 0 && optvallen_ < 256 && optval_ != NULL && *((const char*) optval_) != 0) {
+                std::string filter_str ((const char *) optval_, optvallen_);
+                tcp_address_mask_t mask;
+                int rc = mask.resolve (filter_str.c_str (), ipv6);
+                if (rc == 0) {
+                    tcp_accept_filters.push_back (mask);
+                    return 0;
+                }
+            }
+            break;
+
+#if defined ZMQ_HAVE_SO_PEERCRED || defined ZMQ_HAVE_LOCAL_PEERCRED
+        case ZMQ_IPC_FILTER_UID:
+            if (optvallen_ == 0 && optval_ == NULL) {
+                ipc_uid_accept_filters.clear ();
+                return 0;
+            }
+            else
+            if (optvallen_ == sizeof (uid_t) && optval_ != NULL) {
+                ipc_uid_accept_filters.insert (*((uid_t *) optval_));
+                return 0;
+            }
+            break;
+
+        case ZMQ_IPC_FILTER_GID:
+            if (optvallen_ == 0 && optval_ == NULL) {
+                ipc_gid_accept_filters.clear ();
+                return 0;
+            }
+            else
+            if (optvallen_ == sizeof (gid_t) && optval_ != NULL) {
+                ipc_gid_accept_filters.insert (*((gid_t *) optval_));
+                return 0;
+            }
+            break;
+#endif
+
+#if defined ZMQ_HAVE_SO_PEERCRED
+        case ZMQ_IPC_FILTER_PID:
+            if (optvallen_ == 0 && optval_ == NULL) {
+                ipc_pid_accept_filters.clear ();
+                return 0;
+            }
+            else
+            if (optvallen_ == sizeof (pid_t) && optval_ != NULL) {
+                ipc_pid_accept_filters.insert (*((pid_t *) optval_));
+                return 0;
+            }
+            break;
+#endif
+
+        case ZMQ_PLAIN_SERVER:
+            if (is_int && (value == 0 || value == 1)) {
+                as_server = value;
+                mechanism = value? ZMQ_PLAIN: ZMQ_NULL;
+                return 0;
+            }
+            break;
+
+        case ZMQ_PLAIN_USERNAME:
+            if (optvallen_ == 0 && optval_ == NULL) {
+                mechanism = ZMQ_NULL;
+                return 0;
+            }
+            else
+            if (optvallen_ > 0 && optvallen_ < 256 && optval_ != NULL) {
+                plain_username.assign ((const char *) optval_, optvallen_);
+                as_server = 0;
+                mechanism = ZMQ_PLAIN;
+                return 0;
+            }
+            break;
+
+        case ZMQ_PLAIN_PASSWORD:
+            if (optvallen_ == 0 && optval_ == NULL) {
+                mechanism = ZMQ_NULL;
+                return 0;
+            }
+            else
+            if (optvallen_ > 0 && optvallen_ < 256 && optval_ != NULL) {
+                plain_password.assign ((const char *) optval_, optvallen_);
+                as_server = 0;
+                mechanism = ZMQ_PLAIN;
+                return 0;
+            }
+            break;
+
+        case ZMQ_ZAP_DOMAIN:
+            if (optvallen_ < 256) {
+                zap_domain.assign ((const char *) optval_, optvallen_);
+                return 0;
+            }
+            break;
+
+        //  If curve encryption isn't built, these options provoke EINVAL
+#ifdef ZMQ_HAVE_CURVE
+        case ZMQ_CURVE_SERVER:
+            if (is_int && (value == 0 || value == 1)) {
+                as_server = value;
+                mechanism = value? ZMQ_CURVE: ZMQ_NULL;
+                return 0;
+            }
+            break;
+
+        case ZMQ_CURVE_PUBLICKEY:
+            if(0 == set_curve_key(curve_public_key, optval_, optvallen_)) {
+                return 0;
+            }
+            break;
+
+        case ZMQ_CURVE_SECRETKEY:
+            if(0 == set_curve_key(curve_secret_key, optval_, optvallen_)) {
+                return 0;
+            }
+            break;
+
+        case ZMQ_CURVE_SERVERKEY:
+            if(0 == set_curve_key(curve_server_key, optval_, optvallen_)) {
+                as_server = 0;
+                return 0;
+            }
+            break;
+#endif
+
+        case ZMQ_CONFLATE:
+            if (is_int && (value == 0 || value == 1)) {
+                conflate = (value != 0);
+                return 0;
+            }
+            break;
+
+        //  If libgssapi isn't installed, these options provoke EINVAL
+#ifdef HAVE_LIBGSSAPI_KRB5
+        case ZMQ_GSSAPI_SERVER:
+            if (is_int && (value == 0 || value == 1)) {
+                as_server = value;
+                mechanism = ZMQ_GSSAPI;
+                return 0;
+            }
+            break;
+
+        case ZMQ_GSSAPI_PRINCIPAL:
+            if (optvallen_ > 0 && optvallen_ < 256 && optval_ != NULL) {
+                gss_principal.assign ((const char *) optval_, optvallen_);
+                mechanism = ZMQ_GSSAPI;
+                return 0;
+            }
+            break;
+
+        case ZMQ_GSSAPI_SERVICE_PRINCIPAL:
+            if (optvallen_ > 0 && optvallen_ < 256 && optval_ != NULL) {
+                gss_service_principal.assign ((const char *) optval_, optvallen_);
+                mechanism = ZMQ_GSSAPI;
+                as_server = 0;
+                return 0;
+            }
+            break;
+
+        case ZMQ_GSSAPI_PLAINTEXT:
+            if (is_int && (value == 0 || value == 1)) {
+                gss_plaintext = (value != 0);
+                return 0;
+            }
+            break;
+
+        case ZMQ_GSSAPI_PRINCIPAL_NAMETYPE:
+            if (is_int && (value == ZMQ_GSSAPI_NT_HOSTBASED
+                        || value == ZMQ_GSSAPI_NT_USER_NAME
+                        || value == ZMQ_GSSAPI_NT_KRB5_PRINCIPAL)) {
+                gss_principal_nt = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_GSSAPI_SERVICE_PRINCIPAL_NAMETYPE:
+            if (is_int && (value == ZMQ_GSSAPI_NT_HOSTBASED
+                        || value == ZMQ_GSSAPI_NT_USER_NAME
+                        || value == ZMQ_GSSAPI_NT_KRB5_PRINCIPAL)) {
+                gss_service_principal_nt = value;
+                return 0;
+            }
+            break;
+#endif
+
+        case ZMQ_HANDSHAKE_IVL:
+            if (is_int && value >= 0) {
+                handshake_ivl = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_INVERT_MATCHING:
+            if (is_int) {
+                invert_matching = (value != 0);
+                return 0;
+            }
+            break;
+
+        case ZMQ_HEARTBEAT_IVL:
+            if (is_int && value >= 0) {
+                heartbeat_interval = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_HEARTBEAT_TTL:
+            // Convert this to deciseconds from milliseconds
+            value = value / 100;
+            if (is_int && value >= 0 && value <= 6553) {
+                heartbeat_ttl = (uint16_t)value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_HEARTBEAT_TIMEOUT:
+            if (is_int && value >= 0) {
+                heartbeat_timeout = value;
+                return 0;
+            }
+            break;
+
+#ifdef ZMQ_HAVE_VMCI
+        case ZMQ_VMCI_BUFFER_SIZE:
+            if (optvallen_ == sizeof (uint64_t)) {
+                vmci_buffer_size = *((uint64_t*) optval_);
+                return 0;
+            }
+            break;
+
+        case ZMQ_VMCI_BUFFER_MIN_SIZE:
+            if (optvallen_ == sizeof (uint64_t)) {
+                vmci_buffer_min_size = *((uint64_t*) optval_);
+                return 0;
+            }
+            break;
+
+        case ZMQ_VMCI_BUFFER_MAX_SIZE:
+            if (optvallen_ == sizeof (uint64_t)) {
+                vmci_buffer_max_size = *((uint64_t*) optval_);
+                return 0;
+            }
+            break;
+
+        case ZMQ_VMCI_CONNECT_TIMEOUT:
+            if (optvallen_ == sizeof (int)) {
+                vmci_connect_timeout = *((int*) optval_);
+                return 0;
+            }
+            break;
+#endif
+
+        case ZMQ_USE_FD:
+            if (is_int && value >= -1) {
+                use_fd = value;
+                return 0;
+            }
+            break;
+
+        case ZMQ_BINDTODEVICE:
+            if (optval_ == NULL && optvallen_ == 0) {
+                bound_device.clear ();
+                return 0;
+            }
+            else
+            if (optval_ != NULL && optvallen_ > 0 && optvallen_ <= BINDDEVSIZ) {
+                bound_device =
+                    std::string ((const char *) optval_, optvallen_);
+                return 0;
+            }
+            break;
+
+        case ZMQ_ZAP_ENFORCE_DOMAIN:
+            if (is_int) {
+                zap_enforce_domain = (value != 0);
+                return 0;
+            }
+            break;
+
+
+        default:
+#if defined (ZMQ_ACT_MILITANT)
+            //  There are valid scenarios for probing with unknown socket option
+            //  values, e.g. to check if security is enabled or not. This will not
+            //  provoke a militant assert. However, passing bad values to a valid
+            //  socket option will, if ZMQ_ACT_MILITANT is defined.
+            malformed = false;
+#endif
+            break;
+    }
+#if defined (ZMQ_ACT_MILITANT)
+    //  There is no valid use case for passing an error back to the application
+    //  when it sent malformed arguments to a socket option. Use ./configure
+    //  --with-militant to enable this checking.
+    if (malformed)
+        zmq_assert (false);
+#endif
+    errno = EINVAL;
+    return -1;
+}
+
+int zmq::options_t::getsockopt (int option_, void *optval_, size_t *optvallen_) const
+{
+    bool is_int = (*optvallen_ == sizeof (int));
+    int *value = (int *) optval_;
+#if defined (ZMQ_ACT_MILITANT)
+    bool malformed = true;          //  Did caller pass a bad option value?
+#endif
+
+    switch (option_) {
+        case ZMQ_SNDHWM:
+            if (is_int) {
+                *value = sndhwm;
+                return 0;
+            }
+            break;
+
+        case ZMQ_RCVHWM:
+            if (is_int) {
+                *value = rcvhwm;
+                return 0;
+            }
+            break;
+
+        case ZMQ_AFFINITY:
+            if (*optvallen_ == sizeof (uint64_t)) {
+                *((uint64_t *) optval_) = affinity;
+                return 0;
+            }
+            break;
+
+        case ZMQ_ROUTING_ID:
+            if (*optvallen_ >= routing_id_size) {
+                memcpy (optval_, routing_id, routing_id_size);
+                *optvallen_ = routing_id_size;
+                return 0;
+            }
+            break;
+
+        case ZMQ_RATE:
+            if (is_int) {
+                *value = rate;
+                return 0;
+            }
+            break;
+
+        case ZMQ_RECOVERY_IVL:
+            if (is_int) {
+                *value = recovery_ivl;
+                return 0;
+            }
+            break;
+
+        case ZMQ_SNDBUF:
+            if (is_int) {
+                *value = sndbuf;
+                return 0;
+            }
+            break;
+
+        case ZMQ_RCVBUF:
+            if (is_int) {
+                *value = rcvbuf;
+                return 0;
+            }
+            break;
+
+        case ZMQ_TOS:
+            if (is_int) {
+                *value = tos;
+                return 0;
+            }
+            break;
+
+        case ZMQ_TYPE:
+            if (is_int) {
+                *value = type;
+                return 0;
+            }
+            break;
+
+        case ZMQ_LINGER:
+            if (is_int) {
+                *value = linger;
+                return 0;
+            }
+            break;
+
+        case ZMQ_CONNECT_TIMEOUT:
+            if (is_int) {
+                *value = connect_timeout;
+                return 0;
+            }
+            break;
+
+        case ZMQ_TCP_MAXRT:
+            if (is_int) {
+                *value = tcp_maxrt;
+                return 0;
+            }
+            break;
+
+        case ZMQ_RECONNECT_IVL:
+            if (is_int) {
+                *value = reconnect_ivl;
+                return 0;
+            }
+            break;
+
+        case ZMQ_RECONNECT_IVL_MAX:
+            if (is_int) {
+                *value = reconnect_ivl_max;
+                return 0;
+            }
+            break;
+
+        case ZMQ_BACKLOG:
+            if (is_int) {
+                *value = backlog;
+                return 0;
+            }
+            break;
+
+        case ZMQ_MAXMSGSIZE:
+            if (*optvallen_ == sizeof (int64_t)) {
+                *((int64_t *) optval_) = maxmsgsize;
+                *optvallen_ = sizeof (int64_t);
+                return 0;
+            }
+            break;
+
+        case ZMQ_MULTICAST_HOPS:
+            if (is_int) {
+                *value = multicast_hops;
+                return 0;
+            }
+            break;
+
+        case ZMQ_MULTICAST_MAXTPDU:
+            if (is_int) {
+                *value = multicast_maxtpdu;
+                return 0;
+            }
+            break;
+
+        case ZMQ_RCVTIMEO:
+            if (is_int) {
+                *value = rcvtimeo;
+                return 0;
+            }
+            break;
+
+        case ZMQ_SNDTIMEO:
+            if (is_int) {
+                *value = sndtimeo;
+                return 0;
+            }
+            break;
+
+        case ZMQ_IPV4ONLY:
+            if (is_int) {
+                *value = 1 - ipv6;
+                return 0;
+            }
+            break;
+
+        case ZMQ_IPV6:
+            if (is_int) {
+                *value = ipv6;
+                return 0;
+            }
+            break;
+
+        case ZMQ_IMMEDIATE:
+            if (is_int) {
+                *value = immediate;
+                return 0;
+            }
+            break;
+
+        case ZMQ_SOCKS_PROXY:
+            if (*optvallen_ >= socks_proxy_address.size () + 1) {
+                memcpy (optval_, socks_proxy_address.c_str (), socks_proxy_address.size () + 1);
+                *optvallen_ = socks_proxy_address.size () + 1;
+                return 0;
+            }
+            break;
+
+        case ZMQ_TCP_KEEPALIVE:
+            if (is_int) {
+                *value = tcp_keepalive;
+                return 0;
+            }
+            break;
+
+        case ZMQ_TCP_KEEPALIVE_CNT:
+            if (is_int) {
+                *value = tcp_keepalive_cnt;
+                return 0;
+            }
+            break;
+
+        case ZMQ_TCP_KEEPALIVE_IDLE:
+            if (is_int) {
+                *value = tcp_keepalive_idle;
+                return 0;
+            }
+            break;
+
+        case ZMQ_TCP_KEEPALIVE_INTVL:
+            if (is_int) {
+                *value = tcp_keepalive_intvl;
+                return 0;
+            }
+            break;
+
+        case ZMQ_MECHANISM:
+            if (is_int) {
+                *value = mechanism;
+                return 0;
+            }
+            break;
+
+        case ZMQ_PLAIN_SERVER:
+            if (is_int) {
+                *value = as_server && mechanism == ZMQ_PLAIN;
+                return 0;
+            }
+            break;
+
+        case ZMQ_PLAIN_USERNAME:
+            if (*optvallen_ >= plain_username.size () + 1) {
+                memcpy (optval_, plain_username.c_str (), plain_username.size () + 1);
+                *optvallen_ = plain_username.size () + 1;
+                return 0;
+            }
+            break;
+
+        case ZMQ_PLAIN_PASSWORD:
+            if (*optvallen_ >= plain_password.size () + 1) {
+                memcpy (optval_, plain_password.c_str (), plain_password.size () + 1);
+                *optvallen_ = plain_password.size () + 1;
+                return 0;
+            }
+            break;
+
+        case ZMQ_ZAP_DOMAIN:
+            if (*optvallen_ >= zap_domain.size () + 1) {
+                memcpy (optval_, zap_domain.c_str (), zap_domain.size () + 1);
+                *optvallen_ = zap_domain.size () + 1;
+                return 0;
+            }
+            break;
+
+        //  If curve encryption isn't built, these options provoke EINVAL
+#ifdef ZMQ_HAVE_CURVE
+        case ZMQ_CURVE_SERVER:
+            if (is_int) {
+                *value = as_server && mechanism == ZMQ_CURVE;
+                return 0;
+            }
+            break;
+
+        case ZMQ_CURVE_PUBLICKEY:
+            if (*optvallen_ == CURVE_KEYSIZE) {
+                memcpy (optval_, curve_public_key, CURVE_KEYSIZE);
+                return 0;
+            }
+            else
+            if (*optvallen_ == CURVE_KEYSIZE_Z85 + 1) {
+                zmq_z85_encode ((char *) optval_, curve_public_key, CURVE_KEYSIZE);
+                return 0;
+            }
+            break;
+
+        case ZMQ_CURVE_SECRETKEY:
+            if (*optvallen_ == CURVE_KEYSIZE) {
+                memcpy (optval_, curve_secret_key, CURVE_KEYSIZE);
+                return 0;
+            }
+            else
+            if (*optvallen_ == CURVE_KEYSIZE_Z85 + 1) {
+                zmq_z85_encode ((char *) optval_, curve_secret_key, CURVE_KEYSIZE);
+                return 0;
+            }
+            break;
+
+        case ZMQ_CURVE_SERVERKEY:
+            if (*optvallen_ == CURVE_KEYSIZE) {
+                memcpy (optval_, curve_server_key, CURVE_KEYSIZE);
+                return 0;
+            }
+            else
+            if (*optvallen_ == CURVE_KEYSIZE_Z85 + 1) {
+                zmq_z85_encode ((char *) optval_, curve_server_key, CURVE_KEYSIZE);
+                return 0;
+            }
+            break;
+#endif
+
+        case ZMQ_CONFLATE:
+            if (is_int) {
+                *value = conflate;
+                return 0;
+            }
+            break;
+
+        //  If libgssapi isn't installed, these options provoke EINVAL
+#ifdef HAVE_LIBGSSAPI_KRB5
+        case ZMQ_GSSAPI_SERVER:
+            if (is_int) {
+                *value = as_server && mechanism == ZMQ_GSSAPI;
+                return 0;
+            }
+            break;
+
+        case ZMQ_GSSAPI_PRINCIPAL:
+            if (*optvallen_ >= gss_principal.size () + 1) {
+                memcpy (optval_, gss_principal.c_str (), gss_principal.size () + 1);
+                *optvallen_ = gss_principal.size () + 1;
+                return 0;
+            }
+            break;
+
+        case ZMQ_GSSAPI_SERVICE_PRINCIPAL:
+            if (*optvallen_ >= gss_service_principal.size () + 1) {
+                memcpy (optval_, gss_service_principal.c_str (), gss_service_principal.size () + 1);
+                *optvallen_ = gss_service_principal.size () + 1;
+                return 0;
+            }
+            break;
+
+        case ZMQ_GSSAPI_PLAINTEXT:
+            if (is_int) {
+                *value = gss_plaintext;
+                return 0;
+            }
+            break;
+
+        case ZMQ_GSSAPI_PRINCIPAL_NAMETYPE:
+            if (is_int) {
+                *value = gss_principal_nt;
+                return 0;
+            }
+            break;
+        case ZMQ_GSSAPI_SERVICE_PRINCIPAL_NAMETYPE:
+            if (is_int) {
+                *value = gss_service_principal_nt;
+                return 0;
+            }
+            break;
+#endif
+
+        case ZMQ_HANDSHAKE_IVL:
+            if (is_int) {
+                *value = handshake_ivl;
+                return 0;
+            }
+            break;
+
+        case ZMQ_INVERT_MATCHING:
+            if (is_int) {
+                *value = invert_matching;
+                return 0;
+            }
+            break;
+
+        case ZMQ_HEARTBEAT_IVL:
+            if (is_int) {
+                *value = heartbeat_interval;
+                return 0;
+            }
+            break;
+
+        case ZMQ_HEARTBEAT_TTL:
+            if (is_int) {
+                // Convert the internal deciseconds value to milliseconds
+                *value = heartbeat_ttl * 100;
+                return 0;
+            }
+            break;
+
+        case ZMQ_HEARTBEAT_TIMEOUT:
+            if (is_int) {
+                *value = heartbeat_timeout;
+                return 0;
+            }
+            break;
+
+        case ZMQ_USE_FD:
+            if (is_int) {
+                *value = use_fd;
+                return 0;
+            }
+            break;
+
+        case ZMQ_BINDTODEVICE:
+            if (*optvallen_ >= bound_device.size () + 1) {
+                memcpy (optval_, bound_device.c_str (), bound_device.size () + 1);
+                *optvallen_ = bound_device.size () + 1;
+                return 0;
+            }
+            break;
+
+        case ZMQ_ZAP_ENFORCE_DOMAIN:
+            if (is_int) {
+                *value = zap_enforce_domain;
+                return 0;
+            }
+            break;
+
+        default:
+#if defined (ZMQ_ACT_MILITANT)
+            malformed = false;
+#endif
+            break;
+    }
+#if defined (ZMQ_ACT_MILITANT)
+    if (malformed)
+        zmq_assert (false);
+#endif
+    errno = EINVAL;
+    return -1;
+}
+
+bool zmq::options_t::is_valid (int option_) const
+{
+    LIBZMQ_UNUSED (option_);
+    return true;
+}