Merge pull request #3754 from sigiesec/code-improvements-analyze

Improvements to static analysis & resolve some issues identified by static analysis
2025-03-10 16:06:09 +00:00 · 2019-12-08 17:31:02 +00:00 · 2019-12-08 17:31:02 +00:00 · 400107d765
commit 400107d765
parent b9ddf62261 76460c5e17
75 changed files with 445 additions and 413 deletions
--- a/.clang-tidy
+++ b/.clang-tidy
@ -9,21 +9,28 @@ Checks:        "*,\
 -fuchsia-default-arguments,\
 -google-readability-todo,\
 -google-runtime-int,\
+-cppcoreguidelines-avoid-goto,\
 -cppcoreguidelines-pro-type-member-init,\
 -cppcoreguidelines-pro-type-static-cast-downcast,\
 # not applicable\
+-fuchsia-default-argument-calls,\
 -fuchsia-overloaded-operator,\
+-fuchsia-statically-constructed-objects,\
 # not currently a coding convention, C++11-specific, but conceivable,\
 -modernize-use-nullptr,\
 -modernize-use-equals-default,\
 -modernize-deprecated-headers,\
 # not currently a coding convention, C++11-specific and hard to implement,\
 -hicpp-no-malloc,\
+-hicpp-avoid-c-arrays,\
+-modernize-avoid-c-arrays,\
 -modernize-pass-by-value,\
 -modernize-loop-convert,\
 -modernize-use-auto,\
+-modernize-use-trailing-return-type,\
 -modernize-use-using,\
 -modernize-return-braced-init-list,\
+-cppcoreguidelines-avoid-c-arrays,\
 -cppcoreguidelines-no-malloc,\
 -cppcoreguidelines-owning-memory,\
 -cppcoreguidelines-pro-type-union-access,\
@ -37,6 +44,7 @@ Checks:        "*,\
 # duplicates,\
 -google-readability-braces-around-statements,\
 -cppcoreguidelines-pro-type-cstyle-cast,\
+-cppcoreguidelines-avoid-magic-numbers,\
 -hicpp-braces-around-statements,\
 -hicpp-use-equals-default,\
 -hicpp-deprecated-headers,\
--- a/.travis.yml
+++ b/.travis.yml
@ -29,18 +29,18 @@ env:
 matrix:
  include:
  - if: type = cron OR (branch =~ analyze$ AND type = push)
-    env: BUILD_TYPE=cmake CLANG_TIDY=/usr/bin/clang-tidy-6.0 CC=clang-6.0 CXX=clang++-6.0
+    env: BUILD_TYPE=cmake CLANG_TIDY=/usr/bin/clang-tidy-8 CC=clang-8 CXX=clang++-8
    os: linux
    compiler: clang
    addons:
      apt:
        sources:
          - ubuntu-toolchain-r-test
-          - llvm-toolchain-trusty-6.0
+          - llvm-toolchain-trusty-8
        packages:
-          - clang-6.0
-          - clang-tools-6.0
-          - clang-tidy-6.0
+          - clang-8
+          - clang-tools-8
+          - clang-tidy-8
  - env: BUILD_TYPE=default CURVE=tweetnacl IPv6=ON
    os: linux
    dist: precise
@ -107,15 +107,15 @@ matrix:
  - env: BUILD_TYPE=android CURVE=tweetnacl
    os: linux
    dist: trusty
-  - env: BUILD_TYPE=cmake DO_CLANG_FORMAT_CHECK=1 CLANG_FORMAT=/usr/lib/llvm-7/bin/clang-format
+  - env: BUILD_TYPE=cmake DO_CLANG_FORMAT_CHECK=1 CLANG_FORMAT=/usr/lib/llvm-8/bin/clang-format
    os: linux
    addons:
      apt:
        sources:
-        - llvm-toolchain-trusty-7
+        - llvm-toolchain-trusty-8
        - ubuntu-toolchain-r-test
        packages:
-        - clang-format-7
+        - clang-format-8
  - env: BUILD_TYPE=default POLLER=poll
    os: linux
  - env: BUILD_TYPE=default POLLER=select
--- a/builds/cmake/ci_build.sh
+++ b/builds/cmake/ci_build.sh
@ -60,8 +60,8 @@ if [ -n "$CLANG_TIDY" ] ; then
        MAKE_PREFIXES+=("${TRAVIS_BUILD_DIR}/bw-output")
        
    fi
-    CMAKE_PREFIXES+=("scan-build-6.0")
-    MAKE_PREFIXES+=("scan-build-6.0")
+    CMAKE_PREFIXES+=("scan-build-8")
+    MAKE_PREFIXES+=("scan-build-8")
    MAKE_PREFIXES+=("-plist-html")
    SCAN_BUILD_OUTPUT="$(pwd)/scan-build-report"
    MAKE_PREFIXES+=("-o ${SCAN_BUILD_OUTPUT}")
--- a/src/ctx.cpp
+++ b/src/ctx.cpp
@ -385,11 +385,11 @@ int zmq::ctx_t::get (int option_, void *optval_, size_t *optvallen_)

 int zmq::ctx_t::get (int option_)
 {
-    int optval_ = 0;
-    size_t optvallen_ = sizeof (int);
+    int optval = 0;
+    size_t optvallen = sizeof (int);

-    if (get (option_, &optval_, &optvallen_) == 0)
-        return optval_;
+    if (get (option_, &optval, &optvallen) == 0)
+        return optval;

    errno = EINVAL;
    return -1;
@ -616,7 +616,9 @@ int zmq::thread_ctx_t::set (int option_, const void *optval_, size_t optvallen_)
    return -1;
 }

-int zmq::thread_ctx_t::get (int option_, void *optval_, size_t *optvallen_)
+int zmq::thread_ctx_t::get (int option_,
+                            void *optval_,
+                            const size_t *optvallen_)
 {
    const bool is_int = (*optvallen_ == sizeof (int));
    int *value = static_cast<int *> (optval_);
--- a/src/ctx.hpp
+++ b/src/ctx.hpp
@ -73,7 +73,7 @@ class thread_ctx_t
                       const char *name_ = NULL) const;

    int set (int option_, const void *optval_, size_t optvallen_);
-    int get (int option_, void *optval_, size_t *optvallen_);
+    int get (int option_, void *optval_, const size_t *optvallen_);

  protected:
    //  Synchronisation of access to context options.
--- a/src/curve_client.cpp
+++ b/src/curve_client.cpp
@ -128,8 +128,8 @@ zmq::mechanism_t::status_t zmq::curve_client_t::status () const
        return mechanism_t::ready;
    if (_state == error_received)
        return mechanism_t::error;
-    else
-        return mechanism_t::handshaking;
+
+    return mechanism_t::handshaking;
 }

 int zmq::curve_client_t::produce_hello (msg_t *msg_)
--- a/src/curve_client.hpp
+++ b/src/curve_client.hpp
@ -72,10 +72,10 @@ class curve_client_t : public curve_mechanism_base_t
    curve_client_tools_t _tools;

    int produce_hello (msg_t *msg_);
-    int process_welcome (const uint8_t *cmd_data_, size_t data_size_);
+    int process_welcome (const uint8_t *msg_data_, size_t msg_size_);
    int produce_initiate (msg_t *msg_);
-    int process_ready (const uint8_t *cmd_data_, size_t data_size_);
-    int process_error (const uint8_t *cmd_data_, size_t data_size_);
+    int process_ready (const uint8_t *msg_data_, size_t msg_size_);
+    int process_error (const uint8_t *msg_data_, size_t msg_size_);
 };
 }

--- a/src/decoder_allocators.hpp
+++ b/src/decoder_allocators.hpp
@ -103,7 +103,7 @@ class shared_message_memory_allocator

    void inc_ref ();

-    static void call_dec_ref (void *, void *buffer_);
+    static void call_dec_ref (void *, void *hint_);

    std::size_t size () const;

--- a/src/ip.cpp
+++ b/src/ip.cpp
@ -255,9 +255,9 @@ int zmq::bind_to_device (fd_t s_, const std::string &bound_device_)
    if (rc != 0) {
        assert_success_or_recoverable (s_, rc);
        return -1;
-    } else {
-        return 0;
    }
+    return 0;
+
 #else
    LIBZMQ_UNUSED (s_);
    LIBZMQ_UNUSED (bound_device_);
@ -550,10 +550,10 @@ int zmq::make_fdpair (fd_t *r_, fd_t *w_)
        errno_assert (errno == ENFILE || errno == EMFILE);
        *w_ = *r_ = -1;
        return -1;
-    } else {
-        *w_ = *r_ = fd;
-        return 0;
    }
+    *w_ = *r_ = fd;
+    return 0;
+

 #elif defined ZMQ_HAVE_WINDOWS
 #ifdef ZMQ_HAVE_IPC
--- a/src/options.cpp
+++ b/src/options.cpp
@ -85,7 +85,7 @@ int zmq::do_getsockopt (void *const optval_,

 #ifdef ZMQ_HAVE_CURVE
 static int do_getsockopt_curve_key (void *const optval_,
-                                    size_t *const optvallen_,
+                                    const size_t *const optvallen_,
                                    const uint8_t (&curve_key_)[CURVE_KEYSIZE])
 {
    if (*optvallen_ == CURVE_KEYSIZE) {
--- a/src/proxy.cpp
+++ b/src/proxy.cpp
@ -128,8 +128,8 @@ int forward (class zmq::socket_base_t *from_,
            if (rc < 0) {
                if (likely (errno == EAGAIN && i > 0))
                    return 0; // End of burst
-                else
-                    return -1;
+
+                return -1;
            }

            complete_msg_size += msg_->size ();
--- a/src/radix_tree.cpp
+++ b/src/radix_tree.cpp
@ -540,7 +540,7 @@ bool zmq::radix_tree_t::check (const unsigned char *key_, size_t key_size_)
 static void
 visit_keys (node_t node_,
            std::vector<unsigned char> &buffer_,
-            void (*func_) (unsigned char *data, size_t size, void *arg),
+            void (*func_) (unsigned char *data_, size_t size_, void *arg_),
            void *arg_)
 {
    for (size_t i = 0; i < node_.prefix_length (); ++i)
@ -558,7 +558,7 @@ visit_keys (node_t node_,
 }

 void zmq::radix_tree_t::apply (
-  void (*func_) (unsigned char *data, size_t size, void *arg), void *arg_)
+  void (*func_) (unsigned char *data_, size_t size_, void *arg_), void *arg_)
 {
    if (_root.refcount () > 0)
        func_ (NULL, 0, arg_); // Root node is always empty.
--- a/src/radix_tree.hpp
+++ b/src/radix_tree.hpp
@ -78,7 +78,7 @@ struct node_t
    inline void set_refcount (uint32_t value_);
    inline void set_prefix_length (uint32_t value_);
    inline void set_edgecount (uint32_t value_);
-    inline void set_prefix (const unsigned char *prefix_);
+    inline void set_prefix (const unsigned char *bytes_);
    inline void set_first_bytes (const unsigned char *bytes_);
    inline void set_first_byte_at (size_t index_, unsigned char byte_);
    inline void set_node_pointers (const unsigned char *pointers_);
--- a/src/session_base.cpp
+++ b/src/session_base.cpp
@ -118,7 +118,8 @@ zmq::session_base_t::session_base_t (class io_thread_t *io_thread_,
    _wss_hostname (NULL)
 {
    if (options_.wss_hostname.length () > 0) {
-        _wss_hostname = (char *) malloc (options_.wss_hostname.length () + 1);
+        _wss_hostname =
+          static_cast<char *> (malloc (options_.wss_hostname.length () + 1));
        assert (_wss_hostname);
        strcpy (_wss_hostname, options_.wss_hostname.c_str ());
    }
--- a/src/socket_base.cpp
+++ b/src/socket_base.cpp
@ -1777,98 +1777,98 @@ int zmq::socket_base_t::monitor (const char *endpoint_,
 void zmq::socket_base_t::event_connected (
  const endpoint_uri_pair_t &endpoint_uri_pair_, zmq::fd_t fd_)
 {
-    uint64_t values[1] = {(uint64_t) fd_};
+    uint64_t values[1] = {static_cast<uint64_t> (fd_)};
    event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_CONNECTED);
 }

 void zmq::socket_base_t::event_connect_delayed (
  const endpoint_uri_pair_t &endpoint_uri_pair_, int err_)
 {
-    uint64_t values[1] = {(uint64_t) err_};
+    uint64_t values[1] = {static_cast<uint64_t> (err_)};
    event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_CONNECT_DELAYED);
 }

 void zmq::socket_base_t::event_connect_retried (
  const endpoint_uri_pair_t &endpoint_uri_pair_, int interval_)
 {
-    uint64_t values[1] = {(uint64_t) interval_};
+    uint64_t values[1] = {static_cast<uint64_t> (interval_)};
    event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_CONNECT_RETRIED);
 }

 void zmq::socket_base_t::event_listening (
  const endpoint_uri_pair_t &endpoint_uri_pair_, zmq::fd_t fd_)
 {
-    uint64_t values[1] = {(uint64_t) fd_};
+    uint64_t values[1] = {static_cast<uint64_t> (fd_)};
    event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_LISTENING);
 }

 void zmq::socket_base_t::event_bind_failed (
  const endpoint_uri_pair_t &endpoint_uri_pair_, int err_)
 {
-    uint64_t values[1] = {(uint64_t) err_};
+    uint64_t values[1] = {static_cast<uint64_t> (err_)};
    event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_BIND_FAILED);
 }

 void zmq::socket_base_t::event_accepted (
  const endpoint_uri_pair_t &endpoint_uri_pair_, zmq::fd_t fd_)
 {
-    uint64_t values[1] = {(uint64_t) fd_};
+    uint64_t values[1] = {static_cast<uint64_t> (fd_)};
    event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_ACCEPTED);
 }

 void zmq::socket_base_t::event_accept_failed (
  const endpoint_uri_pair_t &endpoint_uri_pair_, int err_)
 {
-    uint64_t values[1] = {(uint64_t) err_};
+    uint64_t values[1] = {static_cast<uint64_t> (err_)};
    event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_ACCEPT_FAILED);
 }

 void zmq::socket_base_t::event_closed (
  const endpoint_uri_pair_t &endpoint_uri_pair_, zmq::fd_t fd_)
 {
-    uint64_t values[1] = {(uint64_t) fd_};
+    uint64_t values[1] = {static_cast<uint64_t> (fd_)};
    event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_CLOSED);
 }

 void zmq::socket_base_t::event_close_failed (
  const endpoint_uri_pair_t &endpoint_uri_pair_, int err_)
 {
-    uint64_t values[1] = {(uint64_t) err_};
+    uint64_t values[1] = {static_cast<uint64_t> (err_)};
    event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_CLOSE_FAILED);
 }

 void zmq::socket_base_t::event_disconnected (
  const endpoint_uri_pair_t &endpoint_uri_pair_, zmq::fd_t fd_)
 {
-    uint64_t values[1] = {(uint64_t) fd_};
+    uint64_t values[1] = {static_cast<uint64_t> (fd_)};
    event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_DISCONNECTED);
 }

 void zmq::socket_base_t::event_handshake_failed_no_detail (
  const endpoint_uri_pair_t &endpoint_uri_pair_, int err_)
 {
-    uint64_t values[1] = {(uint64_t) err_};
+    uint64_t values[1] = {static_cast<uint64_t> (err_)};
    event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_HANDSHAKE_FAILED_NO_DETAIL);
 }

 void zmq::socket_base_t::event_handshake_failed_protocol (
  const endpoint_uri_pair_t &endpoint_uri_pair_, int err_)
 {
-    uint64_t values[1] = {(uint64_t) err_};
+    uint64_t values[1] = {static_cast<uint64_t> (err_)};
    event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_HANDSHAKE_FAILED_PROTOCOL);
 }

 void zmq::socket_base_t::event_handshake_failed_auth (
  const endpoint_uri_pair_t &endpoint_uri_pair_, int err_)
 {
-    uint64_t values[1] = {(uint64_t) err_};
+    uint64_t values[1] = {static_cast<uint64_t> (err_)};
    event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_HANDSHAKE_FAILED_AUTH);
 }

 void zmq::socket_base_t::event_handshake_succeeded (
  const endpoint_uri_pair_t &endpoint_uri_pair_, int err_)
 {
-    uint64_t values[1] = {(uint64_t) err_};
+    uint64_t values[1] = {static_cast<uint64_t> (err_)};
    event (endpoint_uri_pair_, values, 1, ZMQ_EVENT_HANDSHAKE_SUCCEEDED);
 }

