options.hpp 9.53 KB
Newer Older
1
/*
2
    Copyright (c) 2007-2016 Contributors as noted in the AUTHORS file
3

4
    This file is part of libzmq, the ZeroMQ core engine in C++.
5

6 7 8
    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
9 10
    (at your option) any later version.

11 12 13 14 15 16 17 18 19 20 21 22 23 24
    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.
25

26
    You should have received a copy of the GNU Lesser General Public License
27 28 29 30 31 32
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef __ZMQ_OPTIONS_HPP_INCLUDED__
#define __ZMQ_OPTIONS_HPP_INCLUDED__

33
#include <string>
34
#include <vector>
35
#include <map>
36

37
#include "atomic_ptr.hpp"
38
#include "stddef.h"
unknown's avatar
unknown committed
39
#include "stdint.hpp"
40
#include "tcp_address.hpp"
unknown's avatar
unknown committed
41

42
#if defined ZMQ_HAVE_SO_PEERCRED || defined ZMQ_HAVE_LOCAL_PEERCRED
43
#include <set>
44 45
#include <sys/types.h>
#endif
46 47 48
#ifdef ZMQ_HAVE_LOCAL_PEERCRED
#include <sys/ucred.h>
#endif
49

50 51 52 53
#if __cplusplus >= 201103L
#include <type_traits>
#endif

Pieter Hintjens's avatar
Pieter Hintjens committed
54
//  Normal base 256 key is 32 bytes
55
#define CURVE_KEYSIZE 32
Pieter Hintjens's avatar
Pieter Hintjens committed
56
//  Key encoded using Z85 is 40 bytes
57
#define CURVE_KEYSIZE_Z85 40
58

59 60
namespace zmq
{
61 62 63 64
struct options_t
{
    options_t ();

65
    int set_curve_key (uint8_t *destination_,
66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
                       const void *optval_,
                       size_t optvallen_);

    int setsockopt (int option_, const void *optval_, size_t optvallen_);
    int getsockopt (int option_, void *optval_, size_t *optvallen_) const;

    //  High-water marks for message pipes.
    int sndhwm;
    int rcvhwm;

    //  I/O thread affinity.
    uint64_t affinity;

    //  Socket routing id.
    unsigned char routing_id_size;
    unsigned char routing_id[256];

    //  Maximum transfer rate [kb/s]. Default 100kb/s.
    int rate;
85

86 87
    //  Reliability time interval [ms]. Default 10 seconds.
    int recovery_ivl;
88

89 90
    // Sets the time-to-live field in every multicast packet sent.
    int multicast_hops;
91

92 93 94
    // Sets the maximum transport data unit size in every multicast
    // packet sent.
    int multicast_maxtpdu;
95

96 97 98
    // SO_SNDBUF and SO_RCVBUF to be passed to underlying transport sockets.
    int sndbuf;
    int rcvbuf;
99

100 101
    // Type of service (containing DSCP and ECN socket options)
    int tos;
malosek's avatar
malosek committed
102

103
    //  Socket type.
104
    int8_t type;
105

106
    //  Linger time, in milliseconds.
107
    atomic_value_t linger;
malosek's avatar
malosek committed
108

109 110 111 112
    //  Maximum interval in milliseconds beyond which userspace will
    //  timeout connect().
    //  Default 0 (unused)
    int connect_timeout;
113

114 115 116 117
    //  Maximum interval in milliseconds beyond which TCP will timeout
    //  retransmitted packets.
    //  Default 0 (unused)
    int tcp_maxrt;
118

119 120 121
    //  Minimum interval between attempts to reconnect, in milliseconds.
    //  Default 100ms
    int reconnect_ivl;
122

123 124 125
    //  Maximum interval between attempts to reconnect, in milliseconds.
    //  Default 0 (unused)
    int reconnect_ivl_max;
126

127 128
    //  Maximum backlog for pending connections.
    int backlog;
129

130 131
    //  Maximal size of message to handle.
    int64_t maxmsgsize;
132

133 134 135
    // The timeout for send/recv operations for this socket, in milliseconds.
    int rcvtimeo;
    int sndtimeo;
136

137 138
    //  If true, IPv6 is enabled (as well as IPv4)
    bool ipv6;
139

140 141 142
    //  If 1, connecting pipes are not attached immediately, meaning a send()
    //  on a socket with only connecting pipes would block
    int immediate;
143

144 145
    //  If 1, (X)SUB socket should filter the messages. If 0, it should not.
    bool filter;
146

147 148 149 150
    //  If true, the subscription matching on (X)PUB and (X)SUB sockets
    //  is reversed. Messages are sent to and received by non-matching
    //  sockets.
    bool invert_matching;
151

152 153
    //  If true, the routing id message is forwarded to the socket.
    bool recv_routing_id;
154

155 156 157
    // if true, router socket accepts non-zmq tcp connections
    bool raw_socket;
    bool raw_notify; //  Provide connect notifications
158

159 160
    //  Address of SOCKS proxy
    std::string socks_proxy_address;
161

162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242
    //  TCP keep-alive settings.
    //  Defaults to -1 = do not change socket options
    int tcp_keepalive;
    int tcp_keepalive_cnt;
    int tcp_keepalive_idle;
    int tcp_keepalive_intvl;

    // TCP accept() filters
    typedef std::vector<tcp_address_mask_t> tcp_accept_filters_t;
    tcp_accept_filters_t tcp_accept_filters;

    // IPC accept() filters
#if defined ZMQ_HAVE_SO_PEERCRED || defined ZMQ_HAVE_LOCAL_PEERCRED
    typedef std::set<uid_t> ipc_uid_accept_filters_t;
    ipc_uid_accept_filters_t ipc_uid_accept_filters;
    typedef std::set<gid_t> ipc_gid_accept_filters_t;
    ipc_gid_accept_filters_t ipc_gid_accept_filters;
#endif
#if defined ZMQ_HAVE_SO_PEERCRED
    typedef std::set<pid_t> ipc_pid_accept_filters_t;
    ipc_pid_accept_filters_t ipc_pid_accept_filters;
#endif

    //  Security mechanism for all connections on this socket
    int mechanism;

    //  If peer is acting as server for PLAIN or CURVE mechanisms
    int as_server;

    //  ZAP authentication domain
    std::string zap_domain;

    //  Security credentials for PLAIN mechanism
    std::string plain_username;
    std::string plain_password;

    //  Security credentials for CURVE mechanism
    uint8_t curve_public_key[CURVE_KEYSIZE];
    uint8_t curve_secret_key[CURVE_KEYSIZE];
    uint8_t curve_server_key[CURVE_KEYSIZE];

    //  Principals for GSSAPI mechanism
    std::string gss_principal;
    std::string gss_service_principal;

    //  Name types GSSAPI principals
    int gss_principal_nt;
    int gss_service_principal_nt;

    //  If true, gss encryption will be disabled
    bool gss_plaintext;

    //  ID of the socket.
    int socket_id;

    //  If true, socket conflates outgoing/incoming messages.
    //  Applicable to dealer, push/pull, pub/sub socket types.
    //  Cannot receive multi-part messages.
    //  Ignores hwm
    bool conflate;

    //  If connection handshake is not done after this many milliseconds,
    //  close socket.  Default is 30 secs.  0 means no handshake timeout.
    int handshake_ivl;

    bool connected;
    //  If remote peer receives a PING message and doesn't receive another
    //  message within the ttl value, it should close the connection
    //  (measured in tenths of a second)
    uint16_t heartbeat_ttl;
    //  Time in milliseconds between sending heartbeat PING messages.
    int heartbeat_interval;
    //  Time in milliseconds to wait for a PING response before disconnecting
    int heartbeat_timeout;

#if defined ZMQ_HAVE_VMCI
    uint64_t vmci_buffer_size;
    uint64_t vmci_buffer_min_size;
    uint64_t vmci_buffer_max_size;
    int vmci_connect_timeout;
#endif
243

244 245 246 247
    //  When creating a new ZMQ socket, if this option is set the value
    //  will be used as the File Descriptor instead of allocating a new
    //  one via the socket () system call.
    int use_fd;
Steven McCoy's avatar
Steven McCoy committed
248

249 250
    // Device to bind the underlying socket to, eg. VRF or interface
    std::string bound_device;
251

252 253
    //  Enforce a non-empty ZAP domain requirement for PLAIN auth
    bool zap_enforce_domain;
254 255 256

    // Use of loopback fastpath.
    bool loopback_fastpath;
257

258 259 260
    //  Loop sent multicast packets to local sockets
    bool multicast_loop;

261 262
    // Use zero copy strategy for storing message content when decoding.
    bool zero_copy;
263

264 265 266
    // Router socket ZMQ_NOTIFY_CONNECT/ZMQ_NOTIFY_DISCONNECT notifications
    int router_notify;

267 268
    // Application metadata
    std::map<std::string, std::string> app_metadata;
269 270 271

    // Version of monitor events to emit
    int monitor_event_version;
272
};
273

274 275 276 277 278 279 280 281 282
inline bool get_effective_conflate_option (const options_t &options)
{
    // conflate is only effective for some socket types
    return options.conflate
           && (options.type == ZMQ_DEALER || options.type == ZMQ_PULL
               || options.type == ZMQ_PUSH || options.type == ZMQ_PUB
               || options.type == ZMQ_SUB);
}

283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303
int do_getsockopt (void *const optval_,
                   size_t *const optvallen_,
                   const void *value_,
                   const size_t value_len_);

template <typename T>
int do_getsockopt (void *const optval_, size_t *const optvallen_, T value_)
{
#if __cplusplus >= 201103L && (!defined(__GNUC__) || __GNUC__ > 5)
    static_assert (std::is_trivially_copyable<T>::value,
                   "invalid use of do_getsockopt");
#endif
    return do_getsockopt (optval_, optvallen_, &value_, sizeof (T));
}

int do_getsockopt (void *const optval_,
                   size_t *const optvallen_,
                   const std::string &value_);

int do_setsockopt_int_as_bool_strict (const void *const optval_,
                                      const size_t optvallen_,
304
                                      bool *const out_value_);
305 306 307

int do_setsockopt_int_as_bool_relaxed (const void *const optval_,
                                       const size_t optvallen_,
308
                                       bool *const out_value_);
309 310 311
}

#endif