diff --git a/src/dealer.cpp b/src/dealer.cpp
index 2e2178e4..d812663e 100644
--- a/src/dealer.cpp
+++ b/src/dealer.cpp
@@ -49,9 +49,9 @@ void zmq::dealer_t::xattach_pipe (pipe_t *pipe_, bool icanhasall_)
     lb.attach (pipe_);
 }
 
-int zmq::dealer_t::xsend (msg_t *msg_, int flags_)
+int zmq::dealer_t::xsend (msg_t *msg_)
 {
-    return lb.send (msg_, flags_);
+    return lb.send (msg_);
 }
 
 int zmq::dealer_t::xrecv (msg_t *msg_, int flags_)
diff --git a/src/dealer.hpp b/src/dealer.hpp
index b58ef880..3d98736a 100644
--- a/src/dealer.hpp
+++ b/src/dealer.hpp
@@ -47,7 +47,7 @@ namespace zmq
 
         //  Overloads of functions from socket_base_t.
         void xattach_pipe (zmq::pipe_t *pipe_, bool icanhasall_);
-        int xsend (zmq::msg_t *msg_, int flags_);
+        int xsend (zmq::msg_t *msg_);
         int xrecv (zmq::msg_t *msg_, int flags_);
         bool xhas_in ();
         bool xhas_out ();
diff --git a/src/dist.cpp b/src/dist.cpp
index a8cb2ecf..c16fb493 100644
--- a/src/dist.cpp
+++ b/src/dist.cpp
@@ -103,19 +103,19 @@ void zmq::dist_t::activated (pipe_t *pipe_)
     }
 }
 
-int zmq::dist_t::send_to_all (msg_t *msg_, int flags_)
+int zmq::dist_t::send_to_all (msg_t *msg_)
 {
     matching = active;
-    return send_to_matching (msg_, flags_);
+    return send_to_matching (msg_);
 }
 
-int zmq::dist_t::send_to_matching (msg_t *msg_, int flags_)
+int zmq::dist_t::send_to_matching (msg_t *msg_)
 {
     //  Is this end of a multipart message?
     bool msg_more = msg_->flags () & msg_t::more ? true : false;
 
     //  Push the message to matching pipes.
-    distribute (msg_, flags_);
+    distribute (msg_);
 
     //  If mutlipart message is fully sent, activate all the eligible pipes.
     if (!msg_more)
@@ -126,11 +126,8 @@ int zmq::dist_t::send_to_matching (msg_t *msg_, int flags_)
     return 0;
 }
 
