options.hpp 7.88 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 <set>
36

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

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

Pieter Hintjens's avatar
Pieter Hintjens committed
48 49 50 51
//  Normal base 256 key is 32 bytes
#define CURVE_KEYSIZE       32
//  Key encoded using Z85 is 40 bytes
#define CURVE_KEYSIZE_Z85   40
52

53 54 55 56 57 58
namespace zmq
{
    struct options_t
    {
        options_t ();

59 60
        int set_curve_key(uint8_t * destination, const void * optval_, size_t optvallen_);

61
        int setsockopt (int option_, const void *optval_, size_t optvallen_);
62 63 64
        int getsockopt (int option_, void *optval_, size_t *optvallen_) const;

        bool is_valid (int option_) const;
65

66 67 68
        //  High-water marks for message pipes.
        int sndhwm;
        int rcvhwm;
69

70
        //  I/O thread affinity.
71
        uint64_t affinity;
malosek's avatar
malosek committed
72

73 74 75
        //  Socket identity
        unsigned char identity_size;
        unsigned char identity [256];
76

77
        //  Maximum transfer rate [kb/s]. Default 100kb/s.
78
        int rate;
malosek's avatar
malosek committed
79

80
        //  Reliability time interval [ms]. Default 10 seconds.
81
        int recovery_ivl;
82

83 84 85
        // Sets the time-to-live field in every multicast packet sent.
        int multicast_hops;

86 87 88 89
        // Sets the maximum transport data unit size in every multicast
        // packet sent.
        int multicast_maxtpdu;

90 91 92
        // SO_SNDBUF and SO_RCVBUF to be passed to underlying transport sockets.
        int sndbuf;
        int rcvbuf;
93

94 95 96
        // Type of service (containing DSCP and ECN socket options)
        int tos;

97 98 99
        //  Socket type.
        int type;

100 101 102
        //  Linger time, in milliseconds.
        int linger;

103 104 105 106
        //  Maximum interval in milliseconds beyond which userspace will
        //  timeout connect().
        //  Default 0 (unused)
        int connect_timeout;
107 108 109 110

        //  Maximum interval in milliseconds beyond which TCP will timeout
        //  retransmitted packets.
        //  Default 0 (unused)
111
        int tcp_maxrt;
112

113 114
        //  Minimum interval between attempts to reconnect, in milliseconds.
        //  Default 100ms
115
        int reconnect_ivl;
116

117 118 119
        //  Maximum interval between attempts to reconnect, in milliseconds.
        //  Default 0 (unused)
        int reconnect_ivl_max;
120

121 122 123
        //  Maximum backlog for pending connections.
        int backlog;

124 125 126
        //  Maximal size of message to handle.
        int64_t maxmsgsize;

127 128 129 130
        // The timeout for send/recv operations for this socket.
        int rcvtimeo;
        int sndtimeo;

Pieter Hintjens's avatar
Pieter Hintjens committed
131 132
        //  If true, IPv6 is enabled (as well as IPv4)
        bool ipv6;
133

134 135
        //  If 1, connecting pipes are not attached immediately, meaning a send()
        //  on a socket with only connecting pipes would block
136
        int immediate;
Steven McCoy's avatar
Steven McCoy committed
137

138 139
        //  If 1, (X)SUB socket should filter the messages. If 0, it should not.
        bool filter;
140

141 142 143 144 145
        //  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;

146
        //  If true, the identity message is forwarded to the socket.
147
        bool recv_identity;
Martin Hurton's avatar
Martin Hurton committed
148

149
        // if true, router socket accepts non-zmq tcp connections
150 151
        bool raw_socket;
        bool raw_notify;        //  Provide connect notifications
152

153
        //  Address of SOCKS proxy
154 155
        std::string socks_proxy_address;

156 157 158 159 160 161 162
        //  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;

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

167 168
        // IPC accept() filters
#       if defined ZMQ_HAVE_SO_PEERCRED || defined ZMQ_HAVE_LOCAL_PEERCRED
169
        bool zap_ipc_creds;
170 171 172 173 174 175 176 177 178 179
        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

180 181
        //  Security mechanism for all connections on this socket
        int mechanism;
182

183
        //  If peer is acting as server for PLAIN or CURVE mechanisms
184 185 186 187 188
        int as_server;

        //  ZAP authentication domain
        std::string zap_domain;

189 190 191 192
        //  Security credentials for PLAIN mechanism
        std::string plain_username;
        std::string plain_password;

193
        //  Security credentials for CURVE mechanism
194 195 196
        uint8_t curve_public_key [CURVE_KEYSIZE];
        uint8_t curve_secret_key [CURVE_KEYSIZE];
        uint8_t curve_server_key [CURVE_KEYSIZE];
197

Chris Busbey's avatar
Chris Busbey committed
198 199 200
        //  Principals for GSSAPI mechanism
        std::string gss_principal;
        std::string gss_service_principal;
201

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

205 206
        //  ID of the socket.
        int socket_id;
danielkr's avatar
danielkr committed
207 208 209 210 211 212

        //  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;
213 214 215 216 217

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

218
        bool connected;
Jonathan Reams's avatar
Jonathan Reams committed
219 220 221 222 223 224 225 226 227
        //  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;

Ilya Kulakov's avatar
Ilya Kulakov committed
228 229 230 231 232 233
#       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
234 235 236 237

        //  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.
238
        int use_fd;
239 240 241 242
    };
}

#endif