--- a/src/socket_poller.cpp
+++ b/src/socket_poller.cpp
@ -91,11 +91,10 @@ int zmq::socket_poller_t::signaler_fd (fd_t *fd_)
    if (_signaler) {
        *fd_ = _signaler->get_fd ();
        return 0;
-    } else {
-        // Only thread-safe socket types are guaranteed to have a signaler.
-        errno = EINVAL;
-        return -1;
    }
+    // Only thread-safe socket types are guaranteed to have a signaler.
+    errno = EINVAL;
+    return -1;
 }

 int zmq::socket_poller_t::add (socket_base_t *socket_,
--- a/src/socket_poller.hpp
+++ b/src/socket_poller.hpp
@ -78,7 +78,7 @@ class socket_poller_t
    // Returns the signaler's fd if there is one, otherwise errors.
    int signaler_fd (fd_t *fd_);

-    int wait (event_t *event_, int n_events_, long timeout_);
+    int wait (event_t *events_, int n_events_, long timeout_);

    inline int size () { return static_cast<int> (_items.size ()); };

--- a/src/socks.cpp
+++ b/src/socks.cpp
@ -130,7 +130,7 @@ void zmq::socks_choice_decoder_t::reset ()


 zmq::socks_basic_auth_request_t::socks_basic_auth_request_t (
-  std::string username_, std::string password_) :
+  const std::string &username_, const std::string &password_) :
    username (username_),
    password (password_)
 {
@ -306,7 +306,7 @@ void zmq::socks_request_encoder_t::reset ()
 }

 zmq::socks_response_t::socks_response_t (uint8_t response_code_,
-                                         std::string address_,
+                                         const std::string &address_,
                                         uint16_t port_) :
    response_code (response_code_),
    address (address_),
--- a/src/socks.hpp
+++ b/src/socks.hpp
@ -84,7 +84,8 @@ class socks_choice_decoder_t

 struct socks_basic_auth_request_t
 {
-    socks_basic_auth_request_t (std::string username_, std::string password_);
+    socks_basic_auth_request_t (const std::string &username_,
+                                const std::string &password_);

    const std::string username;
    const std::string password;
@ -152,7 +153,7 @@ class socks_request_encoder_t
 struct socks_response_t
 {
    socks_response_t (uint8_t response_code_,
-                      std::string address_,
+                      const std::string &address_,
                      uint16_t port_);
    uint8_t response_code;
    std::string address;
--- a/src/socks_connecter.cpp
+++ b/src/socks_connecter.cpp
@ -79,12 +79,12 @@ void zmq::socks_connecter_t::set_auth_method_none ()
    _auth_password.clear ();
 }

-void zmq::socks_connecter_t::set_auth_method_basic (const std::string username,
-                                                    const std::string password)
+void zmq::socks_connecter_t::set_auth_method_basic (
+  const std::string &username_, const std::string &password_)
 {
    _auth_method = socks_basic_auth;
-    _auth_username = username;
-    _auth_password = password;
+    _auth_username = username_;
+    _auth_password = password_;
 }

 void zmq::socks_connecter_t::in_event ()
@ -387,8 +387,8 @@ zmq::fd_t zmq::socks_connecter_t::check_proxy_connection ()
    rc = tune_tcp_socket (_s);
    rc = rc
         | tune_tcp_keepalives (
-             _s, options.tcp_keepalive, options.tcp_keepalive_cnt,
-             options.tcp_keepalive_idle, options.tcp_keepalive_intvl);
+           _s, options.tcp_keepalive, options.tcp_keepalive_cnt,
+           options.tcp_keepalive_idle, options.tcp_keepalive_intvl);
    if (rc != 0)
        return -1;

--- a/src/socks_connecter.hpp
+++ b/src/socks_connecter.hpp
@ -54,8 +54,8 @@ class socks_connecter_t : public stream_connecter_base_t
                       bool delayed_start_);
    ~socks_connecter_t ();

-    void set_auth_method_basic (const std::string username,
-                                const std::string password);
+    void set_auth_method_basic (const std::string &username,
+                                const std::string &password);
    void set_auth_method_none ();


--- a/src/stream_connecter_base.cpp
+++ b/src/stream_connecter_base.cpp
@ -169,7 +169,7 @@ void zmq::stream_connecter_base_t::in_event ()
 }

 void zmq::stream_connecter_base_t::create_engine (
-  fd_t fd, const std::string &local_address_)
+  fd_t fd_, const std::string &local_address_)
 {
    const endpoint_uri_pair_t endpoint_pair (local_address_, _endpoint,
                                             endpoint_type_connect);
@ -177,9 +177,9 @@ void zmq::stream_connecter_base_t::create_engine (
    //  Create the engine object for this connection.
    i_engine *engine;
    if (options.raw_socket)
-        engine = new (std::nothrow) raw_engine_t (fd, options, endpoint_pair);
+        engine = new (std::nothrow) raw_engine_t (fd_, options, endpoint_pair);
    else
-        engine = new (std::nothrow) zmtp_engine_t (fd, options, endpoint_pair);
+        engine = new (std::nothrow) zmtp_engine_t (fd_, options, endpoint_pair);
    alloc_assert (engine);

    //  Attach the engine to the corresponding session object.
@ -188,7 +188,7 @@ void zmq::stream_connecter_base_t::create_engine (
    //  Shut the connecter down.
    terminate ();

-    _socket->event_connected (endpoint_pair, fd);
+    _socket->event_connected (endpoint_pair, fd_);
 }

 void zmq::stream_connecter_base_t::timer_event (int id_)
--- a/src/stream_engine_base.cpp
+++ b/src/stream_engine_base.cpp
@ -465,14 +465,13 @@ int zmq::stream_engine_base_t::next_handshake_command (msg_t *msg_)
    if (_mechanism->status () == mechanism_t::error) {
        errno = EPROTO;
        return -1;
-    } else {
-        const int rc = _mechanism->next_handshake_command (msg_);
-
-        if (rc == 0)
-            msg_->set_flags (msg_t::command);
-
-        return rc;
    }
+    const int rc = _mechanism->next_handshake_command (msg_);
+
+    if (rc == 0)
+        msg_->set_flags (msg_t::command);
+
+    return rc;
 }

 int zmq::stream_engine_base_t::process_handshake_command (msg_t *msg_)
--- a/src/stream_listener_base.cpp
+++ b/src/stream_listener_base.cpp
@ -97,17 +97,17 @@ int zmq::stream_listener_base_t::close ()
    return 0;
 }

-void zmq::stream_listener_base_t::create_engine (fd_t fd)
+void zmq::stream_listener_base_t::create_engine (fd_t fd_)
 {
    const endpoint_uri_pair_t endpoint_pair (
-      get_socket_name (fd, socket_end_local),
-      get_socket_name (fd, socket_end_remote), endpoint_type_bind);
+      get_socket_name (fd_, socket_end_local),
+      get_socket_name (fd_, socket_end_remote), endpoint_type_bind);

    i_engine *engine;
    if (options.raw_socket)
-        engine = new (std::nothrow) raw_engine_t (fd, options, endpoint_pair);
+        engine = new (std::nothrow) raw_engine_t (fd_, options, endpoint_pair);
    else
-        engine = new (std::nothrow) zmtp_engine_t (fd, options, endpoint_pair);
+        engine = new (std::nothrow) zmtp_engine_t (fd_, options, endpoint_pair);
    alloc_assert (engine);

    //  Choose I/O thread to run connecter in. Given that we are already
@ -123,5 +123,5 @@ void zmq::stream_listener_base_t::create_engine (fd_t fd)
    launch_child (session);
    send_attach (session, engine, false);

-    _socket->event_accepted (endpoint_pair, fd);
+    _socket->event_accepted (endpoint_pair, fd_);
 }
--- a/src/tcp_address.cpp
+++ b/src/tcp_address.cpp
@ -113,23 +113,23 @@ int zmq::tcp_address_t::resolve (const char *name_, bool local_, bool ipv6_)
 }

 template <size_t N1, size_t N2>
-static std::string make_address_string (const char *hbuf,
-                                        uint16_t port,
-                                        const char (&ipv6_prefix)[N1],
-                                        const char (&ipv6_suffix)[N2])
+static std::string make_address_string (const char *hbuf_,
+                                        uint16_t port_,
+                                        const char (&ipv6_prefix_)[N1],
+                                        const char (&ipv6_suffix_)[N2])
 {
    const size_t max_port_str_length = 5;
-    char buf[NI_MAXHOST + sizeof ipv6_prefix + sizeof ipv6_suffix
+    char buf[NI_MAXHOST + sizeof ipv6_prefix_ + sizeof ipv6_suffix_
             + max_port_str_length];
    char *pos = buf;
-    memcpy (pos, ipv6_prefix, sizeof ipv6_prefix - 1);
-    pos += sizeof ipv6_prefix - 1;
-    const size_t hbuf_len = strlen (hbuf);
-    memcpy (pos, hbuf, hbuf_len);
+    memcpy (pos, ipv6_prefix_, sizeof ipv6_prefix_ - 1);
+    pos += sizeof ipv6_prefix_ - 1;
+    const size_t hbuf_len = strlen (hbuf_);
+    memcpy (pos, hbuf_, hbuf_len);
    pos += hbuf_len;
-    memcpy (pos, ipv6_suffix, sizeof ipv6_suffix - 1);
-    pos += sizeof ipv6_suffix - 1;
-    pos += sprintf (pos, "%d", ntohs (port));
+    memcpy (pos, ipv6_suffix_, sizeof ipv6_suffix_ - 1);
+    pos += sizeof ipv6_suffix_ - 1;
+    pos += sprintf (pos, "%d", ntohs (port_));
    return std::string (buf, pos - buf);
 }

--- a/src/thread.cpp
+++ b/src/thread.cpp
@ -277,10 +277,10 @@ bool zmq::thread_t::is_current_thread () const
 }

 void zmq::thread_t::setSchedulingParameters (
-  int priority_, int schedulingPolicy_, const std::set<int> &affinity_cpus_)
+  int priority_, int scheduling_policy_, const std::set<int> &affinity_cpus_)
 {
    _thread_priority = priority_;
-    _thread_sched_policy = schedulingPolicy_;
+    _thread_sched_policy = scheduling_policy_;
    _thread_affinity_cpus = affinity_cpus_;
 }

--- a/src/tipc_address.cpp
+++ b/src/tipc_address.cpp
@ -44,13 +44,13 @@ zmq::tipc_address_t::tipc_address_t ()
    _random = false;
 }

-zmq::tipc_address_t::tipc_address_t (const sockaddr *sa, socklen_t sa_len)
+zmq::tipc_address_t::tipc_address_t (const sockaddr *sa_, socklen_t sa_len_)
 {
-    zmq_assert (sa && sa_len > 0);
+    zmq_assert (sa_ && sa_len_ > 0);

    memset (&address, 0, sizeof address);
-    if (sa->sa_family == AF_TIPC)
-        memcpy (&address, sa, sa_len);
+    if (sa_->sa_family == AF_TIPC)
+        memcpy (&address, sa_, sa_len_);

    _random = false;
 }
@ -70,7 +70,7 @@ bool zmq::tipc_address_t::is_service () const

    return true;
 }
