summaryrefslogtreecommitdiffstats
path: root/external_libs/python/pyzmq-14.7.0/bundled/zeromq/src/options.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'external_libs/python/pyzmq-14.7.0/bundled/zeromq/src/options.cpp')
-rw-r--r--external_libs/python/pyzmq-14.7.0/bundled/zeromq/src/options.cpp864
1 files changed, 864 insertions, 0 deletions
diff --git a/external_libs/python/pyzmq-14.7.0/bundled/zeromq/src/options.cpp b/external_libs/python/pyzmq-14.7.0/bundled/zeromq/src/options.cpp
new file mode 100644
index 00000000..ea4f74c9
--- /dev/null
+++ b/external_libs/python/pyzmq-14.7.0/bundled/zeromq/src/options.cpp
@@ -0,0 +1,864 @@
+/*
+ Copyright (c) 2007-2015 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 <string.h>
+
+#include "options.hpp"
+#include "err.hpp"
+#include "../include/zmq_utils.h"
+
+zmq::options_t::options_t () :
+ sndhwm (1000),
+ rcvhwm (1000),
+ affinity (0),
+ identity_size (0),
+ rate (100),
+ recovery_ivl (10000),
+ multicast_hops (1),
+ sndbuf (0),
+ rcvbuf (0),
+ tos (0),
+ type (-1),
+ linger (-1),
+ reconnect_ivl (100),
+ reconnect_ivl_max (0),
+ backlog (100),
+ maxmsgsize (-1),
+ rcvtimeo (-1),
+ sndtimeo (-1),
+ ipv6 (0),
+ immediate (0),
+ filter (false),
+ recv_identity (false),
+ raw_sock (false),
+ tcp_keepalive (-1),
+ tcp_keepalive_cnt (-1),
+ tcp_keepalive_idle (-1),
+ tcp_keepalive_intvl (-1),
+ mechanism (ZMQ_NULL),
+ as_server (0),
+ gss_plaintext (false),
+ socket_id (0),
+ conflate (false),
+ handshake_ivl (30000)
+{
+}
+
+int zmq::options_t::setsockopt (int option_, const void *optval_,
+ size_t optvallen_)
+{
+ bool is_int = (optvallen_ == sizeof (int));
+ int value = is_int? *((int *) optval_): 0;
+#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_IDENTITY:
+ // Identity is any binary string from 1 to 255 octets
+ if (optvallen_ > 0 && optvallen_ < 256) {
+ identity_size = optvallen_;
+ memcpy (identity, optval_, identity_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 >= 0) {
+ sndbuf = value;
+ return 0;
+ }
+ break;
+
+ case ZMQ_RCVBUF:
+ if (is_int && value >= 0) {
+ 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_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_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 libsodium isn't installed, these options provoke EINVAL
+# ifdef HAVE_LIBSODIUM
+ 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:
+ // TODO: refactor repeated code for these three options
+ // into set_curve_key (destination, optval, optlen) method
+ // ==> set_curve_key (curve_public_key, optval_, optvallen_);
+ if (optvallen_ == CURVE_KEYSIZE) {
+ memcpy (curve_public_key, optval_, CURVE_KEYSIZE);
+ mechanism = ZMQ_CURVE;
+ return 0;
+ }
+ else
+ if (optvallen_ == CURVE_KEYSIZE_Z85 + 1) {
+ zmq_z85_decode (curve_public_key, (char *) optval_);
+ mechanism = ZMQ_CURVE;
+ return 0;
+ }
+ else
+ // Deprecated, not symmetrical with zmq_getsockopt
+ if (optvallen_ == CURVE_KEYSIZE_Z85) {
+ char z85_key [41];
+ memcpy (z85_key, (char *) optval_, CURVE_KEYSIZE_Z85);
+ z85_key [CURVE_KEYSIZE_Z85] = 0;
+ zmq_z85_decode (curve_public_key, z85_key);
+ mechanism = ZMQ_CURVE;
+ return 0;
+ }
+ break;
+
+ case ZMQ_CURVE_SECRETKEY:
+ if (optvallen_ == CURVE_KEYSIZE) {
+ memcpy (curve_secret_key, optval_, CURVE_KEYSIZE);
+ mechanism = ZMQ_CURVE;
+ return 0;
+ }
+ else
+ if (optvallen_ == CURVE_KEYSIZE_Z85 + 1) {
+ zmq_z85_decode (curve_secret_key, (char *) optval_);
+ mechanism = ZMQ_CURVE;
+ return 0;
+ }
+ else
+ // Deprecated, not symmetrical with zmq_getsockopt
+ if (optvallen_ == CURVE_KEYSIZE_Z85) {
+ char z85_key [41];
+ memcpy (z85_key, (char *) optval_, CURVE_KEYSIZE_Z85);
+ z85_key [CURVE_KEYSIZE_Z85] = 0;
+ zmq_z85_decode (curve_secret_key, z85_key);
+ mechanism = ZMQ_CURVE;
+ return 0;
+ }
+ break;
+
+ case ZMQ_CURVE_SERVERKEY:
+ if (optvallen_ == CURVE_KEYSIZE) {
+ memcpy (curve_server_key, optval_, CURVE_KEYSIZE);
+ mechanism = ZMQ_CURVE;
+ as_server = 0;
+ return 0;
+ }
+ else
+ if (optvallen_ == CURVE_KEYSIZE_Z85 + 1) {
+ zmq_z85_decode (curve_server_key, (char *) optval_);
+ mechanism = ZMQ_CURVE;
+ as_server = 0;
+ return 0;
+ }
+ else
+ // Deprecated, not symmetrical with zmq_getsockopt
+ if (optvallen_ == CURVE_KEYSIZE_Z85) {
+ char z85_key [41];
+ memcpy (z85_key, (char *) optval_, CURVE_KEYSIZE_Z85);
+ z85_key [CURVE_KEYSIZE_Z85] = 0;
+ zmq_z85_decode (curve_server_key, z85_key);
+ mechanism = ZMQ_CURVE;
+ 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;
+# endif
+
+ case ZMQ_HANDSHAKE_IVL:
+ if (is_int && value >= 0) {
+ handshake_ivl = value;
+ 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_)
+{
+ 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_IDENTITY:
+ if (*optvallen_ >= identity_size) {
+ memcpy (optval_, identity, identity_size);
+ *optvallen_ = identity_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_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_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 libsodium isn't installed, these options provoke EINVAL
+# ifdef HAVE_LIBSODIUM
+ 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;
+#endif
+
+ case ZMQ_HANDSHAKE_IVL:
+ if (is_int) {
+ *value = handshake_ivl;
+ 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;
+}