Solution: Use the appropriate assertion macro.

Solution: Do it unconditionally.

Solution: Pass (std::nothrow) as done in all other places.

Solution: call it simply "ZMQ background" instead of "ZMQ b/g thread"

Solution: fix ifdef check for pthread_setname

Solution: use pthread API to set the name. For now call every thread
"ZMQ b/g thread". Would be nice to number the I/O threads and name
explicitly the reaper thread, but in reality a bit of internal API
churn would be necessary, so perhaps it's not worth it.
This is useful when debugging a process with many threads.

making the creation of FD only when thread safe sockets are in used
within the zmq_poller which improve the zmq_poll performance.

Solution: restore the wsa_assert statement previously removed.

Solution: Change to the way it does below on non-Windows platforms, retry when send returns -1.

Solution: invert check_write and check_hwm calls in router xsend
function so that check_write can mark the pipe as inactive if
necessary.

Solution:

Revert "Problem with ZMQ_ROUTER_MANDATORY option when peer lost"

This partially reverts commit 06740b5d.

The change in the mentioned commit was fixed to be backward
compatible so test changes are no longer necessary.
Partially revert the commit, leaving only the bug fix and taking out
the test change and the superfluous change in socket_base.

indention

Revert "indention"

This reverts commit a6e7e192ac2d089ac9f7dc0d31d4b1fd10de982e.

indention

indention

Fix Failure in tests

Check both pipe full and pipe close

Solution: in the address validator accept an endpoint that starts
with :, eg: ::ffff:192.168.0.1:12345 as it's a valid mapped
address.

This is based on https://github.com/zeromq/zeromq3-x/pull/116/files

* Fix possible clock_t crash on iOS 9.3.2 and 9.3.5 + macOS < 10.12

* No need to read return value

* Problem: zmq_z85_decode does not validate its input
Solution: added checks for invalid characters and overflows

* Added tests, added further check for range overflow, removed (multiple) calls to strlen

* Problem: gcc fails to build
Solution: added missing include directive

* Added VS2015 test_utils_z85 project

* Fixed indentation and copyright notice

* Resolved garbage from merge

* Revert "Added VS2015 test_utils_z85 project"

This reverts commit c58b3c664c144326e77135aa1184b6f0dee11143.

* Problem: test calls zmq_z85_decode with a NULL dest
Solution: call zmq_z85_decode with a properly sized buffer

* Problem: tests for zmq_z85_* scattered over two files
Solution: merged files

* Removed reference to removed test file from CMakeLists.txt

* Problem: Missing include directive to stdint.h
Solution: Added include directive

* Define __STDC_LIMIT_MACROS before including stdint.h

* Problem: Wrong variable is checked for invalid character marker
Solution: Use correct variable

As discussed in #2307

Solution: where change pipe hwm, send a command (new type pipe_hwm) to peer, so peer pipe can modify hwm thread-safely

Solution: initialise *hwmboost to -1 instead of 1, and use it only if
it's >= 0. The socket option code checks anyway that the
user-provided value is >= 0 so there is no risk of clashing. The
documentation also specifies that it has to be >= 0.

Solution: revert change from #2299 to avoid bugs while we look for an
alternative and thread-safe solution

Solution: setsockopt returns EINVAL if the connection was closed by
the peer after the accept returned a valid socket. This is a valid
network error and should not cause an assert.
To handle this we have to extract the setsockopt from the stream
engine, as there's no clean way to return an error from the
constructor. Instead, try to set this option before creating the
engine in the callers, and return immediately as if the accept
had failed to avoid churn. Do the same for the connect calls by
setting the option in open_socket, so that the option for that
case is set even before connecting, so there's no possible race
condition.
Since this has to be done in 4 places (tcp/ipc listener, socks
connecter and open_socket) add an utility function in ip.cpp.
Fixes #1442

The mechanism is instanciated during the handshake itself, when and
error happen before this, the error method shall work anyway.
An error handling with a NULL mechanism means the handshake fail, so the
handshake failure event is also raised in this case.

 - removed the previously added encryption_error, less changes less bug
 - handshake fail is now signaled when an error happen while the
   mechanism is still hanshaking

Solution: check if IPV6_TCLASS is defined so that when Hurd adds
support it will just work. Also it will avoid tripping over this on
other similar legacy systems.

Solution: wrap the event triggering in the DRAFT ifdef as well as the
defines. This ensures that the event are returned only if the
library was built with DRAFTs enabled.

Also update the test case to expect the new events since it uses
the catch-all mask. Although the sequence of event is different and
this might be considered as an API breakage, using the catch-all
ZMQ_EVENT_ALL mask implies that, well, all events are monitored so
it's normal that new ones will be added.
Users that don't want this kind of behaviour to change can simply
monitor only the event that they care about.

 - Moved new events in draft section + added to zmq_draft.h
 - Removed the remainning tabs
 - Reverted the hard error (back to soft error) in curve_server.cpp

=> The feature doesn't works anymore

Added two new monitoring events:
 - ZMQ_EVENT_HANDSHAKE_SUCCEED is raised once the encryption handshake succeed
 - ZMQ_EVENT_HANDSHAKE_FAILED is raised when it failed
Both events are raised on server and client side.

Solution: move it there, add it to src/zmq_draft.h and clarify in the
documentation and in the NEWS file that this option is not yet stable

Solution: if available, call socketpair with SOCK_CLOEXEC flag to
make the process close the socket on fork+exec

Solution: if available, use eventfd with EFD_CLOEXEC flag to make
the process close the socket on fork+exec

Solution: if available, use epoll_create1 with EPOLL_CLOEXEC flag to
make the process close the socket on fork+exec

Solution: add a comment as it's easy to miss and very tempting to
"optimize"

Solution: set_curve_key method in options_t struct with little
improvement in switch-case block