-int zmq::tipc_address_t::resolve (const char *name)
+int zmq::tipc_address_t::resolve (const char *name_)
 {
    unsigned int type = 0;
    unsigned int lower = 0;
@ -82,7 +82,7 @@ int zmq::tipc_address_t::resolve (const char *name)
    int res;


-    if (strncmp (name, "<*>", 3) == 0) {
+    if (strncmp (name_, "<*>", 3) == 0) {
        set_random ();
        address.family = AF_TIPC;
        address.addrtype = TIPC_ADDR_ID;
@ -92,9 +92,9 @@ int zmq::tipc_address_t::resolve (const char *name)
        return 0;
    }

-    res = sscanf (name, "{%u,%u,%u}", &type, &lower, &upper);
+    res = sscanf (name_, "{%u,%u,%u}", &type, &lower, &upper);
    /* Fetch optional domain suffix. */
-    if ((domain = strchr (name, '@'))) {
+    if ((domain = strchr (name_, '@'))) {
        if (sscanf (domain, "@%u.%u.%u%c", &z, &c, &n, &eof) != 3)
            return EINVAL;
    }
@ -108,7 +108,8 @@ int zmq::tipc_address_t::resolve (const char *name)
        address.addr.nameseq.upper = upper;
        address.scope = TIPC_ZONE_SCOPE;
        return 0;
-    } else if (res == 2 && type > TIPC_RESERVED_TYPES) {
+    }
+    if (res == 2 && type > TIPC_RESERVED_TYPES) {
        address.family = AF_TIPC;
        address.addrtype = TIPC_ADDR_NAME;
        address.addr.name.name.type = type;
@ -117,7 +118,7 @@ int zmq::tipc_address_t::resolve (const char *name)
        address.scope = 0;
        return 0;
    } else if (res == 0) {
-        res = sscanf (name, "<%u.%u.%u:%u>", &z, &c, &n, &ref);
+        res = sscanf (name_, "<%u.%u.%u:%u>", &z, &c, &n, &ref);
        if (res == 4) {
            address.family = AF_TIPC;
            address.addrtype = TIPC_ADDR_ID;
@ -165,7 +166,7 @@ const sockaddr *zmq::tipc_address_t::addr () const

 socklen_t zmq::tipc_address_t::addrlen () const
 {
-    return (socklen_t) sizeof address;
+    return static_cast<socklen_t> (sizeof address);
 }

 #endif
--- a/src/tipc_connecter.cpp
+++ b/src/tipc_connecter.cpp
@ -153,7 +153,8 @@ zmq::fd_t zmq::tipc_connecter_t::connect ()
 #else
    socklen_t len = sizeof (err);
 #endif
-    int rc = getsockopt (_s, SOL_SOCKET, SO_ERROR, (char *) &err, &len);
+    int rc = getsockopt (_s, SOL_SOCKET, SO_ERROR,
+                         reinterpret_cast<char *> (&err), &len);
    if (rc == -1)
        err = errno;
    if (err != 0) {
--- a/src/tipc_listener.cpp
+++ b/src/tipc_listener.cpp
@ -111,7 +111,8 @@ int zmq::tipc_listener_t::set_local_address (const char *addr_)
        if (sl == 0)
            goto error;

-        _address = tipc_address_t ((struct sockaddr *) &ss, sl);
+        _address =
+          tipc_address_t (reinterpret_cast<struct sockaddr *> (&ss), sl);
    }


@ -156,7 +157,8 @@ zmq::fd_t zmq::tipc_listener_t::accept ()
 #ifdef ZMQ_HAVE_VXWORKS
    fd_t sock = ::accept (_s, (struct sockaddr *) &ss, (int *) &ss_len);
 #else
-    fd_t sock = ::accept (_s, (struct sockaddr *) &ss, &ss_len);
+    fd_t sock =
+      ::accept (_s, reinterpret_cast<struct sockaddr *> (&ss), &ss_len);
 #endif
    if (sock == -1) {
        errno_assert (errno == EAGAIN || errno == EWOULDBLOCK
--- a/src/udp_address.hpp
+++ b/src/udp_address.hpp
@ -47,7 +47,7 @@ class udp_address_t
    udp_address_t ();
    virtual ~udp_address_t ();

-    int resolve (const char *name_, bool receiver_, bool ipv6_);
+    int resolve (const char *name_, bool bind_, bool ipv6_);

    //  The opposite to resolve()
    virtual int to_string (std::string &addr_);
--- a/src/udp_engine.hpp
+++ b/src/udp_engine.hpp
@ -46,7 +46,7 @@ class udp_engine_t : public io_object_t, public i_engine
    const endpoint_uri_pair_t &get_endpoint () const;

  private:
-    int resolve_raw_address (char *addr_, size_t length_);
+    int resolve_raw_address (char *name_, size_t length_);
    void sockaddr_to_msg (zmq::msg_t *msg_, sockaddr_in *addr_);

    int set_udp_reuse_address (fd_t s_, bool on_);
--- a/src/ws_connecter.cpp
+++ b/src/ws_connecter.cpp
@ -270,7 +270,7 @@ bool zmq::ws_connecter_t::tune_socket (const fd_t fd_)
    return rc == 0;
 }

-void zmq::ws_connecter_t::create_engine (fd_t fd,
+void zmq::ws_connecter_t::create_engine (fd_t fd_,
                                         const std::string &local_address_)
 {
    const endpoint_uri_pair_t endpoint_pair (local_address_, _endpoint,
@ -281,14 +281,14 @@ void zmq::ws_connecter_t::create_engine (fd_t fd,
    if (_wss)
 #ifdef ZMQ_HAVE_WSS
        engine = new (std::nothrow)
-          wss_engine_t (fd, options, endpoint_pair, *_addr->resolved.ws_addr,
+          wss_engine_t (fd_, options, endpoint_pair, *_addr->resolved.ws_addr,
                        true, NULL, _hostname);
 #else
        assert (false);
 #endif
    else
        engine = new (std::nothrow) ws_engine_t (
-          fd, options, endpoint_pair, *_addr->resolved.ws_addr, true);
+          fd_, options, endpoint_pair, *_addr->resolved.ws_addr, true);
    alloc_assert (engine);

    //  Attach the engine to the corresponding session object.
@ -297,5 +297,5 @@ void zmq::ws_connecter_t::create_engine (fd_t fd,
    //  Shut the connecter down.
    terminate ();

-    _socket->event_connected (endpoint_pair, fd);
+    _socket->event_connected (endpoint_pair, fd_);
 }
--- a/src/ws_decoder.cpp
+++ b/src/ws_decoder.cpp
@ -69,7 +69,7 @@ int zmq::ws_decoder_t::opcode_ready (unsigned char const *)
    if (!final)
        return -1; // non final messages are not supported

-    _opcode = (zmq::ws_protocol_t::opcode_t) (_tmpbuf[0] & 0xF);
+    _opcode = static_cast<zmq::ws_protocol_t::opcode_t> (_tmpbuf[0] & 0xF);

    _msg_flags = 0;

@ -101,7 +101,7 @@ int zmq::ws_decoder_t::size_first_byte_ready (unsigned char const *read_from_)
    if (is_masked != _must_mask) // wrong mask value
        return -1;

-    _size = (uint64_t) (_tmpbuf[0] & 0x7F);
+    _size = static_cast<uint64_t> (_tmpbuf[0] & 0x7F);

    if (_size < 126) {
        if (_must_mask)
@ -260,7 +260,8 @@ int zmq::ws_decoder_t::message_ready (unsigned char const *)
    if (_must_mask) {
        int mask_index = _opcode == ws_protocol_t::opcode_binary ? 1 : 0;

-        unsigned char *data = (unsigned char *) _in_progress.data ();
+        unsigned char *data =
+          static_cast<unsigned char *> (_in_progress.data ());
        for (size_t i = 0; i < _size; ++i, mask_index++)
            data[i] = data[i] ^ _mask[mask_index % 4];
    }
--- a/src/ws_encoder.cpp
+++ b/src/ws_encoder.cpp
@ -63,11 +63,11 @@ void zmq::ws_encoder_t::message_ready ()
    size++; // TODO: check if binary

    if (size <= 125)
-        _tmp_buf[offset++] |= (unsigned char) (size & 127);
+        _tmp_buf[offset++] |= static_cast<unsigned char> (size & 127);
    else if (size <= 0xFFFF) {
        _tmp_buf[offset++] |= 126;
-        _tmp_buf[offset++] = (unsigned char) ((size >> 8) & 0xFF);
-        _tmp_buf[offset++] = (unsigned char) (size & 0xFF);
+        _tmp_buf[offset++] = static_cast<unsigned char> ((size >> 8) & 0xFF);
+        _tmp_buf[offset++] = static_cast<unsigned char> (size & 0xFF);
    } else {
        _tmp_buf[offset++] |= 127;
        put_uint64 (_tmp_buf + offset, size);
@ -106,8 +106,10 @@ void zmq::ws_encoder_t::size_ready ()
        _masked_msg.init_size (size);

        int mask_index = 1; // TODO: check if binary message
-        unsigned char *dest = (unsigned char *) _masked_msg.data ();
-        unsigned char *src = (unsigned char *) in_progress ()->data ();
+        unsigned char *dest =
+          static_cast<unsigned char *> (_masked_msg.data ());
+        unsigned char *src =
+          static_cast<unsigned char *> (in_progress ()->data ());
        for (size_t i = 0; i < in_progress ()->size (); ++i, mask_index++)
            dest[i] = src[i] ^ _mask[mask_index % 4];

--- a/src/ws_engine.cpp
+++ b/src/ws_engine.cpp
@ -83,10 +83,10 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #endif

 static int
-encode_base64 (const unsigned char *in, int in_len, char *out, int out_len);
+encode_base64 (const unsigned char *in_, int in_len_, char *out_, int out_len_);

-static void compute_accept_key (char *key,
-                                unsigned char output[SHA_DIGEST_LENGTH]);
+static void compute_accept_key (char *key_,
+                                unsigned char hash_[SHA_DIGEST_LENGTH]);

 zmq::ws_engine_t::ws_engine_t (fd_t fd_,
                               const options_t &options_,
@ -131,7 +131,7 @@ void zmq::ws_engine_t::start_ws_handshake ()
            assert (false);

        unsigned char nonce[16];
-        int *p = (int *) nonce;
+        int *p = reinterpret_cast<int *> (nonce);

        // The nonce doesn't have to be secure one, it is just use to avoid proxy cache
        *p = zmq::generate_random ();
@ -143,16 +143,16 @@ void zmq::ws_engine_t::start_ws_handshake ()
          encode_base64 (nonce, 16, _websocket_key, MAX_HEADER_VALUE_LENGTH);
        assert (size > 0);

-        size = snprintf ((char *) _write_buffer, WS_BUFFER_SIZE,
-                         "GET %s HTTP/1.1\r\n"
-                         "Host: %s\r\n"
-                         "Upgrade: websocket\r\n"
-                         "Connection: Upgrade\r\n"
-                         "Sec-WebSocket-Key: %s\r\n"
-                         "Sec-WebSocket-Protocol: %s\r\n"
-                         "Sec-WebSocket-Version: 13\r\n\r\n",
-                         _address.path (), _address.host (), _websocket_key,
-                         protocol);
+        size = snprintf (
+          reinterpret_cast<char *> (_write_buffer), WS_BUFFER_SIZE,
+          "GET %s HTTP/1.1\r\n"
+          "Host: %s\r\n"
+          "Upgrade: websocket\r\n"
+          "Connection: Upgrade\r\n"
+          "Sec-WebSocket-Key: %s\r\n"
+          "Sec-WebSocket-Protocol: %s\r\n"
+          "Sec-WebSocket-Version: 13\r\n\r\n",
+          _address.path (), _address.host (), _websocket_key, protocol);
        assert (size > 0 && size < WS_BUFFER_SIZE);
        _outpos = _write_buffer;
        _outsize = size;
@ -196,22 +196,23 @@ int zmq::ws_engine_t::process_routing_id_msg (msg_t *msg_)
    return 0;
 }

-bool zmq::ws_engine_t::select_protocol (char *protocol)
+bool zmq::ws_engine_t::select_protocol (char *protocol_)
 {
-    if (_options.mechanism == ZMQ_NULL && (strcmp ("ZWS2.0", protocol) == 0)) {
+    if (_options.mechanism == ZMQ_NULL && (strcmp ("ZWS2.0", protocol_) == 0)) {
        _next_msg = static_cast<int (stream_engine_base_t::*) (msg_t *)> (
          &ws_engine_t::routing_id_msg);
        _process_msg = static_cast<int (stream_engine_base_t::*) (msg_t *)> (
          &ws_engine_t::process_routing_id_msg);
        return true;
-    } else if (_options.mechanism == ZMQ_NULL
-               && strcmp ("ZWS2.0/NULL", protocol) == 0) {
+    }
+    if (_options.mechanism == ZMQ_NULL
+        && strcmp ("ZWS2.0/NULL", protocol_) == 0) {
        _mechanism = new (std::nothrow)
          null_mechanism_t (session (), _peer_address, _options);
        alloc_assert (_mechanism);
        return true;
    } else if (_options.mechanism == ZMQ_PLAIN
-               && strcmp ("ZWS2.0/PLAIN", protocol) == 0) {
+               && strcmp ("ZWS2.0/PLAIN", protocol_) == 0) {
        if (_options.as_server)
            _mechanism = new (std::nothrow)
              plain_server_t (session (), _peer_address, _options);
@ -223,7 +224,7 @@ bool zmq::ws_engine_t::select_protocol (char *protocol)
    }
 #ifdef ZMQ_HAVE_CURVE
    else if (_options.mechanism == ZMQ_CURVE
-             && strcmp ("ZWS2.0/CURVE", protocol) == 0) {
+             && strcmp ("ZWS2.0/CURVE", protocol_) == 0) {
        if (_options.as_server)
            _mechanism = new (std::nothrow)
              curve_server_t (session (), _peer_address, _options);
@ -278,7 +279,7 @@ bool zmq::ws_engine_t::server_handshake ()
    _insize = nbytes;

    while (_insize > 0) {
-        char c = (char) *_inpos;
+        char c = static_cast<char> (*_inpos);

        switch (_server_handshake_state) {
            case handshake_initial:
@ -391,7 +392,7 @@ bool zmq::ws_engine_t::server_handshake ()
                        _server_handshake_state = handshake_error;
                        break;
                    default:
-                        _header_name[0] = (char) c;
+                        _header_name[0] = c;
                        _header_name_position = 1;
                        _server_handshake_state = header_field_name;
                        break;
@ -493,7 +494,8 @@ bool zmq::ws_engine_t::server_handshake ()
                        _websocket_accept[accept_key_len] = '\0';

                        int written =
-                          snprintf ((char *) _write_buffer, WS_BUFFER_SIZE,
+                          snprintf (reinterpret_cast<char *> (_write_buffer),
+                                    WS_BUFFER_SIZE,
                                    "HTTP/1.1 101 Switching Protocols\r\n"
                                    "Upgrade: websocket\r\n"
                                    "Connection: Upgrade\r\n"
@ -509,8 +511,8 @@ bool zmq::ws_engine_t::server_handshake ()
                        _insize--;

                        return true;
-                    } else
-                        _server_handshake_state = handshake_error;
+                    }
+                    _server_handshake_state = handshake_error;
                } else
                    _server_handshake_state = handshake_error;
                break;
@ -547,7 +549,7 @@ bool zmq::ws_engine_t::client_handshake ()
    _insize = nbytes;

    while (_insize > 0) {
-        char c = (char) *_inpos;
+        char c = static_cast<char> (*_inpos);

        switch (_client_handshake_state) {
            case client_handshake_initial:
@ -769,7 +771,7 @@ bool zmq::ws_engine_t::client_handshake ()
                        _client_handshake_state = client_handshake_error;
                        break;
                    default:
-                        _header_name[0] = (char) c;
+                        _header_name[0] = c;
                        _header_name_position = 1;
                        _client_handshake_state = client_header_field_name;
                        break;
@ -852,8 +854,8 @@ bool zmq::ws_engine_t::client_handshake ()
                        _insize--;

                        return true;
-                    } else
-                        _client_handshake_state = client_handshake_error;
+                    }
+                    _client_handshake_state = client_handshake_error;
                } else
                    _client_handshake_state = client_handshake_error;
                break;
@ -877,7 +879,7 @@ bool zmq::ws_engine_t::client_handshake ()
 }

 static int
-encode_base64 (const unsigned char *in, int in_len, char *out, int out_len)
+encode_base64 (const unsigned char *in_, int in_len_, char *out_, int out_len_)
 {
    static const unsigned char base64enc_tab[65] =
      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@ -886,36 +888,36 @@ encode_base64 (const unsigned char *in, int in_len, char *out, int out_len)
    uint32_t v;
    int rem;

-    for (io = 0, ii = 0, v = 0, rem = 0; ii < in_len; ii++) {
+    for (io = 0, ii = 0, v = 0, rem = 0; ii < in_len_; ii++) {
        unsigned char ch;
-        ch = in[ii];
+        ch = in_[ii];
        v = (v << 8) | ch;
        rem += 8;
        while (rem >= 6) {
            rem -= 6;
-            if (io >= out_len)
+            if (io >= out_len_)
                return -1; /* truncation is failure */
-            out[io++] = base64enc_tab[(v >> rem) & 63];
+            out_[io++] = base64enc_tab[(v >> rem) & 63];
        }
    }
    if (rem) {
        v <<= (6 - rem);
-        if (io >= out_len)
+        if (io >= out_len_)
            return -1; /* truncation is failure */
-        out[io++] = base64enc_tab[v & 63];
+        out_[io++] = base64enc_tab[v & 63];
    }
    while (io & 3) {
-        if (io >= out_len)
+        if (io >= out_len_)
            return -1; /* truncation is failure */
-        out[io++] = '=';
+        out_[io++] = '=';
    }
-    if (io >= out_len)
+    if (io >= out_len_)
        return -1; /* no room for null terminator */
-    out[io] = 0;
+    out_[io] = 0;
    return io;
 }

-static void compute_accept_key (char *key, unsigned char *hash)
+static void compute_accept_key (char *key_, unsigned char *hash_)
 {
    const char *magic_string = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 #ifdef ZMQ_USE_NSS
@ -925,24 +927,24 @@ static void compute_accept_key (char *key, unsigned char *hash)
    assert (ctx);

    HASH_Begin (ctx);
-    HASH_Update (ctx, (unsigned char *) key, (unsigned int) strlen (key));
+    HASH_Update (ctx, (unsigned char *) key_, (unsigned int) strlen (key_));
    HASH_Update (ctx, (unsigned char *) magic_string,
                 (unsigned int) strlen (magic_string));
-    HASH_End (ctx, hash, &len, SHA_DIGEST_LENGTH);
+    HASH_End (ctx, hash_, &len, SHA_DIGEST_LENGTH);
    HASH_Destroy (ctx);
 #elif defined ZMQ_USE_BUILTIN_SHA1
    sha1_ctxt ctx;
    SHA1_Init (&ctx);
-    SHA1_Update (&ctx, (unsigned char *) key, strlen (key));
+    SHA1_Update (&ctx, (unsigned char *) key_, strlen (key_));
    SHA1_Update (&ctx, (unsigned char *) magic_string, strlen (magic_string));

-    SHA1_Final (hash, &ctx);
+    SHA1_Final (hash_, &ctx);
 #elif defined ZMQ_USE_GNUTLS
    gnutls_hash_hd_t hd;
    gnutls_hash_init (&hd, GNUTLS_DIG_SHA1);
-    gnutls_hash (hd, key, strlen (key));
+    gnutls_hash (hd, key_, strlen (key_));
    gnutls_hash (hd, magic_string, strlen (magic_string));
-    gnutls_hash_deinit (hd, hash);
+    gnutls_hash_deinit (hd, hash_);
 #else
 #error "No sha1 implementation set"
 #endif
--- a/src/ws_listener.cpp
+++ b/src/ws_listener.cpp
@ -126,8 +126,8 @@ std::string zmq::ws_listener_t::get_socket_name (zmq::fd_t fd_,
 {
    if (_wss)
        return zmq::get_socket_name<wss_address_t> (fd_, socket_end_);
-    else
-        return zmq::get_socket_name<ws_address_t> (fd_, socket_end_);
+
+    return zmq::get_socket_name<ws_address_t> (fd_, socket_end_);
 }

 int zmq::ws_listener_t::create_socket (const char *addr_)
@ -285,23 +285,23 @@ zmq::fd_t zmq::ws_listener_t::accept ()
    return sock;
 }

-void zmq::ws_listener_t::create_engine (fd_t fd)
+void zmq::ws_listener_t::create_engine (fd_t fd_)
 {
    const endpoint_uri_pair_t endpoint_pair (
-      get_socket_name (fd, socket_end_local),
-      get_socket_name (fd, socket_end_remote), endpoint_type_bind);
+      get_socket_name (fd_, socket_end_local),
+      get_socket_name (fd_, socket_end_remote), endpoint_type_bind);

    i_engine *engine = NULL;
    if (_wss)
 #ifdef ZMQ_HAVE_WSS
        engine = new (std::nothrow) wss_engine_t (
-          fd, options, endpoint_pair, _address, false, _tls_cred, NULL);
+          fd_, options, endpoint_pair, _address, false, _tls_cred, NULL);
 #else
        assert (false);
 #endif
    else
        engine = new (std::nothrow)
-          ws_engine_t (fd, options, endpoint_pair, _address, false);
+          ws_engine_t (fd_, options, endpoint_pair, _address, false);
    alloc_assert (engine);

    //  Choose I/O thread to run connecter in. Given that we are already
@ -317,5 +317,5 @@ void zmq::ws_listener_t::create_engine (fd_t fd)
    launch_child (session);
    send_attach (session, engine, false);

-    _socket->event_accepted (endpoint_pair, fd);
+    _socket->event_accepted (endpoint_pair, fd_);
 }
--- a/src/xpub.hpp
+++ b/src/xpub.hpp
@ -71,7 +71,7 @@ class xpub_t : public socket_base_t
                                     xpub_t *self_);

    //  Function to be applied to each matching pipes.
-    static void mark_as_matching (zmq::pipe_t *pipe_, xpub_t *arg_);
+    static void mark_as_matching (zmq::pipe_t *pipe_, xpub_t *self_);

    //  List of all subscriptions mapped to corresponding pipes.
    mtrie_t _subscriptions;
@ -115,7 +115,7 @@ class xpub_t : public socket_base_t
    bool _send_last_pipe;

    //  Function to be applied to match the last pipe.
-    static void mark_last_pipe_as_matching (zmq::pipe_t *pipe_, xpub_t *arg_);
+    static void mark_last_pipe_as_matching (zmq::pipe_t *pipe_, xpub_t *self_);

    //  Last pipe that sent subscription message, only used if xpub is on manual
    pipe_t *_last_pipe;
--- a/src/xsub.cpp
+++ b/src/xsub.cpp
@ -109,10 +109,9 @@ int zmq::xsub_t::xsetsockopt (int option_,
        }
        _only_first_subscribe = (*static_cast<const int *> (optval_) != 0);
        return 0;
-    } else {
-        errno = EINVAL;
-        return -1;
    }
+    errno = EINVAL;
+    return -1;
 }

 int zmq::xsub_t::xsend (msg_t *msg_)
--- a/src/zap_client.cpp
+++ b/src/zap_client.cpp
@ -274,8 +274,8 @@ zmq::mechanism_t::status_t zap_client_common_handshake_t::status () const
        return mechanism_t::ready;
    if (state == error_sent)
        return mechanism_t::error;
-    else
-        return mechanism_t::handshaking;
+
+    return mechanism_t::handshaking;
 }

 int zap_client_common_handshake_t::zap_msg_available ()
--- a/src/zmq.cpp
+++ b/src/zmq.cpp
@ -194,10 +194,10 @@ int zmq_ctx_set_ext (void *ctx_,

 int zmq_ctx_get (void *ctx_, int option_)
 {
-    int optval_ = 0;
-    size_t optvallen_ = sizeof (int);
-    if (zmq_ctx_get_ext (ctx_, option_, &optval_, &optvallen_) == 0) {
-        return optval_;
+    int optval = 0;
+    size_t optvallen = sizeof (int);
+    if (zmq_ctx_get_ext (ctx_, option_, &optval, &optvallen) == 0) {
+        return optval;
    }

    errno = EFAULT;
@ -1305,9 +1305,8 @@ int zmq_poller_fd (void *poller_, zmq_fd_t *fd_)
        || !(static_cast<zmq::socket_poller_t *> (poller_)->check_tag ())) {
        errno = EFAULT;
        return -1;
-    } else {
-        return static_cast<zmq::socket_poller_t *> (poller_)->signaler_fd (fd_);
    }
+    return static_cast<zmq::socket_poller_t *> (poller_)->signaler_fd (fd_);
 }

 //  Peer-specific state
--- a/src/zmtp_engine.cpp
+++ b/src/zmtp_engine.cpp
@ -229,14 +229,14 @@ void zmq::zmtp_engine_t::receive_greeting_versioned ()
 }

 zmq::zmtp_engine_t::handshake_fun_t
-zmq::zmtp_engine_t::select_handshake_fun (bool unversioned,
-                                          unsigned char revision)
+zmq::zmtp_engine_t::select_handshake_fun (bool unversioned_,
+                                          unsigned char revision_)
 {
    //  Is the peer using ZMTP/1.0 with no revision number?
-    if (unversioned) {
+    if (unversioned_) {
        return &zmtp_engine_t::handshake_v1_0_unversioned;
    }
-    switch (revision) {
+    switch (revision_) {
        case ZMTP_1_0:
            return &zmtp_engine_t::handshake_v1_0;
        case ZMTP_2_0:
--- a/tests/test_app_meta.cpp
+++ b/tests/test_app_meta.cpp
@ -109,7 +109,7 @@ void test_app_meta_reqrep ()
    rc = zmq_msg_init_size (&msg, 1);
    TEST_ASSERT_EQUAL_INT (0, rc);

-    char *data = (char *) zmq_msg_data (&msg);
+    char *data = static_cast<char *> (zmq_msg_data (&msg));
    data[0] = 1;

    rc = zmq_msg_send (&msg, req_sock, 0);
@ -123,7 +123,7 @@ void test_app_meta_reqrep ()

    TEST_ASSERT_EQUAL_STRING ("hello", zmq_msg_gets (&msg, "X-hello"));
    TEST_ASSERT_EQUAL_STRING ("primary", zmq_msg_gets (&msg, "X-connection"));
-    char *bindata = (char *) zmq_msg_gets (&msg, "X-bin");
+    char *bindata = const_cast<char *> (zmq_msg_gets (&msg, "X-bin"));
    TEST_ASSERT_NOT_NULL (bindata);
    uint8_t rawdata[4];
    void *ret = zmq_z85_decode (rawdata, bindata);
--- a/tests/test_client_server.cpp
+++ b/tests/test_client_server.cpp
@ -97,7 +97,7 @@ void test_routing_id ()
        zmq_msg_t msg;
        TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init_size (&msg, 1));

-        char *data = (char *) zmq_msg_data (&msg);
+        char *data = static_cast<char *> (zmq_msg_data (&msg));
        data[0] = 2;

        TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_set_routing_id (&msg, routing_id));
--- a/tests/test_ctx_destroy.cpp
+++ b/tests/test_ctx_destroy.cpp
@ -124,7 +124,7 @@ struct poller_test_data_t
 void run_poller (void *data_)
 {
    struct poller_test_data_t *poller_test_data =
-      (struct poller_test_data_t *) data_;
+      static_cast<struct poller_test_data_t *> (data_);

    void *socket =
      zmq_socket (poller_test_data->ctx, poller_test_data->socket_type);
--- a/tests/test_disconnect_inproc.cpp
+++ b/tests/test_disconnect_inproc.cpp
@ -68,7 +68,7 @@ void test_disconnect_inproc ()
                zmq_msg_t msg;
                zmq_msg_init (&msg);
                TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&msg, pub_socket, 0));
-                char *buffer = (char *) zmq_msg_data (&msg);
+                char *buffer = static_cast<char *> (zmq_msg_data (&msg));

                if (buffer[0] == 0) {
                    TEST_ASSERT_TRUE (isSubscribed);
--- a/tests/test_heartbeats.cpp
+++ b/tests/test_heartbeats.cpp
@ -60,8 +60,8 @@ static int get_monitor_event (void *monitor_)
        }
        TEST_ASSERT_TRUE (zmq_msg_more (&msg));

-        uint8_t *data = (uint8_t *) zmq_msg_data (&msg);
-        uint16_t event = *(uint16_t *) (data);
+        uint8_t *data = static_cast<uint8_t *> (zmq_msg_data (&msg));
+        uint16_t event = *reinterpret_cast<uint16_t *> (data);

        //  Second frame in message contains event address
        TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&msg));
--- a/tests/test_hwm_pubsub.cpp
+++ b/tests/test_hwm_pubsub.cpp
@ -38,13 +38,13 @@

 SETUP_TEARDOWN_TESTCONTEXT

-int test_defaults (int send_hwm_, int msg_cnt_, const char *endpoint)
+int test_defaults (int send_hwm_, int msg_cnt_, const char *endpoint_)
 {
    char pub_endpoint[SOCKET_STRING_LEN];

    // Set up and bind XPUB socket
    void *pub_socket = test_context_socket (ZMQ_XPUB);
-    test_bind (pub_socket, endpoint, pub_endpoint, sizeof pub_endpoint);
+    test_bind (pub_socket, endpoint_, pub_endpoint, sizeof pub_endpoint);

    // Set up and connect SUB socket
    void *sub_socket = test_context_socket (ZMQ_SUB);
@ -86,10 +86,10 @@ int test_defaults (int send_hwm_, int msg_cnt_, const char *endpoint)
    return recv_count;
 }

-int receive (void *socket_, int *is_termination)
+int receive (void *socket_, int *is_termination_)
 {
    int recv_count = 0;
-    *is_termination = 0;
+    *is_termination_ = 0;

    // Now receive all sent messages
    char buffer[255];
@ -98,7 +98,7 @@ int receive (void *socket_, int *is_termination)
        ++recv_count;

        if (len == 3 && strncmp (buffer, "end", len) == 0) {
-            *is_termination = 1;
+            *is_termination_ = 1;
            return recv_count;
        }
    }
@ -106,13 +106,13 @@ int receive (void *socket_, int *is_termination)
    return recv_count;
 }

-int test_blocking (int send_hwm_, int msg_cnt_, const char *endpoint)
+int test_blocking (int send_hwm_, int msg_cnt_, const char *endpoint_)
 {
    char pub_endpoint[SOCKET_STRING_LEN];

    // Set up bind socket
    void *pub_socket = test_context_socket (ZMQ_XPUB);
-    test_bind (pub_socket, endpoint, pub_endpoint, sizeof pub_endpoint);
+    test_bind (pub_socket, endpoint_, pub_endpoint, sizeof pub_endpoint);

    // Set up connect socket
    void *sub_socket = test_context_socket (ZMQ_SUB);
--- a/tests/test_inproc_connect.cpp
+++ b/tests/test_inproc_connect.cpp
@ -236,10 +236,8 @@ void test_simultaneous_connect_bind_threads ()

    // Spawn all threads as simultaneously as possible
    for (unsigned int i = 0; i < no_of_times; ++i) {
-        threads[i * 2 + 0] =
-          zmq_threadstart (&simult_conn, (void *) thr_args[i]);
-        threads[i * 2 + 1] =
-          zmq_threadstart (&simult_bind, (void *) thr_args[i]);
+        threads[i * 2 + 0] = zmq_threadstart (&simult_conn, thr_args[i]);
+        threads[i * 2 + 1] = zmq_threadstart (&simult_bind, thr_args[i]);
    }

    // Close all threads
--- a/tests/test_mock_pub_sub.cpp
+++ b/tests/test_mock_pub_sub.cpp
@ -52,8 +52,8 @@ static int get_monitor_event (void *monitor_)
        }
        TEST_ASSERT_TRUE (zmq_msg_more (&msg));

-        uint8_t *data = (uint8_t *) zmq_msg_data (&msg);
-        uint16_t event = *(uint16_t *) (data);
+        uint8_t *data = static_cast<uint8_t *> (zmq_msg_data (&msg));
+        uint16_t event = *reinterpret_cast<uint16_t *> (data);

        //  Second frame in message contains event address
        TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&msg));
@ -136,7 +136,7 @@ static void prep_server_socket (void **server_out_,
    *mon_out_ = server_mon;
 }

-static void test_mock_sub (bool sub_command)
+static void test_mock_sub (bool sub_command_)
 {
    int rc;
    char my_endpoint[MAX_SOCKET_STRING];
@ -167,7 +167,7 @@ static void test_mock_sub (bool sub_command)
    rc = get_monitor_event (server_mon);
    TEST_ASSERT_EQUAL_INT (ZMQ_EVENT_ACCEPTED, rc);

-    if (sub_command) {
+    if (sub_command_) {
        const uint8_t sub[13] = {4,   11,  9,   'S', 'U', 'B', 'S',
                                 'C', 'R', 'I', 'B', 'E', 'A'};
        rc =
--- a/tests/test_monitor.cpp
+++ b/tests/test_monitor.cpp
@ -196,12 +196,12 @@ void test_monitor_versioned_basic (bind_function_t bind_function_,
    //  Now do a basic ping test
    bind_function_ (server, server_endpoint, sizeof server_endpoint);

-    int ipv6_;
-    size_t ipv6_size_ = sizeof (ipv6_);
+    int ipv6;
+    size_t ipv6_size = sizeof (ipv6);
    TEST_ASSERT_SUCCESS_ERRNO (
-      zmq_getsockopt (server, ZMQ_IPV6, &ipv6_, &ipv6_size_));
+      zmq_getsockopt (server, ZMQ_IPV6, &ipv6, &ipv6_size));
    TEST_ASSERT_SUCCESS_ERRNO (
-      zmq_setsockopt (client, ZMQ_IPV6, &ipv6_, sizeof (int)));
+      zmq_setsockopt (client, ZMQ_IPV6, &ipv6, sizeof (int)));
    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (client, server_endpoint));
    bounce (server, client);

@ -327,14 +327,14 @@ void test_monitor_versioned_stats (bind_function_t bind_function_,
      push, ZMQ_SNDBUF, &tcp_buffer_size, sizeof (tcp_buffer_size)));
    bind_function_ (push, server_endpoint, sizeof (server_endpoint));

-    int ipv6_;
-    size_t ipv6_size_ = sizeof (ipv6_);
+    int ipv6;
+    size_t ipv6_size = sizeof (ipv6);
    TEST_ASSERT_SUCCESS_ERRNO (
-      zmq_getsockopt (push, ZMQ_IPV6, &ipv6_, &ipv6_size_));
+      zmq_getsockopt (push, ZMQ_IPV6, &ipv6, &ipv6_size));
    for (int i = 0; i < pulls_count; ++i) {
        pulls[i] = test_context_socket (ZMQ_PULL);
        TEST_ASSERT_SUCCESS_ERRNO (
-          zmq_setsockopt (pulls[i], ZMQ_IPV6, &ipv6_, sizeof (int)));
+          zmq_setsockopt (pulls[i], ZMQ_IPV6, &ipv6, sizeof (int)));
        int timeout_ms = 10;
        TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (
          pulls[i], ZMQ_RCVTIMEO, &timeout_ms, sizeof (timeout_ms)));
--- a/tests/test_proxy.cpp
+++ b/tests/test_proxy.cpp
@ -80,7 +80,7 @@ void *g_workers_pkts_out = NULL;

 static void client_task (void *db_)
 {
-    struct thread_data *databag = (struct thread_data *) db_;
+    struct thread_data *databag = static_cast<struct thread_data *> (db_);
    // Endpoint socket gets random port to avoid test failing when port in use
    void *endpoint = zmq_socket (get_test_context (), ZMQ_PAIR);
    TEST_ASSERT_NOT_NULL (endpoint);
@ -373,16 +373,16 @@ void check_proxy_stats (void *control_proxy_)
    if (is_verbose) {
        printf (
          "frontend: pkts_in=%lu bytes_in=%lu  pkts_out=%lu bytes_out=%lu\n",
-          (unsigned long int) total_stats.frontend.msg_in,
-          (unsigned long int) total_stats.frontend.bytes_in,
-          (unsigned long int) total_stats.frontend.msg_out,
-          (unsigned long int) total_stats.frontend.bytes_out);
+          static_cast<unsigned long int> (total_stats.frontend.msg_in),
+          static_cast<unsigned long int> (total_stats.frontend.bytes_in),
+          static_cast<unsigned long int> (total_stats.frontend.msg_out),
+          static_cast<unsigned long int> (total_stats.frontend.bytes_out));
        printf (
          "backend: pkts_in=%lu bytes_in=%lu  pkts_out=%lu bytes_out=%lu\n",
-          (unsigned long int) total_stats.backend.msg_in,
-          (unsigned long int) total_stats.backend.bytes_in,
-          (unsigned long int) total_stats.backend.msg_out,
-          (unsigned long int) total_stats.backend.bytes_out);
+          static_cast<unsigned long int> (total_stats.backend.msg_in),
+          static_cast<unsigned long int> (total_stats.backend.bytes_in),
+          static_cast<unsigned long int> (total_stats.backend.msg_out),
+          static_cast<unsigned long int> (total_stats.backend.bytes_out));

        printf ("clients sent out %d requests\n",
                zmq_atomic_counter_value (g_clients_pkts_out));
--- a/tests/test_proxy_hwm.cpp
+++ b/tests/test_proxy_hwm.cpp
@ -71,19 +71,19 @@ typedef struct
    void *subscriber_received_all;
 } proxy_hwm_cfg_t;

-static void lower_hwm (void *skt)
+static void lower_hwm (void *skt_)
 {
-    int send_hwm_ = HWM;
+    int send_hwm = HWM;
    TEST_ASSERT_SUCCESS_ERRNO (
-      zmq_setsockopt (skt, ZMQ_SNDHWM, &send_hwm_, sizeof (send_hwm_)));
+      zmq_setsockopt (skt_, ZMQ_SNDHWM, &send_hwm, sizeof (send_hwm)));

    TEST_ASSERT_SUCCESS_ERRNO (
-      zmq_setsockopt (skt, ZMQ_RCVHWM, &send_hwm_, sizeof (send_hwm_)));
+      zmq_setsockopt (skt_, ZMQ_RCVHWM, &send_hwm, sizeof (send_hwm)));
 }