-void zmq::dist_t::distribute (msg_t *msg_, int flags_)
+void zmq::dist_t::distribute (msg_t *msg_)
 {
-    // flags_ is unused
-    (void)flags_;
-
     //  If there are no matching pipes available, simply drop the message.
     if (matching == 0) {
         int rc = msg_->close ();
diff --git a/src/dist.hpp b/src/dist.hpp
index be86ab2f..8b62c5fe 100644
--- a/src/dist.hpp
+++ b/src/dist.hpp
@@ -58,10 +58,10 @@ namespace zmq
         void terminated (zmq::pipe_t *pipe_);
 
         //  Send the message to the matching outbound pipes.
-        int send_to_matching (zmq::msg_t *msg_, int flags_);
+        int send_to_matching (zmq::msg_t *msg_);
 
         //  Send the message to all the outbound pipes.
-        int send_to_all (zmq::msg_t *msg_, int flags_);
+        int send_to_all (zmq::msg_t *msg_);
 
         bool has_out ();
 
@@ -72,7 +72,7 @@ namespace zmq
         bool write (zmq::pipe_t *pipe_, zmq::msg_t *msg_);
 
         //  Put the message to all active pipes.
-        void distribute (zmq::msg_t *msg_, int flags_);
+        void distribute (zmq::msg_t *msg_);
 
         //  List of outbound pipes.
         typedef array_t <zmq::pipe_t, 2> pipes_t;
diff --git a/src/lb.cpp b/src/lb.cpp
index 51696ff6..77d0235b 100644
--- a/src/lb.cpp
+++ b/src/lb.cpp
@@ -71,11 +71,8 @@ void zmq::lb_t::activated (pipe_t *pipe_)
     active++;
 }
 
-int zmq::lb_t::send (msg_t *msg_, int flags_)
+int zmq::lb_t::send (msg_t *msg_)
 {
-    // flags_ is unused
-    (void)flags_;
-
     //  Drop the message if required. If we are at the end of the message
     //  switch back to non-dropping mode.
     if (dropping) {
diff --git a/src/lb.hpp b/src/lb.hpp
index 91189f5b..bb327518 100644
--- a/src/lb.hpp
+++ b/src/lb.hpp
@@ -42,7 +42,7 @@ namespace zmq
         void activated (pipe_t *pipe_);
         void terminated (pipe_t *pipe_);
 
-        int send (msg_t *msg_, int flags_);
+        int send (msg_t *msg_);
         bool has_out ();
 
     private:
diff --git a/src/pair.cpp b/src/pair.cpp
index a06c21d2..213d9171 100644
--- a/src/pair.cpp
+++ b/src/pair.cpp
@@ -69,14 +69,14 @@ void zmq::pair_t::xwrite_activated (pipe_t *)
     //  There's nothing to do here.
 }
 
-int zmq::pair_t::xsend (msg_t *msg_, int flags_)
+int zmq::pair_t::xsend (msg_t *msg_)
 {
     if (!pipe || !pipe->write (msg_)) {
         errno = EAGAIN;
         return -1;
     }
 
-    if (!(flags_ & ZMQ_SNDMORE))
+    if (!(msg_->flags () & msg_t::more))
         pipe->flush ();
 
     //  Detach the original message from the data buffer.
diff --git a/src/pair.hpp b/src/pair.hpp
index d07052e9..da31674e 100644
--- a/src/pair.hpp
+++ b/src/pair.hpp
@@ -43,7 +43,7 @@ namespace zmq
 
         //  Overloads of functions from socket_base_t.
         void xattach_pipe (zmq::pipe_t *pipe_, bool icanhasall_);
-        int xsend (zmq::msg_t *msg_, int flags_);
+        int xsend (zmq::msg_t *msg_);
         int xrecv (zmq::msg_t *msg_, int flags_);
         bool xhas_in ();
         bool xhas_out ();
diff --git a/src/push.cpp b/src/push.cpp
index 2414f2c1..edc5228e 100644
--- a/src/push.cpp
+++ b/src/push.cpp
@@ -53,9 +53,9 @@ void zmq::push_t::xterminated (pipe_t *pipe_)
     lb.terminated (pipe_);
 }
 
-int zmq::push_t::xsend (msg_t *msg_, int flags_)
+int zmq::push_t::xsend (msg_t *msg_)
 {
-    return lb.send (msg_, flags_);
+    return lb.send (msg_);
 }
 
 bool zmq::push_t::xhas_out ()
diff --git a/src/push.hpp b/src/push.hpp
index 3ac2bf0f..bae4a7ca 100644
--- a/src/push.hpp
+++ b/src/push.hpp
@@ -46,7 +46,7 @@ namespace zmq
 
         //  Overloads of functions from socket_base_t.
         void xattach_pipe (zmq::pipe_t *pipe_, bool icanhasall_);
-        int xsend (zmq::msg_t *msg_, int flags_);
+        int xsend (zmq::msg_t *msg_);
         bool xhas_out ();
         void xwrite_activated (zmq::pipe_t *pipe_);
         void xterminated (zmq::pipe_t *pipe_);
diff --git a/src/rep.cpp b/src/rep.cpp
index 8d8b3d79..a6c2e2f0 100644
--- a/src/rep.cpp
+++ b/src/rep.cpp
@@ -35,7 +35,7 @@ zmq::rep_t::~rep_t ()
 {
 }
 
-int zmq::rep_t::xsend (msg_t *msg_, int flags_)
+int zmq::rep_t::xsend (msg_t *msg_)
 {
     //  If we are in the middle of receiving a request, we cannot send reply.
     if (!sending_reply) {
@@ -46,7 +46,7 @@ int zmq::rep_t::xsend (msg_t *msg_, int flags_)
     bool more = msg_->flags () & msg_t::more ? true : false;
 
     //  Push message to the reply pipe.
-    int rc = router_t::xsend (msg_, flags_);
+    int rc = router_t::xsend (msg_);
     if (rc != 0)
         return rc;
 
@@ -78,7 +78,7 @@ int zmq::rep_t::xrecv (msg_t *msg_, int flags_)
                 bool bottom = (msg_->size () == 0);
 
                 //  Push it to the reply pipe.
-                rc = router_t::xsend (msg_, flags_);
+                rc = router_t::xsend (msg_);
                 errno_assert (rc == 0);
 
                 if (bottom)
diff --git a/src/rep.hpp b/src/rep.hpp
index 5c6eca75..033626fc 100644
--- a/src/rep.hpp
+++ b/src/rep.hpp
@@ -40,7 +40,7 @@ namespace zmq
         ~rep_t ();
 
         //  Overloads of functions from socket_base_t.
-        int xsend (zmq::msg_t *msg_, int flags_);
+        int xsend (zmq::msg_t *msg_);
         int xrecv (zmq::msg_t *msg_, int flags_);
         bool xhas_in ();
         bool xhas_out ();
diff --git a/src/req.cpp b/src/req.cpp
index e1b68a67..51510ccd 100644
--- a/src/req.cpp
+++ b/src/req.cpp
@@ -39,7 +39,7 @@ zmq::req_t::~req_t ()
 {
 }
 
-int zmq::req_t::xsend (msg_t *msg_, int flags_)
+int zmq::req_t::xsend (msg_t *msg_)
 {
     //  If we've sent a request and we still haven't got the reply,
     //  we can't send another request.
@@ -54,7 +54,7 @@ int zmq::req_t::xsend (msg_t *msg_, int flags_)
         int rc = bottom.init ();
         errno_assert (rc == 0);
         bottom.set_flags (msg_t::more);
-        rc = dealer_t::xsend (&bottom, 0);
+        rc = dealer_t::xsend (&bottom);
         if (rc != 0)
             return -1;
         message_begins = false;
@@ -62,7 +62,7 @@ int zmq::req_t::xsend (msg_t *msg_, int flags_)
 
     bool more = msg_->flags () & msg_t::more ? true : false;
 
-    int rc = dealer_t::xsend (msg_, flags_);
+    int rc = dealer_t::xsend (msg_);
     if (rc != 0)
         return rc;
 
diff --git a/src/req.hpp b/src/req.hpp
index 023778e3..34907311 100644
--- a/src/req.hpp
+++ b/src/req.hpp
@@ -42,7 +42,7 @@ namespace zmq
         ~req_t ();
 
         //  Overloads of functions from socket_base_t.
-        int xsend (zmq::msg_t *msg_, int flags_);
+        int xsend (zmq::msg_t *msg_);
         int xrecv (zmq::msg_t *msg_, int flags_);
         bool xhas_in ();
         bool xhas_out ();
diff --git a/src/router.cpp b/src/router.cpp
index 707e1ab0..c666121c 100644
--- a/src/router.cpp
+++ b/src/router.cpp
@@ -140,11 +140,8 @@ void zmq::router_t::xwrite_activated (pipe_t *pipe_)
     it->second.active = true;
 }
 
-int zmq::router_t::xsend (msg_t *msg_, int flags_)
+int zmq::router_t::xsend (msg_t *msg_)
 {
-    // flags_ is unused
-    (void)flags_;
-
     //  If this is the first part of the message it's the ID of the
     //  peer to send the message to.
     if (!more_out) {
diff --git a/src/router.hpp b/src/router.hpp
index 1a4b10b5..2a448f12 100644
--- a/src/router.hpp
+++ b/src/router.hpp
@@ -50,7 +50,7 @@ namespace zmq
         //  Overloads of functions from socket_base_t.
         void xattach_pipe (zmq::pipe_t *pipe_, bool icanhasall_);
         int xsetsockopt (int option_, const void *optval_, size_t optvallen_);
-        int xsend (msg_t *msg_, int flags_);
+        int xsend (msg_t *msg_);
         int xrecv (msg_t *msg_, int flags_);
         bool xhas_in ();
         bool xhas_out ();
diff --git a/src/socket_base.cpp b/src/socket_base.cpp
index 5f740af7..516e5635 100644
--- a/src/socket_base.cpp
+++ b/src/socket_base.cpp
@@ -622,7 +622,7 @@ int zmq::socket_base_t::send (msg_t *msg_, int flags_)
         msg_->set_flags (msg_t::more);
 
     //  Try to send the message.
-    rc = xsend (msg_, flags_);
+    rc = xsend (msg_);
     if (rc == 0)
         return 0;
     if (unlikely (errno != EAGAIN))
@@ -644,7 +644,7 @@ int zmq::socket_base_t::send (msg_t *msg_, int flags_)
     while (true) {
         if (unlikely (process_commands (timeout, false) != 0))
             return -1;
-        rc = xsend (msg_, flags_);
+        rc = xsend (msg_);
         if (rc == 0)
             break;
         if (unlikely (errno != EAGAIN))
@@ -886,7 +886,7 @@ bool zmq::socket_base_t::xhas_out ()
     return false;
 }
 
-int zmq::socket_base_t::xsend (msg_t *, int)
+int zmq::socket_base_t::xsend (msg_t *)
 {
     errno = ENOTSUP;
     return -1;
diff --git a/src/socket_base.hpp b/src/socket_base.hpp
index 5c688269..ee0af242 100644
--- a/src/socket_base.hpp
+++ b/src/socket_base.hpp
@@ -133,7 +133,7 @@ namespace zmq
 
         //  The default implementation assumes that send is not supported.
         virtual bool xhas_out ();
-        virtual int xsend (zmq::msg_t *msg_, int flags_);
+        virtual int xsend (zmq::msg_t *msg_);
 
         //  The default implementation assumes that recv in not supported.
         virtual bool xhas_in ();
diff --git a/src/sub.cpp b/src/sub.cpp
index 05f3015b..7a72bb1f 100644
--- a/src/sub.cpp
+++ b/src/sub.cpp
@@ -58,7 +58,7 @@ int zmq::sub_t::xsetsockopt (int option_, const void *optval_,
 
     //  Pass it further on in the stack.
     int err = 0;
-    rc = xsub_t::xsend (&msg, 0);
+    rc = xsub_t::xsend (&msg);
     if (rc != 0)
         err = errno;
     int rc2 = msg.close ();
@@ -68,7 +68,7 @@ int zmq::sub_t::xsetsockopt (int option_, const void *optval_,
     return rc;
 }
 
-int zmq::sub_t::xsend (msg_t *, int)
+int zmq::sub_t::xsend (msg_t *)
 {
     //  Overload the XSUB's send.
     errno = ENOTSUP;
diff --git a/src/sub.hpp b/src/sub.hpp
index ee66d7df..fdda7017 100644
--- a/src/sub.hpp
+++ b/src/sub.hpp
@@ -42,7 +42,7 @@ namespace zmq
     protected:
 
         int xsetsockopt (int option_, const void *optval_, size_t optvallen_);
-        int xsend (zmq::msg_t *msg_, int flags_);
+        int xsend (zmq::msg_t *msg_);
         bool xhas_out ();
 
     private:
diff --git a/src/xpub.cpp b/src/xpub.cpp
index e446f0f0..8b63dc5b 100644
--- a/src/xpub.cpp
+++ b/src/xpub.cpp
@@ -115,7 +115,7 @@ void zmq::xpub_t::mark_as_matching (pipe_t *pipe_, void *arg_)
     self->dist.match (pipe_);
 }
 
-int zmq::xpub_t::xsend (msg_t *msg_, int flags_)
+int zmq::xpub_t::xsend (msg_t *msg_)
 {
     bool msg_more = msg_->flags () & msg_t::more ? true : false;
 
@@ -126,7 +126,7 @@ int zmq::xpub_t::xsend (msg_t *msg_, int flags_)
 
     //  Send the message to all the pipes that were marked as matching
     //  in the previous step.
-    int rc = dist.send_to_matching (msg_, flags_);
+    int rc = dist.send_to_matching (msg_);
     if (rc != 0)
         return rc;
 
diff --git a/src/xpub.hpp b/src/xpub.hpp
index 045253d5..954b26be 100644
--- a/src/xpub.hpp
+++ b/src/xpub.hpp
@@ -48,7 +48,7 @@ namespace zmq
 
         //  Implementations of virtual functions from socket_base_t.
         void xattach_pipe (zmq::pipe_t *pipe_, bool icanhasall_ = false);
-        int xsend (zmq::msg_t *msg_, int flags_);
+        int xsend (zmq::msg_t *msg_);
         bool xhas_out ();
         int xrecv (zmq::msg_t *msg_, int flags_);
         bool xhas_in ();
diff --git a/src/xsub.cpp b/src/xsub.cpp
index 7f5f6fdc..7126c563 100644
--- a/src/xsub.cpp
+++ b/src/xsub.cpp
@@ -82,7 +82,7 @@ void zmq::xsub_t::xhiccuped (pipe_t *pipe_)
     pipe_->flush ();
 }
 
-int zmq::xsub_t::xsend (msg_t *msg_, int flags_)
+int zmq::xsub_t::xsend (msg_t *msg_)
 {
     size_t size = msg_->size ();
     unsigned char *data = (unsigned char*) msg_->data ();
@@ -100,11 +100,11 @@ int zmq::xsub_t::xsend (msg_t *msg_, int flags_)
 	// doing it here as well breaks ZMQ_XPUB_VERBOSE
 	// when there are forwarding devices involved
         subscriptions.add (data + 1, size - 1);
-        return dist.send_to_all (msg_, flags_);
+        return dist.send_to_all (msg_);
     }
     else {
         if (subscriptions.rm (data + 1, size - 1))
-            return dist.send_to_all (msg_, flags_);
+            return dist.send_to_all (msg_);
     }
 
     int rc = msg_->close ();
diff --git a/src/xsub.hpp b/src/xsub.hpp
index 6182a3f3..bc11a74e 100644
--- a/src/xsub.hpp
+++ b/src/xsub.hpp
@@ -46,7 +46,7 @@ namespace zmq
 
         //  Overloads of functions from socket_base_t.
         void xattach_pipe (zmq::pipe_t *pipe_, bool icanhasall_);
-        int xsend (zmq::msg_t *msg_, int flags_);
+        int xsend (zmq::msg_t *msg_);
         bool xhas_out ();
         int xrecv (zmq::msg_t *msg_, int flags_);
         bool xhas_in ();