/* SPDX-License-Identifier: MPL-2.0 */

#ifndef __ZMQ_OPTIONS_HPP_INCLUDED__

#define __ZMQ_OPTIONS_HPP_INCLUDED__

#include <string>

#include <vector>

#include <map>

#include "atomic_ptr.hpp"

#include "stddef.h"

#include "stdint.hpp"

#include "tcp_address.hpp"

#if defined ZMQ_HAVE_SO_PEERCRED || defined ZMQ_HAVE_LOCAL_PEERCRED

#include <set>

#include <sys/types.h>

#endif

#ifdef ZMQ_HAVE_LOCAL_PEERCRED

#include <sys/ucred.h>

#endif

#if __cplusplus >= 201103L || (defined _MSC_VER && _MSC_VER >= 1700)

#include <type_traits>

#endif

//  Normal base 256 key is 32 bytes

#define CURVE_KEYSIZE 32

//  Key encoded using Z85 is 40 bytes

#define CURVE_KEYSIZE_Z85 40

namespace zmq

{

struct options_t

{

    options_t ();

    int set_curve_key (uint8_t *destination_,

                       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;

    //  Reliability time interval [ms]. Default 10 seconds.

    int recovery_ivl;

    // Sets the time-to-live field in every multicast packet sent.

    int multicast_hops;

    // Sets the maximum transport data unit size in every multicast

    // packet sent.

    int multicast_maxtpdu;

    // SO_SNDBUF and SO_RCVBUF to be passed to underlying transport sockets.

    int sndbuf;

    int rcvbuf;

    // Type of service (containing DSCP and ECN socket options)

    int tos;

    // Protocol-defined priority

    int priority;

    //  Socket type.

    int8_t type;

    //  Linger time, in milliseconds.

    atomic_value_t linger;

    //  Maximum interval in milliseconds beyond which userspace will

    //  timeout connect().

    //  Default 0 (unused)

    int connect_timeout;

    //  Maximum interval in milliseconds beyond which TCP will timeout

    //  retransmitted packets.

    //  Default 0 (unused)

    int tcp_maxrt;

    //  Disable reconnect under certain conditions

    //  Default 0

    int reconnect_stop;

    //  Minimum interval between attempts to reconnect, in milliseconds.

    //  Default 100ms

    int reconnect_ivl;

    //  Maximum interval between attempts to reconnect, in milliseconds.

    //  Default 0ms (meaning maximum interval is disabled)

    int reconnect_ivl_max;

    //  Maximum backlog for pending connections.

    int backlog;

    //  Maximal size of message to handle.

    int64_t maxmsgsize;

    // The timeout for send/recv operations for this socket, in milliseconds.

    int rcvtimeo;

    int sndtimeo;

    //  If true, IPv6 is enabled (as well as IPv4)

    bool ipv6;

    //  If 1, connecting pipes are not attached immediately, meaning a send()

    //  on a socket with only connecting pipes would block

    int immediate;

    //  If 1, (X)SUB socket should filter the messages. If 0, it should not.

    bool filter;

    //  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;

    //  If true, the routing id message is forwarded to the socket.

    bool recv_routing_id;

    // if true, router socket accepts non-zmq tcp connections

    bool raw_socket;

    bool raw_notify; //  Provide connect notifications

    //  Address of SOCKS proxy

    std::string socks_proxy_address;

    // Credentials for SOCKS proxy.

    // Connection method will be basic auth if username

    // is not empty, no auth otherwise.

    std::string socks_proxy_username;

    std::string socks_proxy_password;

    //  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

    //  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;

    // Device to bind the underlying socket to, eg. VRF or interface

    std::string bound_device;

    //  Enforce a non-empty ZAP domain requirement for PLAIN auth

    bool zap_enforce_domain;

    // Use of loopback fastpath.

    bool loopback_fastpath;

    //  Loop sent multicast packets to local sockets

    bool multicast_loop;

    //  Maximal batching size for engines with receiving functionality.

    //  So, if there are 10 messages that fit into the batch size, all of

    //  them may be read by a single 'recv' system call, thus avoiding

    //  unnecessary network stack traversals.

    int in_batch_size;

    //  Maximal batching size for engines with sending functionality.

    //  So, if there are 10 messages that fit into the batch size, all of

    //  them may be written by a single 'send' system call, thus avoiding

    //  unnecessary network stack traversals.

    int out_batch_size;

    // Use zero copy strategy for storing message content when decoding.

    bool zero_copy;

    // Router socket ZMQ_NOTIFY_CONNECT/ZMQ_NOTIFY_DISCONNECT notifications

    int router_notify;

    // Application metadata

    std::map<std::string, std::string> app_metadata;

    // Version of monitor events to emit

    int monitor_event_version;

    //  WSS Keys

    std::string wss_key_pem;

    std::string wss_cert_pem;

    std::string wss_trust_pem;

    std::string wss_hostname;

    bool wss_trust_system;

    //  Hello msg

    std::vector<unsigned char> hello_msg;

    bool can_send_hello_msg;

    //  Disconnect msg

    std::vector<unsigned char> disconnect_msg;

    bool can_recv_disconnect_msg;

    //  Hiccup msg

    std::vector<unsigned char> hiccup_msg;

    bool can_recv_hiccup_msg;

    // NORM Options

    int norm_mode;

    bool norm_unicast_nacks;

    int norm_buffer_size;

    int norm_segment_size;

    int norm_block_size;

    int norm_num_parity;

    int norm_num_autoparity;

    bool norm_push_enable;

    //  This option removes several delays caused by scheduling, interrupts and context switching.

    int busy_poll;

};

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);

}

int do_getsockopt (void *optval_,

                   size_t *optvallen_,

                   const void *value_,

                   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 *optval_,

                   size_t *optvallen_,

                   const std::string &value_);

int do_setsockopt_int_as_bool_strict (const void *optval_,

                                      size_t optvallen_,

                                      bool *out_value_);

int do_setsockopt_int_as_bool_relaxed (const void *optval_,

                                       size_t optvallen_,

                                       bool *out_value_);

}

#endif