-static void publisher_thread_main (void *pvoid)
+static void publisher_thread_main (void *pvoid_)
 {
-    proxy_hwm_cfg_t *cfg = (proxy_hwm_cfg_t *) pvoid;
+    proxy_hwm_cfg_t *cfg = static_cast<proxy_hwm_cfg_t *> (pvoid_);

    void *pubsocket = zmq_socket (cfg->context, ZMQ_XPUB);
    assert (pubsocket);
@ -136,9 +136,9 @@ static void publisher_thread_main (void *pvoid)
    zmq_close (pubsocket);
 }

-static void subscriber_thread_main (void *pvoid)
+static void subscriber_thread_main (void *pvoid_)
 {
-    proxy_hwm_cfg_t *cfg = (proxy_hwm_cfg_t *) pvoid;
+    proxy_hwm_cfg_t *cfg = static_cast<proxy_hwm_cfg_t *> (pvoid_);

    void *subsocket = zmq_socket (cfg->context, ZMQ_SUB);
    assert (subsocket);
@ -190,7 +190,7 @@ static void subscriber_thread_main (void *pvoid)
    zmq_close (subsocket);
 }

-bool recv_stat (void *sock_, bool last_, uint64_t *res)
+bool recv_stat (void *sock_, bool last_, uint64_t *res_)
 {
    zmq_msg_t stats_msg;

@ -205,7 +205,7 @@ bool recv_stat (void *sock_, bool last_, uint64_t *res)
    }

    assert (rc == sizeof (uint64_t));
-    memcpy (res, zmq_msg_data (&stats_msg), zmq_msg_size (&stats_msg));
+    memcpy (res_, zmq_msg_data (&stats_msg), zmq_msg_size (&stats_msg));

    rc = zmq_msg_close (&stats_msg);
    assert (rc == 0);
@ -264,9 +264,9 @@ bool check_proxy_stats (void *control_proxy_)
    return true;
 }

-static void proxy_stats_asker_thread_main (void *pvoid)
+static void proxy_stats_asker_thread_main (void *pvoid_)
 {
-    proxy_hwm_cfg_t *cfg = (proxy_hwm_cfg_t *) pvoid;
+    proxy_hwm_cfg_t *cfg = static_cast<proxy_hwm_cfg_t *> (pvoid_);


    // CONTROL REQ
@ -316,9 +316,9 @@ static void proxy_stats_asker_thread_main (void *pvoid)
    zmq_close (control_req);
 }

-static void proxy_thread_main (void *pvoid)
+static void proxy_thread_main (void *pvoid_)
 {
-    proxy_hwm_cfg_t *cfg = (proxy_hwm_cfg_t *) pvoid;
+    proxy_hwm_cfg_t *cfg = static_cast<proxy_hwm_cfg_t *> (pvoid_);
    int rc;


--- a/tests/test_radio_dish.cpp
+++ b/tests/test_radio_dish.cpp
@ -257,9 +257,8 @@ static const char *mcast_url (int ipv6_)
 {
    if (ipv6_) {
        return "udp://[" MCAST_IPV6 "]:5555";
-    } else {
-        return "udp://" MCAST_IPV4 ":5555";
    }
+    return "udp://" MCAST_IPV4 ":5555";
 }

 //  OSX uses a different name for this socket option
--- a/tests/test_router_notify.cpp
+++ b/tests/test_router_notify.cpp
@ -136,7 +136,7 @@ void test_sockopt_router_notify ()
 }


-void test_router_notify_helper (int opt_notify)
+void test_router_notify_helper (int opt_notify_)
 {
    void *router = test_context_socket (ZMQ_ROUTER);
    int opt_more;
@ -148,7 +148,7 @@ void test_router_notify_helper (int opt_notify)

    // valid values
    TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (
-      router, ZMQ_ROUTER_NOTIFY, &opt_notify, sizeof (opt_notify)));
+      router, ZMQ_ROUTER_NOTIFY, &opt_notify_, sizeof (opt_notify_)));

    bind_loopback_ipv4 (router, connect_address, sizeof connect_address);

@ -162,7 +162,7 @@ void test_router_notify_helper (int opt_notify)
    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (dealer, connect_address));

    // connection notification msg
-    if (opt_notify & ZMQ_NOTIFY_CONNECT) {
+    if (opt_notify_ & ZMQ_NOTIFY_CONNECT) {
        // routing-id only message of the connect
        recv_string_expect_success (router, dealer_routing_id,
                                    0);             // 1st part: routing-id
@ -188,7 +188,7 @@ void test_router_notify_helper (int opt_notify)
    zmq_getsockopt (dealer, ZMQ_EVENTS, &opt_events, &opt_events_length);

    // connection notification msg
-    if (opt_notify & ZMQ_NOTIFY_DISCONNECT) {
+    if (opt_notify_ & ZMQ_NOTIFY_DISCONNECT) {
        // routing-id only message of the connect
        recv_string_expect_success (router, dealer_routing_id,
                                    0);             // 1st part: routing-id
--- a/tests/test_security_curve.cpp
+++ b/tests/test_security_curve.cpp
@ -100,9 +100,9 @@ static void zap_handler_large_routing_id (void * /*unused_*/)
    zap_handler_generic (zap_ok, large_routing_id);
 }

-void expect_new_client_curve_bounce_fail (char *server_public_,
-                                          char *client_public_,
-                                          char *client_secret_,
+void expect_new_client_curve_bounce_fail (const char *server_public_,
+                                          const char *client_public_,
+                                          const char *client_secret_,
                                          char *my_endpoint_,
                                          void *server_,
                                          void **client_mon_ = NULL,
@ -241,7 +241,8 @@ fd_t connect_vanilla_socket (char *my_endpoint_)
 #endif

    s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    rc = connect (s, (struct sockaddr *) &ip4addr, sizeof (ip4addr));
+    rc = connect (s, reinterpret_cast<struct sockaddr *> (&ip4addr),
+                  sizeof (ip4addr));
    TEST_ASSERT_GREATER_THAN_INT (-1, rc);
    return s;
 }
@ -334,9 +335,8 @@ static uint64_t host_to_network (uint64_t value_)
          htonl (static_cast<uint32_t> (value_ & 0xFFFFFFFFLL));

        return (static_cast<uint64_t> (low_part) << 32) | high_part;
-    } else {
-        return value_;
    }
+    return value_;
 }

 template <size_t N> void send_command (fd_t s_, char (&command_)[N])
@ -348,7 +348,7 @@ template <size_t N> void send_command (fd_t s_, char (&command_)[N])
    } else {
        send (s_, "\x06");
        uint64_t len = host_to_network (N);
-        send_all (s_, (char *) &len, 8);
+        send_all (s_, reinterpret_cast<char *> (&len), 8);
    }
    send_all (s_, command_, N);
 }
@ -411,7 +411,7 @@ void recv_all (fd_t fd_, uint8_t *data_, socket_size_t len_)
 {
    socket_size_t received = 0;
    while (received < len_) {
-        int res = recv (fd_, (char *) data_, len_, 0);
+        int res = recv (fd_, reinterpret_cast<char *> (data_), len_, 0);
        TEST_ASSERT_GREATER_THAN_INT (0, res);

        data_ += res;
--- a/tests/test_security_gssapi.cpp
+++ b/tests/test_security_gssapi.cpp
@ -190,10 +190,10 @@ static int get_monitor_event (void *monitor_, int *value_, char **address_)
        return -1; //  Interruped, presumably
    TEST_ASSERT_TRUE (zmq_msg_more (&msg));

-    uint8_t *data = (uint8_t *) zmq_msg_data (&msg);
-    uint16_t event = *(uint16_t *) (data);
+    uint8_t *data = static_cast<uint8_t *> (zmq_msg_data (&msg));
+    uint16_t event = *reinterpret_cast<uint16_t *> (data);
    if (value_)
-        *value_ = *(uint32_t *) (data + 2);
+        *value_ = *reinterpret_cast<uint32_t *> (data + 2);
    zmq_msg_close (&msg);

    //  Second frame in message contains event address
@ -203,9 +203,9 @@ static int get_monitor_event (void *monitor_, int *value_, char **address_)
    TEST_ASSERT_FALSE (zmq_msg_more (&msg));

    if (address_) {
-        uint8_t *data = (uint8_t *) zmq_msg_data (&msg);
+        uint8_t *data = static_cast<uint8_t *> (zmq_msg_data (&msg));
        size_t size = zmq_msg_size (&msg);
-        *address_ = (char *) malloc (size + 1);
+        *address_ = static_cast<char *> (malloc (size + 1));
        memcpy (*address_, data, size);
        *address_[size] = 0;
    }
@ -302,7 +302,8 @@ void test_vanilla_socket ()
 #endif

    s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    rc = connect (s, (struct sockaddr *) &ip4addr, sizeof (ip4addr));
+    rc = connect (s, reinterpret_cast<struct sockaddr *> (&ip4addr),
+                  sizeof (ip4addr));
    TEST_ASSERT_GREATER_THAN (-1, rc);
    // send anonymous ZMTP/1.0 greeting
    send (s, "\x01\x00", 2, 0);
--- a/tests/test_security_null.cpp
+++ b/tests/test_security_null.cpp
@ -185,7 +185,8 @@ void test_vanilla_socket ()
 #endif

    s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    rc = connect (s, (struct sockaddr *) &ip4addr, sizeof ip4addr);
+    rc = connect (s, reinterpret_cast<struct sockaddr *> (&ip4addr),
+                  sizeof ip4addr);
    TEST_ASSERT_GREATER_THAN_INT (-1, rc);
    // send anonymous ZMTP/1.0 greeting
    send (s, "\x01\x00", 2, 0);
--- a/tests/test_security_plain.cpp
+++ b/tests/test_security_plain.cpp
@ -211,7 +211,8 @@ void test_plain_vanilla_socket ()
 #endif

    s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    rc = connect (s, (struct sockaddr *) &ip4addr, sizeof (ip4addr));
+    rc = connect (s, reinterpret_cast<struct sockaddr *> (&ip4addr),
+                  sizeof (ip4addr));
    TEST_ASSERT_GREATER_THAN_INT (-1, rc);
    // send anonymous ZMTP/1.0 greeting
    send (s, "\x01\x00", 2, 0);
--- a/tests/test_spec_pushpull.cpp
+++ b/tests/test_spec_pushpull.cpp
@ -130,7 +130,7 @@ void test_pull_fair_queue_in (const char *bind_address_)
    for (size_t peer = 0; peer < services; ++peer) {
        TEST_ASSERT_EQUAL_INT (
          2, TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&msg, pull, 0)));
-        const char *str = (const char *) zmq_msg_data (&msg);
+        const char *str = static_cast<const char *> (zmq_msg_data (&msg));
        first_half -= str[0];
    }
    TEST_ASSERT_EQUAL_INT (0, first_half);
@ -139,7 +139,7 @@ void test_pull_fair_queue_in (const char *bind_address_)
    for (size_t peer = 0; peer < services; ++peer) {
        TEST_ASSERT_EQUAL_INT (
          2, TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&msg, pull, 0)));
-        const char *str = (const char *) zmq_msg_data (&msg);
+        const char *str = static_cast<const char *> (zmq_msg_data (&msg));
        second_half -= str[0];
    }
    TEST_ASSERT_EQUAL_INT (0, second_half);
@ -237,7 +237,7 @@ void test_destroy_queue_on_disconnect (const char *bind_address_)

 // PUSH and PULL: SHALL either receive or drop multipart messages atomically.
 void test_push_multipart_atomic_drop (const char *bind_address_,
-                                      const bool block)
+                                      const bool block_)
 {
    int linger = 0;
    int hwm = 1;
@ -312,7 +312,7 @@ void test_push_multipart_atomic_drop (const char *bind_address_,
    send_string_expect_success (push, "3", ZMQ_SNDMORE);
    TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init_size (&msg_data, len));
    memset (zmq_msg_data (&msg_data), 'c', len);
-    if (block) {
+    if (block_) {
        TEST_ASSERT_EQUAL_INT (len,
                               zmq_msg_send (&msg_data, push, ZMQ_SNDMORE));
    } else {
--- a/tests/test_spec_rep.cpp
+++ b/tests/test_spec_rep.cpp
@ -36,7 +36,7 @@ SETUP_TEARDOWN_TESTCONTEXT

 char connect_address[MAX_SOCKET_STRING];

-void test_fair_queue_in (const char *bind_address)
+void test_fair_queue_in (const char *bind_address_)
 {
    void *rep = test_context_socket (ZMQ_REP);

@ -44,7 +44,7 @@ void test_fair_queue_in (const char *bind_address)
    TEST_ASSERT_SUCCESS_ERRNO (
      zmq_setsockopt (rep, ZMQ_RCVTIMEO, &timeout, sizeof (int)));

-    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (rep, bind_address));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (rep, bind_address_));
    size_t len = MAX_SOCKET_STRING;
    TEST_ASSERT_SUCCESS_ERRNO (
      zmq_getsockopt (rep, ZMQ_LAST_ENDPOINT, connect_address, &len));
@ -98,11 +98,11 @@ void test_fair_queue_in (const char *bind_address)
        test_context_socket_close_zero_linger (reqs[peer]);
 }

-void test_envelope (const char *bind_address)
+void test_envelope (const char *bind_address_)
 {
    void *rep = test_context_socket (ZMQ_REP);

-    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (rep, bind_address));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (rep, bind_address_));
    size_t len = MAX_SOCKET_STRING;
    TEST_ASSERT_SUCCESS_ERRNO (
      zmq_getsockopt (rep, ZMQ_LAST_ENDPOINT, connect_address, &len));
--- a/tests/test_spec_router.cpp
+++ b/tests/test_spec_router.cpp
@ -37,7 +37,7 @@ SETUP_TEARDOWN_TESTCONTEXT

 // SHALL receive incoming messages from its peers using a fair-queuing
 // strategy.
-void test_fair_queue_in (const char *bind_address)
+void test_fair_queue_in (const char *bind_address_)
 {
    char connect_address[MAX_SOCKET_STRING];
    void *receiver = test_context_socket (ZMQ_ROUTER);
@ -46,7 +46,7 @@ void test_fair_queue_in (const char *bind_address)
    TEST_ASSERT_SUCCESS_ERRNO (
      zmq_setsockopt (receiver, ZMQ_RCVTIMEO, &timeout, sizeof (int)));

-    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (receiver, bind_address));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (receiver, bind_address_));
    size_t len = MAX_SOCKET_STRING;
    TEST_ASSERT_SUCCESS_ERRNO (
      zmq_getsockopt (receiver, ZMQ_LAST_ENDPOINT, connect_address, &len));
@ -116,7 +116,7 @@ void test_fair_queue_in (const char *bind_address)
 // SHALL create a double queue when a peer connects to it. If this peer
 // disconnects, the ROUTER socket SHALL destroy its double queue and SHALL
 // discard any messages it contains.
-void test_destroy_queue_on_disconnect (const char *bind_address)
+void test_destroy_queue_on_disconnect (const char *bind_address_)
 {
    void *a = test_context_socket (ZMQ_ROUTER);

@ -124,7 +124,7 @@ void test_destroy_queue_on_disconnect (const char *bind_address)
    TEST_ASSERT_SUCCESS_ERRNO (
      zmq_setsockopt (a, ZMQ_ROUTER_MANDATORY, &enabled, sizeof (enabled)));

-    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (a, bind_address));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (a, bind_address_));
    size_t len = MAX_SOCKET_STRING;
    char connect_address[MAX_SOCKET_STRING];
    TEST_ASSERT_SUCCESS_ERRNO (
--- a/tests/test_stream_disconnect.cpp
+++ b/tests/test_stream_disconnect.cpp
@ -168,7 +168,8 @@ void test_stream_disconnect ()
              zmq_msg_recv (&data_frame, sockets[SERVER], 0));

            // Make sure payload matches what we expect.
-            const char *const data = (const char *) zmq_msg_data (&data_frame);
+            const char *const data =
+              static_cast<const char *> (zmq_msg_data (&data_frame));
            const size_t size = zmq_msg_size (&data_frame);
            // 0-length frame is a disconnection notification.  The server
            // should receive it as the last step in the dialogue.
@ -222,7 +223,8 @@ void test_stream_disconnect ()
            TEST_ASSERT_GREATER_THAN_INT (0, zmq_msg_size (&data_frame));

            // Make sure payload matches what we expect.
-            const char *const data = (const char *) zmq_msg_data (&data_frame);
+            const char *const data =
+              static_cast<const char *> (zmq_msg_data (&data_frame));
            const size_t size = zmq_msg_size (&data_frame);
            TEST_ASSERT_EQUAL_INT (strlen (dialog[step].text), size);
            TEST_ASSERT_EQUAL_STRING_LEN (dialog[step].text, data, size);
--- a/tests/test_stream_timeout.cpp
+++ b/tests/test_stream_timeout.cpp
@ -48,10 +48,10 @@ static int get_monitor_event (void *monitor_, int *value_, char **address_)
        return -1; //  Interruped, presumably
    TEST_ASSERT_TRUE (zmq_msg_more (&msg));

-    uint8_t *data = (uint8_t *) zmq_msg_data (&msg);
-    uint16_t event = *(uint16_t *) (data);
+    uint8_t *data = static_cast<uint8_t *> (zmq_msg_data (&msg));
+    uint16_t event = *reinterpret_cast<uint16_t *> (data);
    if (value_)
-        *value_ = *(uint32_t *) (data + 2);
+        *value_ = *reinterpret_cast<uint32_t *> (data + 2);

    //  Second frame in message contains event address
    zmq_msg_init (&msg);
@ -60,9 +60,9 @@ static int get_monitor_event (void *monitor_, int *value_, char **address_)
    TEST_ASSERT_TRUE (!zmq_msg_more (&msg));

    if (address_) {
-        uint8_t *data = (uint8_t *) zmq_msg_data (&msg);
+        uint8_t *data = static_cast<uint8_t *> (zmq_msg_data (&msg));
        size_t size = zmq_msg_size (&msg);
-        *address_ = (char *) malloc (size + 1);
+        *address_ = static_cast<char *> (malloc (size + 1));
        memcpy (*address_, data, size);
        *address_[size] = 0;
    }
--- a/tests/test_timers.cpp
+++ b/tests/test_timers.cpp
@ -42,7 +42,7 @@ void tearDown ()
 void handler (int timer_id_, void *arg_)
 {
    (void) timer_id_; //  Stop 'unused' compiler warnings
-    *((bool *) arg_) = true;
+    *(static_cast<bool *> (arg_)) = true;
 }

 int sleep_and_execute (void *timers_)
--- a/tests/test_use_fd.cpp
+++ b/tests/test_use_fd.cpp
@ -119,7 +119,7 @@ void test_client_server (pre_allocate_sock_fun_t pre_allocate_sock_fun_)
    zmq_msg_t msg;
    TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init_size (&msg, 1));

-    char *data = (char *) zmq_msg_data (&msg);
+    char *data = static_cast<char *> (zmq_msg_data (&msg));
    data[0] = 1;

    int rc = zmq_msg_send (&msg, sc, ZMQ_SNDMORE);
@ -141,7 +141,7 @@ void test_client_server (pre_allocate_sock_fun_t pre_allocate_sock_fun_)

    TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init_size (&msg, 1));

-    data = (char *) zmq_msg_data (&msg);
+    data = static_cast<char *> (zmq_msg_data (&msg));
    data[0] = 2;

    TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_set_routing_id (&msg, routing_id));
@ -227,7 +227,8 @@ void pre_allocate_sock_ipc_int (void *zmq_socket_, const char *path_)
    // TODO check return value of unlink
    unlink (path_);

-    setup_socket_and_set_fd (zmq_socket_, AF_UNIX, 0, (struct sockaddr *) &addr,
+    setup_socket_and_set_fd (zmq_socket_, AF_UNIX, 0,
+                             reinterpret_cast<struct sockaddr *> (&addr),
                             sizeof (struct sockaddr_un));
 }

--- a/tests/test_xpub_nodrop.cpp
+++ b/tests/test_xpub_nodrop.cpp
@ -73,16 +73,16 @@ void test ()
        if (rc == -1) {
            TEST_ASSERT_EQUAL_INT (EAGAIN, errno);
            break;
-        } else {
-            TEST_ASSERT_EQUAL_INT (0, rc);
-            recv_count++;
-
-            if (recv_count == 1) {
-                const int sub_rcvtimeo = 250;
-                TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (
-                  sub, ZMQ_RCVTIMEO, &sub_rcvtimeo, sizeof (sub_rcvtimeo)));
-            }
        }
+        TEST_ASSERT_EQUAL_INT (0, rc);
+        recv_count++;
+
+        if (recv_count == 1) {
+            const int sub_rcvtimeo = 250;
+            TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (
+              sub, ZMQ_RCVTIMEO, &sub_rcvtimeo, sizeof (sub_rcvtimeo)));
+        }
+
    } while (true);

    TEST_ASSERT_EQUAL_INT (send_count, recv_count);
--- a/tests/testutil.cpp
+++ b/tests/testutil.cpp
@ -284,7 +284,8 @@ int is_ipv6_available ()
        if (rc != 0)
            ipv6 = 0;
        else {
-            rc = bind (fd, (struct sockaddr *) &test_addr, sizeof (test_addr));
+            rc = bind (fd, reinterpret_cast<struct sockaddr *> (&test_addr),
+                       sizeof (test_addr));
            if (rc != 0)
                ipv6 = 0;
        }
@ -342,7 +343,7 @@ int test_inet_pton (int af_, const char *src_, void *dst_)
 #endif
 }

-sockaddr_in bind_bsd_socket (int socket)
+sockaddr_in bind_bsd_socket (int socket_)
 {
    struct sockaddr_in saddr;
    memset (&saddr, 0, sizeof (saddr));
@ -355,23 +356,23 @@ sockaddr_in bind_bsd_socket (int socket)
 #endif

    TEST_ASSERT_SUCCESS_RAW_ERRNO (
-      bind (socket, (struct sockaddr *) &saddr, sizeof (saddr)));
+      bind (socket_, (struct sockaddr *) &saddr, sizeof (saddr)));

 #if !defined(_WIN32_WINNT) || (_WIN32_WINNT >= 0x0600)
    socklen_t saddr_len = sizeof (saddr);
    TEST_ASSERT_SUCCESS_RAW_ERRNO (
-      getsockname (socket, (struct sockaddr *) &saddr, &saddr_len));
+      getsockname (socket_, (struct sockaddr *) &saddr, &saddr_len));
 #endif

    return saddr;
 }

-bool streq (const char *lhs, const char *rhs)
+bool streq (const char *lhs_, const char *rhs_)
 {
-    return strcmp (lhs, rhs) == 0;
+    return strcmp (lhs_, rhs_) == 0;
 }

-bool strneq (const char *lhs, const char *rhs)
+bool strneq (const char *lhs_, const char *rhs_)
 {
-    return strcmp (lhs, rhs) != 0;
+    return strcmp (lhs_, rhs_) != 0;
 }
--- a/tests/testutil_monitoring.cpp
+++ b/tests/testutil_monitoring.cpp
@ -50,8 +50,8 @@ static int get_monitor_event_internal (void *monitor_,
    }
    TEST_ASSERT_TRUE (zmq_msg_more (&msg));

-    uint8_t *data = (uint8_t *) zmq_msg_data (&msg);
-    uint16_t event = *(uint16_t *) (data);
+    uint8_t *data = static_cast<uint8_t *> (zmq_msg_data (&msg));
+    uint16_t event = *reinterpret_cast<uint16_t *> (data);
    if (value_)
        memcpy (value_, data + 2, sizeof (uint32_t));

@ -61,9 +61,9 @@ static int get_monitor_event_internal (void *monitor_,
    TEST_ASSERT_FALSE (zmq_msg_more (&msg));

    if (address_) {
-        uint8_t *data = (uint8_t *) zmq_msg_data (&msg);
+        uint8_t *data = static_cast<uint8_t *> (zmq_msg_data (&msg));
        size_t size = zmq_msg_size (&msg);
-        *address_ = (char *) malloc (size + 1);
+        *address_ = static_cast<char *> (malloc (size + 1));
        memcpy (*address_, data, size);
        (*address_)[size] = 0;
    }
@ -246,9 +246,9 @@ static int64_t get_monitor_event_internal_v2 (void *monitor_,
    TEST_ASSERT_TRUE (zmq_msg_more (&msg));

    if (local_address_) {
-        uint8_t *data = (uint8_t *) zmq_msg_data (&msg);
+        uint8_t *data = static_cast<uint8_t *> (zmq_msg_data (&msg));
        size_t size = zmq_msg_size (&msg);
-        *local_address_ = (char *) malloc (size + 1);
+        *local_address_ = static_cast<char *> (malloc (size + 1));
        memcpy (*local_address_, data, size);
        (*local_address_)[size] = 0;
    }
@ -260,9 +260,9 @@ static int64_t get_monitor_event_internal_v2 (void *monitor_,
    TEST_ASSERT_TRUE (!zmq_msg_more (&msg));

    if (remote_address_) {
-        uint8_t *data = (uint8_t *) zmq_msg_data (&msg);
+        uint8_t *data = static_cast<uint8_t *> (zmq_msg_data (&msg));
        size_t size = zmq_msg_size (&msg);
-        *remote_address_ = (char *) malloc (size + 1);
+        *remote_address_ = static_cast<char *> (malloc (size + 1));
        memcpy (*remote_address_, data, size);
        (*remote_address_)[size] = 0;
    }
@ -328,7 +328,8 @@ void expect_monitor_event_v2 (void *monitor_,
    if (event != expected_event_) {
        pos += snprintf (pos, sizeof buf - (pos - buf),
                         "Expected monitor event %llx, but received %llx\n",
-                         (long long) expected_event_, (long long) event);
+                         static_cast<long long> (expected_event_),
+                         static_cast<long long> (event));
        failed = true;
    }
    if (expected_local_address_
--- a/tests/testutil_security.cpp
+++ b/tests/testutil_security.cpp
@ -44,7 +44,7 @@ void socket_config_null_server (void *server_, void *server_secret_)
    TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (
      server_, ZMQ_ZAP_DOMAIN, test_zap_domain, strlen (test_zap_domain)));
 #ifdef ZMQ_ZAP_ENFORCE_DOMAIN
-    int required = server_secret_ ? *(int *) server_secret_ : 0;
+    int required = server_secret_ ? *static_cast<int *> (server_secret_) : 0;
    TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (server_, ZMQ_ZAP_ENFORCE_DOMAIN,
                                               &required, sizeof (int)));
 #else
--- a/tests/testutil_unity.cpp
+++ b/tests/testutil_unity.cpp
@ -40,7 +40,7 @@
 int test_assert_success_message_errno_helper (int rc_,
                                              const char *msg_,
                                              const char *expr_,
-                                              int line)
+                                              int line_)
 {
    if (rc_ == -1) {
        char buffer[512];
@ -50,7 +50,7 @@ int test_assert_success_message_errno_helper (int rc_,
                  "%s failed%s%s%s, errno = %i (%s)", expr_,
                  msg_ ? " (additional info: " : "", msg_ ? msg_ : "",
                  msg_ ? ")" : "", zmq_errno (), zmq_strerror (zmq_errno ()));
-        UNITY_TEST_FAIL (line, buffer);
+        UNITY_TEST_FAIL (line_, buffer);
    }
    return rc_;
 }
@ -58,7 +58,7 @@ int test_assert_success_message_errno_helper (int rc_,
 int test_assert_success_message_raw_errno_helper (int rc_,
                                                  const char *msg_,
                                                  const char *expr_,
-                                                  int line)
+                                                  int line_)
 {
    if (rc_ == -1) {
 #if defined ZMQ_HAVE_WINDOWS
@ -73,13 +73,13 @@ int test_assert_success_message_raw_errno_helper (int rc_,
        snprintf (buffer, sizeof (buffer) - 1, "%s failed%s%s%s, errno = %i",
                  expr_, msg_ ? " (additional info: " : "", msg_ ? msg_ : "",
                  msg_ ? ")" : "", current_errno);
-        UNITY_TEST_FAIL (line, buffer);
+        UNITY_TEST_FAIL (line_, buffer);
    }
    return rc_;
 }

 int test_assert_failure_message_raw_errno_helper (
-  int rc_, int expected_errno_, const char *msg_, const char *expr_, int line)
+  int rc_, int expected_errno_, const char *msg_, const char *expr_, int line_)
 {
    char buffer[512];
    buffer[sizeof (buffer) - 1] =
@ -90,7 +90,7 @@ int test_assert_failure_message_raw_errno_helper (
                  "errno = %i, actual return value = %i",
                  expr_, msg_ ? " (additional info: " : "", msg_ ? msg_ : "",
                  msg_ ? ")" : "", expected_errno_, rc_);
-        UNITY_TEST_FAIL (line, buffer);
+        UNITY_TEST_FAIL (line_, buffer);
    } else {
 #if defined ZMQ_HAVE_WINDOWS
        int current_errno = WSAGetLastError ();
@ -104,7 +104,7 @@ int test_assert_failure_message_raw_errno_helper (
                      expr_, msg_ ? " (additional info: " : "",
                      msg_ ? msg_ : "", msg_ ? ")" : "", expected_errno_,
                      current_errno);
-            UNITY_TEST_FAIL (line, buffer);
+            UNITY_TEST_FAIL (line_, buffer);
        }
    }
    return rc_;
@ -165,7 +165,7 @@ static void internal_manage_test_sockets (void *socket_, bool add_)
            fprintf (stderr,
                     "WARNING: Forced closure of %i sockets, this is an "
                     "implementation error unless the test case failed\n",
-                     (int) test_socket_count);
+                     static_cast<int> (test_socket_count));
            test_socket_count = 0;
        }
    } else {
--- a/unittests/unittest_ip_resolver.cpp
+++ b/unittests/unittest_ip_resolver.cpp
@ -160,9 +160,9 @@ static void test_resolve (zmq::ip_resolver_options_t opts_,
        // TODO also check the expected errno
        TEST_ASSERT_EQUAL (-1, rc);
        return;
-    } else {
-        TEST_ASSERT_SUCCESS_ERRNO (rc);
    }
+    TEST_ASSERT_SUCCESS_ERRNO (rc);
+

    validate_address (family, &addr, expected_addr_, expected_port_,
                      expected_zone_, expected_addr_v4_failover_);
--- a/unittests/unittest_mtrie.cpp
+++ b/unittests/unittest_mtrie.cpp
@ -34,9 +34,9 @@ void tearDown ()
 {
 }

-int getlen (const zmq::generic_mtrie_t<int>::prefix_t &data)
+int getlen (const zmq::generic_mtrie_t<int>::prefix_t &data_)
 {
-    return (int) strlen (reinterpret_cast<const char *> (data));
+    return static_cast<int> (strlen (reinterpret_cast<const char *> (data_)));
 }

 void test_create ()
@ -44,10 +44,10 @@ void test_create ()
    zmq::generic_mtrie_t<int> mtrie;
 }

-void mtrie_count (int *pipe, int *count)
+void mtrie_count (int *pipe_, int *count_)
 {
-    LIBZMQ_UNUSED (pipe);
-    ++*count;
+    LIBZMQ_UNUSED (pipe_);
+    ++*count_;
 }

 void test_check_empty_match_nonempty_data ()
@ -187,14 +187,14 @@ void test_rm_nonexistent_empty ()
    TEST_ASSERT_EQUAL_INT (0, count);
 }

-void test_add_and_rm_other (const char *add_name, const char *rm_name)
+void test_add_and_rm_other (const char *add_name_, const char *rm_name_)
 {
    int addpipe, rmpipe;
    zmq::generic_mtrie_t<int> mtrie;
    const zmq::generic_mtrie_t<int>::prefix_t add_name_data =
-      reinterpret_cast<zmq::generic_mtrie_t<int>::prefix_t> (add_name);
+      reinterpret_cast<zmq::generic_mtrie_t<int>::prefix_t> (add_name_);
    const zmq::generic_mtrie_t<int>::prefix_t rm_name_data =
-      reinterpret_cast<zmq::generic_mtrie_t<int>::prefix_t> (rm_name);
+      reinterpret_cast<zmq::generic_mtrie_t<int>::prefix_t> (rm_name_);

    mtrie.add (add_name_data, getlen (add_name_data), &addpipe);

@ -209,8 +209,8 @@ void test_add_and_rm_other (const char *add_name, const char *rm_name)
        TEST_ASSERT_EQUAL_INT (1, count);
    }

-    if (strncmp (add_name, rm_name,
-                 std::min (strlen (add_name), strlen (rm_name) + 1))
+    if (strncmp (add_name_, rm_name_,
+                 std::min (strlen (add_name_), strlen (rm_name_) + 1))
        != 0) {
        int count = 0;
        mtrie.match (rm_name_data, getlen (rm_name_data), mtrie_count, &count);
@ -240,15 +240,15 @@ void test_rm_nonexistent_nonempty_prefixed ()
    test_add_and_rm_other ("foo", "foobar");
 }

-void add_indexed_expect_unique (zmq::generic_mtrie_t<int> &mtrie,
-                                int *pipes,
-                                const char **names,
-                                size_t i)
+void add_indexed_expect_unique (zmq::generic_mtrie_t<int> &mtrie_,
+                                int *pipes_,
+                                const char **names_,
+                                size_t i_)
 {
    const zmq::generic_mtrie_t<int>::prefix_t name_data =
-      reinterpret_cast<zmq::generic_mtrie_t<int>::prefix_t> (names[i]);
+      reinterpret_cast<zmq::generic_mtrie_t<int>::prefix_t> (names_[i_]);

-    bool res = mtrie.add (name_data, getlen (name_data), &pipes[i]);
+    bool res = mtrie_.add (name_data, getlen (name_data), &pipes_[i_]);
    TEST_ASSERT_EQUAL (zmq::generic_mtrie_t<int>::last_value_removed, res);
 }

@ -270,12 +270,12 @@ void test_rm_nonexistent_between ()
 }

 template <size_t N>
-void add_entries (zmq::generic_mtrie_t<int> &mtrie,
-                  int (&pipes)[N],
-                  const char *(&names)[N])
+void add_entries (zmq::generic_mtrie_t<int> &mtrie_,
+                  int (&pipes_)[N],
+                  const char *(&names_)[N])
 {
    for (size_t i = 0; i < N; ++i) {
-        add_indexed_expect_unique (mtrie, pipes, names, i);
+        add_indexed_expect_unique (mtrie_, pipes_, names_, i);
    }
 }

@ -303,7 +303,8 @@ void test_add_multiple_reverse ()

    zmq::generic_mtrie_t<int> mtrie;
    for (int i = 2; i >= 0; --i) {
-        add_indexed_expect_unique (mtrie, pipes, names, (size_t) i);
+        add_indexed_expect_unique (mtrie, pipes, names,
+                                   static_cast<size_t> (i));
    }

    for (size_t i = 0; i < 3; ++i) {
@ -315,15 +316,15 @@ void test_add_multiple_reverse ()
    }
 }

-template <size_t N> void add_and_rm_entries (const char *(&names)[N])
+template <size_t N> void add_and_rm_entries (const char *(&names_)[N])
 {
    int pipes[N];
    zmq::generic_mtrie_t<int> mtrie;
-    add_entries (mtrie, pipes, names);
+    add_entries (mtrie, pipes, names_);

    for (size_t i = 0; i < N; ++i) {
        const zmq::generic_mtrie_t<int>::prefix_t name_data =
-          reinterpret_cast<zmq::generic_mtrie_t<int>::prefix_t> (names[i]);
+          reinterpret_cast<zmq::generic_mtrie_t<int>::prefix_t> (names_[i]);

        zmq::generic_mtrie_t<int>::rm_result res =
          mtrie.rm (name_data, getlen (name_data), &pipes[i]);
@ -351,14 +352,14 @@ void check_name (zmq::generic_mtrie_t<int>::prefix_t data_,
    TEST_ASSERT_EQUAL_STRING_LEN (name_, data_, len_);
 }

-template <size_t N> void add_entries_rm_pipes_unique (const char *(&names)[N])
+template <size_t N> void add_entries_rm_pipes_unique (const char *(&names_)[N])
 {
    int pipes[N];
    zmq::generic_mtrie_t<int> mtrie;
-    add_entries (mtrie, pipes, names);
+    add_entries (mtrie, pipes, names_);

    for (size_t i = 0; i < N; ++i) {
-        mtrie.rm (&pipes[i], check_name, names[i], false);
+        mtrie.rm (&pipes[i], check_name, names_[i], false);
    }
 }

@ -384,16 +385,16 @@ void check_count (zmq::generic_mtrie_t<int>::prefix_t data_,
    TEST_ASSERT_GREATER_OR_EQUAL (0, *count_);
 }

-void add_duplicate_entry (zmq::generic_mtrie_t<int> &mtrie, int (&pipes)[2])
+void add_duplicate_entry (zmq::generic_mtrie_t<int> &mtrie_, int (&pipes_)[2])
 {
    const char *name = "foo";

    const zmq::generic_mtrie_t<int>::prefix_t name_data =
      reinterpret_cast<zmq::generic_mtrie_t<int>::prefix_t> (name);

-    bool res = mtrie.add (name_data, getlen (name_data), &pipes[0]);
+    bool res = mtrie_.add (name_data, getlen (name_data), &pipes_[0]);
    TEST_ASSERT_TRUE (res);
-    res = mtrie.add (name_data, getlen (name_data), &pipes[1]);
+    res = mtrie_.add (name_data, getlen (name_data), &pipes_[1]);
    TEST_ASSERT_FALSE (res);
 }

--- a/unittests/unittest_poller.cpp
+++ b/unittests/unittest_poller.cpp
@ -57,16 +57,16 @@ void test_start_empty ()
 struct test_events_t : zmq::i_poll_events
 {
    test_events_t (zmq::fd_t fd_, zmq::poller_t &poller_) :
-        fd (fd_),
-        poller (poller_)
+        _fd (fd_),
+        _poller (poller_)
    {
-        (void)fd;
+        (void) _fd;
    }

    virtual void in_event ()
    {
-        poller.rm_fd (handle);
-        handle = (zmq::poller_t::handle_t) NULL;
+        _poller.rm_fd (_handle);
+        _handle = (zmq::poller_t::handle_t) NULL;

        // this must only be incremented after rm_fd
        in_events.add (1);
@ -82,27 +82,27 @@ struct test_events_t : zmq::i_poll_events
    virtual void timer_event (int id_)
    {
        LIBZMQ_UNUSED (id_);
-        poller.rm_fd (handle);
-        handle = (zmq::poller_t::handle_t) NULL;
+        _poller.rm_fd (_handle);
+        _handle = (zmq::poller_t::handle_t) NULL;

        // this must only be incremented after rm_fd
        timer_events.add (1);
    }

-    void set_handle (zmq::poller_t::handle_t handle_) { handle = handle_; }
+    void set_handle (zmq::poller_t::handle_t handle_) { _handle = handle_; }

    zmq::atomic_counter_t in_events, timer_events;

  private:
-    zmq::fd_t fd;
-    zmq::poller_t &poller;
-    zmq::poller_t::handle_t handle;
+    zmq::fd_t _fd;
+    zmq::poller_t &_poller;
+    zmq::poller_t::handle_t _handle;
 };

-void wait_in_events (test_events_t &events)
+void wait_in_events (test_events_t &events_)
 {
    void *watch = zmq_stopwatch_start ();
-    while (events.in_events.get () < 1) {
+    while (events_.in_events.get () < 1) {
 #ifdef ZMQ_BUILD_DRAFT
        TEST_ASSERT_LESS_OR_EQUAL_MESSAGE (SETTLE_TIME,
                                           zmq_stopwatch_intermediate (watch),
@ -112,10 +112,10 @@ void wait_in_events (test_events_t &events)
    zmq_stopwatch_stop (watch);
 }

-void wait_timer_events (test_events_t &events)
+void wait_timer_events (test_events_t &events_)
 {
    void *watch = zmq_stopwatch_start ();
-    while (events.timer_events.get () < 1) {
+    while (events_.timer_events.get () < 1) {
 #ifdef ZMQ_BUILD_DRAFT
        TEST_ASSERT_LESS_OR_EQUAL_MESSAGE (SETTLE_TIME,
                                           zmq_stopwatch_intermediate (watch),
@ -125,40 +125,40 @@ void wait_timer_events (test_events_t &events)
    zmq_stopwatch_stop (watch);
 }

-void create_nonblocking_fdpair (zmq::fd_t *r, zmq::fd_t *w)
+void create_nonblocking_fdpair (zmq::fd_t *r_, zmq::fd_t *w_)
 {
-    int rc = zmq::make_fdpair (r, w);
+    int rc = zmq::make_fdpair (r_, w_);
    TEST_ASSERT_EQUAL_INT (0, rc);
-    TEST_ASSERT_NOT_EQUAL (zmq::retired_fd, *r);
-    TEST_ASSERT_NOT_EQUAL (zmq::retired_fd, *w);
-    zmq::unblock_socket (*r);
-    zmq::unblock_socket (*w);
+    TEST_ASSERT_NOT_EQUAL (zmq::retired_fd, *r_);
+    TEST_ASSERT_NOT_EQUAL (zmq::retired_fd, *w_);
+    zmq::unblock_socket (*r_);
+    zmq::unblock_socket (*w_);
 }

-void send_signal (zmq::fd_t w)
+void send_signal (zmq::fd_t w_)
 {
 #if defined ZMQ_HAVE_EVENTFD
    const uint64_t inc = 1;
-    ssize_t sz = write (w, &inc, sizeof (inc));
+    ssize_t sz = write (w_, &inc, sizeof (inc));
    assert (sz == sizeof (inc));
 #else
    {
        char msg[] = "test";
-        int rc = send (w, msg, sizeof (msg), 0);
+        int rc = send (w_, msg, sizeof (msg), 0);
        assert (rc == sizeof (msg));
    }
 #endif
 }

-void close_fdpair (zmq::fd_t w, zmq::fd_t r)
+void close_fdpair (zmq::fd_t w_, zmq::fd_t r_)
 {
-    int rc = closesocket (w);
+    int rc = closesocket (w_);
    TEST_ASSERT_EQUAL_INT (0, rc);
 #if !defined ZMQ_HAVE_EVENTFD
-    rc = closesocket (r);
+    rc = closesocket (r_);
    TEST_ASSERT_EQUAL_INT (0, rc);
 #else
-    LIBZMQ_UNUSED (r);
+    LIBZMQ_UNUSED (r_);
 #endif
 }

--- a/unittests/unittest_radix_tree.cpp
+++ b/unittests/unittest_radix_tree.cpp
@ -222,13 +222,13 @@ void test_size ()
    TEST_ASSERT_TRUE (tree.size () == 0);
 }

-void return_key (unsigned char *data, size_t size, void *arg)
+void return_key (unsigned char *data_, size_t size_, void *arg_)
 {
    std::vector<std::string> *vec =
-      reinterpret_cast<std::vector<std::string> *> (arg);
+      reinterpret_cast<std::vector<std::string> *> (arg_);
    std::string key;
-    for (size_t i = 0; i < size; ++i)
-        key.push_back (static_cast<char> (data[i]));
+    for (size_t i = 0; i < size_; ++i)
+        key.push_back (static_cast<char> (data_[i]));
    vec->push_back (key);
 }

--- a/unittests/unittest_udp_address.cpp
+++ b/unittests/unittest_udp_address.cpp
@ -54,9 +54,9 @@ static void test_resolve (bool bind_,
        TEST_ASSERT_EQUAL (-1, rc);
        TEST_ASSERT_EQUAL (EINVAL, errno);
        return;
-    } else {
-        TEST_ASSERT_EQUAL (0, rc);
    }
+    TEST_ASSERT_EQUAL (0, rc);
+

    TEST_ASSERT_EQUAL (multicast_, addr.is_mcast ());

@ -69,32 +69,36 @@ static void test_resolve (bool bind_,
        }
    }

-    validate_address (family_, addr.target_addr(), target_addr_, expected_port_);
-    validate_address (family_, addr.bind_addr(), bind_addr_, expected_port_);
+    validate_address (family_, addr.target_addr (), target_addr_,
+                      expected_port_);
+    validate_address (family_, addr.bind_addr (), bind_addr_, expected_port_);
 }

 static void test_resolve_bind (int family_,
-                               const char *name_, const char *dest_addr_,
-                                uint16_t expected_port_ = 0,
+                               const char *name_,
+                               const char *dest_addr_,
+                               uint16_t expected_port_ = 0,
                               const char *bind_addr_ = NULL,
                               bool multicast_ = false)
 {
-test_resolve (true, family_, name_, dest_addr_, expected_port_, bind_addr_,
+    test_resolve (true, family_, name_, dest_addr_, expected_port_, bind_addr_,
                  multicast_);
 }

-static void test_resolve_connect (int family_, const char *name_, const char *dest_addr_,
+static void test_resolve_connect (int family_,
+                                  const char *name_,
+                                  const char *dest_addr_,
                                  uint16_t expected_port_ = 0,
                                  const char *bind_addr_ = NULL,
                                  bool multicast_ = false)
 {
-test_resolve (false, family_, name_, dest_addr_, expected_port_, bind_addr_,
+    test_resolve (false, family_, name_, dest_addr_, expected_port_, bind_addr_,
                  multicast_);
 }

 static void test_resolve_ipv4_simple ()
 {
-test_resolve_connect (AF_INET, "127.0.0.1:5555", "127.0.0.1", 5555);
+    test_resolve_connect (AF_INET, "127.0.0.1:5555", "127.0.0.1", 5555);
 }

 static void test_resolve_ipv6_simple ()
@ -104,12 +108,14 @@ static void test_resolve_ipv6_simple ()

 static void test_resolve_ipv4_bind ()
 {
-    test_resolve_bind (AF_INET, "127.0.0.1:5555", "127.0.0.1", 5555, "127.0.0.1");
+    test_resolve_bind (AF_INET, "127.0.0.1:5555", "127.0.0.1", 5555,
+                       "127.0.0.1");
 }

 static void test_resolve_ipv6_bind ()
 {
-    test_resolve_bind (AF_INET6, "[abcd::1234:1]:5555", "abcd::1234:1", 5555, "abcd::1234:1");
+    test_resolve_bind (AF_INET6, "[abcd::1234:1]:5555", "abcd::1234:1", 5555,
+                       "abcd::1234:1");
 }

 static void test_resolve_ipv4_bind_any ()
@ -129,7 +135,8 @@ static void test_resolve_ipv4_bind_anyport ()

 static void test_resolve_ipv6_bind_anyport ()
 {
-    test_resolve_bind (AF_INET6, "[1:2:3:4::5]:*", "1:2:3:4::5", 0, "1:2:3:4::5");
+    test_resolve_bind (AF_INET6, "[1:2:3:4::5]:*", "1:2:3:4::5", 0,
+                       "1:2:3:4::5");
 }

 static void test_resolve_ipv4_bind_any_port ()
@ -176,7 +183,8 @@ static void test_resolve_ipv6_connect_port0 ()

 static void test_resolve_ipv4_bind_mcast ()
 {
-    test_resolve_bind (AF_INET, "239.0.0.1:1234", "239.0.0.1", 1234, "0.0.0.0", true);
+    test_resolve_bind (AF_INET, "239.0.0.1:1234", "239.0.0.1", 1234, "0.0.0.0",
+                       true);
 }

 static void test_resolve_ipv6_bind_mcast ()
@ -186,12 +194,14 @@ static void test_resolve_ipv6_bind_mcast ()

 static void test_resolve_ipv4_connect_mcast ()
 {
-    test_resolve_connect (AF_INET, "239.0.0.1:2222", "239.0.0.1", 2222, NULL, true);
+    test_resolve_connect (AF_INET, "239.0.0.1:2222", "239.0.0.1", 2222, NULL,
+                          true);
 }

 static void test_resolve_ipv6_connect_mcast ()
 {
-    test_resolve_connect (AF_INET6, "[ff00::1]:2222", "ff00::1", 2222, NULL, true);
+    test_resolve_connect (AF_INET6, "[ff00::1]:2222", "ff00::1", 2222, NULL,
+                          true);
 }

 static void test_resolve_ipv4_mcast_src_bind ()
@ -223,14 +233,13 @@ static void test_resolve_ipv4_mcast_src_bind_any ()

 static void test_resolve_ipv6_mcast_src_bind_any ()
 {
-    test_resolve_bind (AF_INET6, "*;[ffff::]:5555", "ffff::", 5555,
-                       "::", true);
+    test_resolve_bind (AF_INET6, "*;[ffff::]:5555", "ffff::", 5555, "::", true);
 }

 static void test_resolve_ipv4_mcast_src_connect ()
 {
-    test_resolve_connect (AF_INET, "8.9.10.11;230.2.8.12:5555", "230.2.8.12", 5555,
-                          "8.9.10.11", true);
+    test_resolve_connect (AF_INET, "8.9.10.11;230.2.8.12:5555", "230.2.8.12",
+                          5555, "8.9.10.11", true);
 }

 static void test_resolve_ipv6_mcast_src_connect ()