ffi-rzmq 0.9.3 → 0.9.6

data/lib/ffi-rzmq/libzmq.rb

@@ -1,7 +1,7 @@
 module ZMQ
 
   # Wraps the libzmq library and attaches to the functions that are
-  # common across the 2.x, 3.x and 4.x APIs.
+  # common across the 2.x and 3.x APIs.
   #
   module LibZMQ
     extend FFI::Library
@@ -10,18 +10,32 @@ module ZMQ
       # bias the library discovery to a path inside the gem first, then
       # to the usual system paths
       inside_gem = File.join(File.dirname(__FILE__), '..', '..', 'ext')
+      if FFI::Platform::IS_WINDOWS
+        local_path=ENV['PATH'].split(';')
+      else
+        local_path=ENV['PATH'].split(':')
+      end
       ZMQ_LIB_PATHS = [
-      inside_gem, '/usr/local/lib', '/opt/local/lib', '/usr/local/homebrew/lib', '/usr/lib64'
+        inside_gem, '/usr/local/lib', '/opt/local/lib', '/usr/local/homebrew/lib', '/usr/lib64'
       ].map{|path| "#{path}/libzmq.#{FFI::Platform::LIBSUFFIX}"}
       ffi_lib(ZMQ_LIB_PATHS + %w{libzmq})
     rescue LoadError
-      STDERR.puts "Unable to load this gem. The libzmq library (or DLL) could not be found."
-      STDERR.puts "If this is a Windows platform, make sure libzmq.dll is on the PATH."
-      STDERR.puts "For non-Windows platforms, make sure libzmq is located in this search path:"
-      STDERR.puts ZMQ_LIB_PATHS.inspect
-      exit 255
+      if ZMQ_LIB_PATHS.push(*local_path).any? {|path|
+        File.file? File.join(path, "libzmq.#{FFI::Platform::LIBSUFFIX}")}
+        warn "Unable to load this gem. The libzmq library exists, but cannot be loaded."
+        warn "If this is Windows:"
+        warn "-  Check that you have MSVC runtime installed or statically linked"
+        warn "-  Check that your DLL is compiled for #{FFI::Platform::ADDRESS_SIZE} bit"
+      else
+        warn "Unable to load this gem. The libzmq library (or DLL) could not be found."
+        warn "If this is a Windows platform, make sure libzmq.dll is on the PATH."
+        warn "If the DLL was built with mingw, make sure the other two dependent DLLs,"
+        warn "libgcc_s_sjlj-1.dll and libstdc++6.dll, are also on the PATH."
+        warn "For non-Windows platforms, make sure libzmq is located in this search path:"
+        warn ZMQ_LIB_PATHS.inspect
+      end
+      raise LoadError, "The libzmq library (or DLL) could not be loaded"
     end
-
     # Size_t not working properly on Windows
     find_type(:size_t) rescue typedef(:ulong, :size_t)
 
@@ -38,20 +52,14 @@ module ZMQ
     # otherwise the runtime hangs (and requires a kill -9 to terminate)
     #
     @blocking = true
-    attach_function :zmq_init, [:int], :pointer
-    @blocking = true
-    attach_function :zmq_socket, [:pointer, :int], :pointer
-    @blocking = true
-    attach_function :zmq_term, [:pointer], :int
+    attach_function :zmq_version, [:pointer, :pointer, :pointer], :void
     @blocking = true
     attach_function :zmq_errno, [], :int
     @blocking = true
     attach_function :zmq_strerror, [:int], :pointer
-    @blocking = true
-    attach_function :zmq_version, [:pointer, :pointer, :pointer], :void
 
     def self.version
-      unless @version
+      if @version.nil?
         major = FFI::MemoryPointer.new :int
         minor = FFI::MemoryPointer.new :int
         patch = FFI::MemoryPointer.new :int
@@ -64,12 +72,15 @@ module ZMQ
 
     def self.version2?() version[:major] == 2 && version[:minor] >= 1  end
 
-    def self.version3?() version[:major] == 3 && version[:minor] >= 1 end
-
-    def self.version4?() version[:major] == 4 end
+    def self.version3?() version[:major] == 3 && version[:minor] >= 2 end
 
+    # Context initialization and destruction
+    @blocking = true
+    attach_function :zmq_init, [:int], :pointer
+    @blocking = true
+    attach_function :zmq_term, [:pointer], :int
 
-    # Message api
+    # Message API
     @blocking = true
     attach_function :zmq_msg_init, [:pointer], :int
     @blocking = true
@@ -96,27 +107,41 @@ module ZMQ
       :vsm_data, [:uint8, 30]
     end # class Msg
 
-    # Socket api
+    # Socket API
+    @blocking = true
+    attach_function :zmq_socket, [:pointer, :int], :pointer
     @blocking = true
     attach_function :zmq_setsockopt, [:pointer, :int, :pointer, :int], :int
     @blocking = true
+    attach_function :zmq_getsockopt, [:pointer, :int, :pointer, :pointer], :int
+    @blocking = true
     attach_function :zmq_bind, [:pointer, :string], :int
     @blocking = true
     attach_function :zmq_connect, [:pointer, :string], :int
     @blocking = true
     attach_function :zmq_close, [:pointer], :int
 
-    # Poll api
+    # Device API
+    @blocking = true
+    attach_function :zmq_device, [:int, :pointer, :pointer], :int
+
+    # Poll API
     @blocking = true
     attach_function :zmq_poll, [:pointer, :int, :long], :int
 
     module PollItemLayout
       def self.included(base)
+        if FFI::Platform::IS_WINDOWS && FFI::Platform::ADDRESS_SIZE==64
+          # On Windows, zmq.h defines fd as a SOCKET, which is 64 bits on x64.
+          fd_type=:uint64
+        else
+          fd_type=:int
+        end
         base.class_eval do
           layout :socket,  :pointer,
-          :fd,    :int,
-          :events, :short,
-          :revents, :short
+            :fd,    fd_type,
+            :events, :short,
+            :revents, :short
         end
       end
     end # module PollItemLayout
@@ -125,7 +150,7 @@ module ZMQ
       include PollItemLayout
 
       def socket() self[:socket]; end
-      
+
       def fd() self[:fd]; end
 
       def readable?
@@ -157,13 +182,9 @@ module ZMQ
     module LibZMQ
       # Socket api
       @blocking = true
-      attach_function :zmq_getsockopt, [:pointer, :int, :pointer, :pointer], :int
-      @blocking = true
       attach_function :zmq_recv, [:pointer, :pointer, :int], :int
       @blocking = true
       attach_function :zmq_send, [:pointer, :pointer, :int], :int
-      @blocking = true
-      attach_function :zmq_device, [:int, :pointer, :pointer], :int
     end
   end
 
@@ -173,9 +194,37 @@ module ZMQ
   if LibZMQ.version3?
 
     module LibZMQ
-      # Socket api
+      # New Context API
+      @blocking = true
+      attach_function :zmq_ctx_new, [], :pointer
+      @blocking = true
+      attach_function :zmq_ctx_destroy, [:pointer], :int
+      @blocking = true
+      attach_function :zmq_ctx_set, [:pointer, :int, :int], :int
+      @blocking = true
+      attach_function :zmq_ctx_get, [:pointer, :int], :int
+
+      # Message API
       @blocking = true
-      attach_function :zmq_getsockopt, [:pointer, :int, :pointer, :pointer], :int
+      attach_function :zmq_msg_send, [:pointer, :pointer, :int], :int
+      @blocking = true
+      attach_function :zmq_msg_recv, [:pointer, :pointer, :int], :int
+      @blocking = true
+      attach_function :zmq_msg_more, [:pointer], :int
+      @blocking = true
+      attach_function :zmq_msg_get, [:pointer, :int], :int
+      @blocking = true
+      attach_function :zmq_msg_set, [:pointer, :int, :int], :int
+      
+      # Monitoring API
+      @blocking = true
+      attach_function :zmq_ctx_set_monitor, [:pointer, :pointer], :int
+
+      # Socket API
+      @blocking = true
+      attach_function :zmq_unbind, [:pointer, :string], :int
+      @blocking = true
+      attach_function :zmq_disconnect, [:pointer, :string], :int
       @blocking = true
       attach_function :zmq_recvmsg, [:pointer, :pointer, :int], :int
       @blocking = true
@@ -184,6 +233,33 @@ module ZMQ
       attach_function :zmq_sendmsg, [:pointer, :pointer, :int], :int
       @blocking = true
       attach_function :zmq_send, [:pointer, :pointer, :size_t, :int], :int
+      
+      module EventDataLayout
+        def self.included(base)
+          base.class_eval do
+            layout :addr,  :string,
+            :field2,    :int
+          end
+        end
+      end # module EventDataLayout
+
+      class EventData < FFI::Struct
+        include EventDataLayout
+
+        def addr() self[:addr]; end
+        alias :address :addr
+
+        def fd() self[:field2]; end
+        alias :err :fd
+        alias :interval :fd
+
+        def inspect
+          "addr [#{addr}], fd [#{fd}], field2 [#{fd}]"
+        end
+
+        def to_s; inspect; end
+      end # class EventData
+      
     end
   end
 
@@ -194,8 +270,7 @@ module ZMQ
   unless LibZMQ.version2? || LibZMQ.version3?
     hash = LibZMQ.version
     version = "#{hash[:major]}.#{hash[:minor]}.#{hash[:patch]}"
-    STDERR.puts "Unable to load this gem. The libzmq version #{version} is incompatible with ffi-rzmq."
-    exit 255
+    raise LoadError, "The libzmq version #{version} is incompatible with ffi-rzmq."
   end
 
 end # module ZMQ

data/lib/ffi-rzmq/message.rb

@@ -30,7 +30,7 @@ module ZMQ
   #
   #  received_message = Message.create
   #  if received_message
-  #    rc = socket.recv(received_message)
+  #    rc = socket.recvmsg(received_message)
   #    if ZMQ::Util.resultcode_ok?(rc)
   #      puts "Message contained: #{received_message.copy_out_string}"
   #    else
@@ -84,7 +84,6 @@ module ZMQ
   #  puts "value1 is #{message.value1}"
   #
   class Message
-    include ZMQ::Util
     
     # Recommended way to create a standard message. A Message object is 
     # returned upon success, nil when allocation fails.
@@ -199,6 +198,28 @@ module ZMQ
     def self.msg_size() @msg_size; end
 
   end # class Message
+  
+  if LibZMQ.version3?
+    class Message
+      # Version3 only
+      #
+      def get(property)
+        LibZMQ.zmq_msg_get(@pointer, property)
+      end
+      
+      # Version3 only
+      #
+      # Returns true if this message has additional parts coming.
+      #
+      def more?
+        Util.resultcode_ok?(get(MORE))
+      end
+      
+      def set(property, value)
+        LibZMQ.zmq_msg_set(@pointer, property, value)
+      end
+    end
+  end
 
 
 

data/lib/ffi-rzmq/poll.rb

@@ -2,7 +2,6 @@
 module ZMQ
 
   class Poller
-    include ZMQ::Util
 
     attr_reader :readables, :writables
 
@@ -15,7 +14,7 @@ module ZMQ
     end
 
     # Checks each registered socket for selectability based on the poll items'
-    # registered +events+. Will block for up to +timeout+ milliseconds
+    # registered +events+. Will block for up to +timeout+ milliseconds.
     # A millisecond is 1/1000 of a second, so to block for 1 second
     # pass the value "1000" to #poll.
     #
@@ -100,7 +99,7 @@ module ZMQ
 
       item = @items.get(@sockets.index(sock))
 
-      if item
+      if item && (item[:events] & events) > 0
         # change the value in place
         item[:events] ^= events
 
@@ -139,11 +138,11 @@ module ZMQ
     # when a socket has been deregistered and has no more events
     # registered anywhere.
     #
+    # Can also be called directly to remove the socket from the polling
+    # array.
+    #
     def delete sock
-      removed_readable = deregister_readable sock
-      removed_writable = deregister_writable sock
-
-      unless (removed_readable || removed_writable) || (size = @sockets.size).zero?
+      unless (size = @sockets.size).zero?
         @sockets.delete_if { |socket| socket.socket.address == sock.socket.address }
         socket_deleted = size != @sockets.size
 
@@ -154,8 +153,7 @@ module ZMQ
         socket_deleted && item_deleted && raw_deleted
         
       else
-        # return result of deregistration
-        removed_readable || removed_writable
+        false
       end
     end
 

data/lib/ffi-rzmq/socket.rb

@@ -2,7 +2,6 @@
 module ZMQ
 
   module CommonSocketBehavior
-    include ZMQ::Util
 
     attr_reader :socket, :name
 
@@ -82,6 +81,7 @@ module ZMQ
         raise ContextError.new 'zmq_socket', 0, ETERM, "Context pointer was null"
       end
 
+      @longlong_cache = @int_cache = nil
       @more_parts_array = []
       @option_lookup = []
       populate_option_lookup
@@ -157,12 +157,12 @@ module ZMQ
     #
     #  message_parts = []
     #  message = Message.new
-    #  rc = socket.recv(message)
+    #  rc = socket.recvmsg(message)
     #  if ZMQ::Util.resultcode_ok?(rc)
     #    message_parts << message
     #    while more_parts?
     #      message = Message.new
-    #      rc = socket.recv(message)
+    #      rc = socket.recvmsg(message)
     #      message_parts.push(message) if resulcode_ok?(rc)
     #    end
     #  end
@@ -183,7 +183,7 @@ module ZMQ
 
     # Connects the socket to an +address+.
     #
-    #  socket.connect("tcp://127.0.0.1:5555")
+    #  rc = socket.connect("tcp://127.0.0.1:5555")
     #
     def connect address
       rc = LibZMQ.zmq_connect @socket, address
@@ -210,6 +210,238 @@ module ZMQ
       end
     end
 
+    # Queues the message for transmission. Message is assumed to conform to the
+    # same public API as #Message.
+    #
+    # +flags+ may take two values:
+    # * 0 (default) - blocking operation
+    # * ZMQ::NonBlocking - non-blocking operation
+    # * ZMQ::SNDMORE - this message is part of a multi-part message
+    #
+    # Returns 0 when the message was successfully enqueued.
+    # Returns -1 under two conditions.
+    # 1. The message could not be enqueued
+    # 2. When +flags+ is set with ZMQ::NonBlocking and the socket returned EAGAIN.
+    #
+    # With a -1 return code, the user must check ZMQ.errno to determine the
+    # cause.
+    #
+    def sendmsg message, flags = 0
+      __sendmsg__(@socket, message.address, flags)
+    end
+
+    # Helper method to make a new #Message instance out of the +string+ passed
+    # in for transmission.
+    #
+    # +flags+ may be ZMQ::NonBlocking and ZMQ::SNDMORE.
+    #
+    # Returns 0 when the message was successfully enqueued.
+    # Returns -1 under two conditions.
+    # 1. The message could not be enqueued
+    # 2. When +flags+ is set with ZMQ::NonBlocking and the socket returned EAGAIN.
+    #
+    # With a -1 return code, the user must check ZMQ.errno to determine the
+    # cause.
+    #
+    def send_string string, flags = 0
+      message = Message.new string
+      send_and_close message, flags
+    end
+
+    # Send a sequence of strings as a multipart message out of the +parts+
+    # passed in for transmission. Every element of +parts+ should be
+    # a String.
+    #
+    # +flags+ may be ZMQ::NonBlocking.
+    #
+    # Returns 0 when the messages were successfully enqueued.
+    # Returns -1 under two conditions.
+    # 1. A message could not be enqueued
+    # 2. When +flags+ is set with ZMQ::NonBlocking and the socket returned EAGAIN.
+    #
+    # With a -1 return code, the user must check ZMQ.errno to determine the
+    # cause.
+    #
+    def send_strings parts, flags = 0
+      return -1 if !parts || parts.empty?
+      flags = NonBlocking if dontwait?(flags)
+
+      parts[0..-2].each do |part|
+        rc = send_string part, (flags | ZMQ::SNDMORE)
+        return rc unless Util.resultcode_ok?(rc)
+      end
+
+      send_string parts[-1], flags
+    end
+
+    # Send a sequence of messages as a multipart message out of the +parts+
+    # passed in for transmission. Every element of +parts+ should be
+    # a Message (or subclass).
+    #
+    # +flags+ may be ZMQ::NonBlocking.
+    #
+    # Returns 0 when the messages were successfully enqueued.
+    # Returns -1 under two conditions.
+    # 1. A message could not be enqueued
+    # 2. When +flags+ is set with ZMQ::NonBlocking and the socket returned EAGAIN.
+    #
+    # With a -1 return code, the user must check ZMQ.errno to determine the
+    # cause.
+    #
+    def sendmsgs parts, flags = 0
+      return -1 if !parts || parts.empty?
+      flags = NonBlocking if dontwait?(flags)
+
+      parts[0..-2].each do |part|
+        rc = sendmsg part, (flags | ZMQ::SNDMORE)
+        return rc unless Util.resultcode_ok?(rc)
+      end
+
+      sendmsg parts[-1], flags
+    end
+
+    # Sends a message. This will automatically close the +message+ for both successful
+    # and failed sends.
+    #
+    # Returns 0 when the message was successfully enqueued.
+    # Returns -1 under two conditions.
+    # 1. The message could not be enqueued
+    # 2. When +flags+ is set with ZMQ::NonBlocking and the socket returned EAGAIN.
+    #
+    # With a -1 return code, the user must check ZMQ.errno to determine the
+    # cause.
+    #
+    def send_and_close message, flags = 0
+      rc = sendmsg message, flags
+      message.close
+      rc
+    end
+
+    # Dequeues a message from the underlying queue. By default, this is a blocking operation.
+    #
+    # +flags+ may take two values:
+    #  0 (default) - blocking operation
+    #  ZMQ::NonBlocking - non-blocking operation
+    #
+    # Returns 0 when the message was successfully dequeued.
+    # Returns -1 under two conditions.
+    # 1. The message could not be dequeued
+    # 2. When +flags+ is set with ZMQ::NonBlocking and the socket returned EAGAIN.
+    #
+    # With a -1 return code, the user must check ZMQ.errno to determine the
+    # cause.
+    #
+    # The application code is responsible for handling the +message+ object lifecycle
+    # when #recv returns an error code.
+    #
+    def recvmsg message, flags = 0
+      #LibZMQ.zmq_recvmsg @socket, message.address, flags
+      __recvmsg__(@socket, message.address, flags)
+    end
+
+    # Helper method to make a new #Message instance and convert its payload
+    # to a string.
+    #
+    # +flags+ may be ZMQ::NonBlocking.
+    #
+    # Returns 0 when the message was successfully dequeued.
+    # Returns -1 under two conditions.
+    # 1. The message could not be dequeued
+    # 2. When +flags+ is set with ZMQ::NonBlocking and the socket returned EAGAIN.
+    #
+    # With a -1 return code, the user must check ZMQ.errno to determine the
+    # cause.
+    #
+    # The application code is responsible for handling the +message+ object lifecycle
+    # when #recv returns an error code.
+    #
+    def recv_string string, flags = 0
+      message = @receiver_klass.new
+      rc = recvmsg message, flags
+      string.replace(message.copy_out_string) if Util.resultcode_ok?(rc)
+      message.close
+      rc
+    end
+
+    # Receive a multipart message as a list of strings.
+    #
+    # +flag+ may be ZMQ::NonBlocking. Any other flag will be
+    # removed.
+    #
+    def recv_strings list, flag = 0
+      array = []
+      rc = recvmsgs array, flag
+
+      if Util.resultcode_ok?(rc)
+        array.each do |message|
+          list << message.copy_out_string
+          message.close
+        end
+      end
+
+      rc
+    end
+
+    # Receive a multipart message as an array of objects
+    # (by default these are instances of Message).
+    #
+    # +flag+ may be ZMQ::NonBlocking. Any other flag will be
+    # removed.
+    #
+    def recvmsgs list, flag = 0
+      flag = NonBlocking if dontwait?(flag)
+
+      message = @receiver_klass.new
+      rc = recvmsg message, flag
+
+      if Util.resultcode_ok?(rc)
+        list << message
+
+        # check rc *first*; necessary because the call to #more_parts? can reset
+        # the zmq_errno to a weird value, so the zmq_errno that was set on the
+        # call to #recv gets lost
+        while Util.resultcode_ok?(rc) && more_parts?
+          message = @receiver_klass.new
+          rc = recvmsg message, flag
+
+          if Util.resultcode_ok?(rc)
+            list << message
+          else
+            message.close
+            list.each { |msg| msg.close }
+            list.clear
+          end
+        end
+      else
+        message.close
+      end
+
+      rc
+    end
+
+    # Should only be used for XREQ, XREP, DEALER and ROUTER type sockets. Takes
+    # a +list+ for receiving the message body parts and a +routing_envelope+
+    # for receiving the message parts comprising the 0mq routing information.
+    #
+    def recv_multipart list, routing_envelope, flag = 0
+      parts = []
+      rc = recvmsgs parts, flag
+
+      if Util.resultcode_ok?(rc)
+        routing = true
+        parts.each do |part|
+          if routing
+            routing_envelope << part
+            routing = part.size > 0
+          else
+            list << part
+          end
+        end
+      end
+
+      rc
+    end
+
 
     private
 
@@ -217,7 +449,7 @@ module ZMQ
       # a small optimization so we only have to determine the option
       # type a single time; gives approx 5% speedup to do it this way.
       option_type = @option_lookup[name]
-      
+
       value, length = sockopt_buffers option_type
 
       rc = LibZMQ.zmq_getsockopt @socket, name, value, length
@@ -276,14 +508,14 @@ module ZMQ
         @int_cache
       end
     end
-    
+
     def populate_option_lookup
       # integer options
-      [EVENTS, LINGER, RECONNECT_IVL, FD, TYPE, BACKLOG].each { |option| @option_lookup[option] = 0 }
+      [EVENTS, LINGER, RCVTIMEO, SNDTIMEO, RECONNECT_IVL, FD, TYPE, BACKLOG].each { |option| @option_lookup[option] = 0 }
 
       # long long options
       [RCVMORE, AFFINITY].each { |option| @option_lookup[option] = 1 }
-      
+
       # string options
       [SUBSCRIBE, UNSUBSCRIBE].each { |option| @option_lookup[option] = 2 }
     end
@@ -292,6 +524,11 @@ module ZMQ
       @longlong_cache = nil
       @int_cache = nil
     end
+
+    def dontwait?(flags)
+      (NonBlocking & flags) == NonBlocking
+    end
+    alias :noblock? :dontwait?
   end # module CommonSocketBehavior
 
 
@@ -313,14 +550,14 @@ module ZMQ
 
 
     private
-    
+
     def populate_option_lookup
       super()
-      
+
       # string options
       [IDENTITY].each { |option| @option_lookup[option] = 2 }
     end
-    
+
   end # module IdentitySupport
 
 
@@ -380,280 +617,26 @@ module ZMQ
         rc
       end
 
-      # Queues the message for transmission. Message is assumed to conform to the
-      # same public API as #Message.
-      #
-      # +flags+ may take two values:
-      # * 0 (default) - blocking operation
-      # * ZMQ::NOBLOCK - non-blocking operation
-      # * ZMQ::SNDMORE - this message is part of a multi-part message
-      #
-      # Returns 0 when the message was successfully enqueued.
-      # Returns -1 under two conditions.
-      # 1. The message could not be enqueued
-      # 2. When +flags+ is set with ZMQ::NOBLOCK and the socket returned EAGAIN.
-      #
-      # With a -1 return code, the user must check ZMQ.errno to determine the
-      # cause.
-      #
-      # The application code is responsible for handling the +message+ object
-      # lifecycle when #send returns. Regardless of the return code, the user
-      # is responsible for calling message.close to free the memory in use.
-      #
-      def send message, flags = 0
-        LibZMQ.zmq_send @socket, message.address, flags
-      end
-
-      # Helper method to make a new #Message instance out of the +message_string+ passed
-      # in for transmission.
-      #
-      # +flags+ may be ZMQ::NOBLOCK.
-      #
-      # Returns 0 when the message was successfully enqueued.
-      # Returns -1 under two conditions.
-      # 1. The message could not be enqueued
-      # 2. When +flags+ is set with ZMQ::NOBLOCK and the socket returned EAGAIN.
-      #
-      # With a -1 return code, the user must check ZMQ.errno to determine the
-      # cause.
-      #
-      def send_string message_string, flags = 0
-        message = Message.new message_string
-        send_and_close message, flags
-      end
-
-      # Send a sequence of strings as a multipart message out of the +parts+
-      # passed in for transmission. Every element of +parts+ should be
-      # a String.
-      #
-      # +flags+ may be ZMQ::NOBLOCK.
-      #
-      # Returns 0 when the message was successfully enqueued.
-      # Returns -1 under two conditions.
-      # 1. The message could not be enqueued
-      # 2. When +flags+ is set with ZMQ::NOBLOCK and the socket returned EAGAIN.
-      #
-      # With a -1 return code, the user must check ZMQ.errno to determine the
-      # cause.
-      #
-      def send_strings parts, flags = 0
-        return -1 if !parts || parts.empty?
-
-        parts[0..-2].each do |part|
-          rc = send_string part, flags | ZMQ::SNDMORE
-          return rc unless Util.resultcode_ok?(rc)
-        end
-
-        send_string parts[-1], flags
-      end
-
-      # Send a sequence of messages as a multipart message out of the +parts+
-      # passed in for transmission. Every element of +parts+ should be
-      # a Message (or subclass).
-      #
-      # +flags+ may be ZMQ::NOBLOCK.
-      #
-      # Returns 0 when the message was successfully enqueued.
-      # Returns -1 under two conditions.
-      # 1. The message could not be enqueued
-      # 2. When +flags+ is set with ZMQ::NOBLOCK and the socket returned EAGAIN.
-      #
-      # With a -1 return code, the user must check ZMQ.errno to determine the
-      # cause.
-      #
-      def sendmsgs parts, flags = 0
-        return -1 if !parts || parts.empty?
-
-        parts[0..-2].each do |part|
-          rc = send part, flags | ZMQ::SNDMORE
-          return rc unless Util.resultcode_ok?(rc)
-        end
-
-        send parts[-1], flags
-      end
-
-      # Sends a message. This will automatically close the +message+ for both successful
-      # and failed sends.
-      #
-      # Returns 0 when the message was successfully enqueued.
-      # Returns -1 under two conditions.
-      # 1. The message could not be enqueued
-      # 2. When +flags+ is set with ZMQ::NOBLOCK and the socket returned EAGAIN.
-      #
-      # With a -1 return code, the user must check ZMQ.errno to determine the
-      # cause.
-      #
-      def send_and_close message, flags = 0
-        rc = send message, flags
-        message.close
-        rc
-      end
-
-      # Dequeues a message from the underlying queue. By default, this is a blocking operation.
-      #
-      # +flags+ may take two values:
-      #  0 (default) - blocking operation
-      #  ZMQ::NOBLOCK - non-blocking operation
-      #
-      # Returns 0 when the message was successfully dequeued.
-      # Returns -1 under two conditions.
-      # 1. The message could not be dequeued
-      # 2. When +flags+ is set with ZMQ::NOBLOCK and the socket returned EAGAIN.
-      #
-      # With a -1 return code, the user must check ZMQ.errno to determine the
-      # cause.
-      #
-      # The application code is responsible for handling the +message+ object lifecycle
-      # when #recv returns an error code.
-      #
-      def recv message, flags = 0
-        LibZMQ.zmq_recv @socket, message.address, flags
-      end
-
-      # Converts the received message to a string and replaces the +string+ arg
-      # contents.
-      #
-      # +string+ should be an empty string, .e.g. ''
-      # +flags+ may be ZMQ::NOBLOCK.
-      #
-      # Returns 0 when the message was successfully dequeued.
-      # Returns -1 under two conditions.
-      # 1. The message could not be dequeued
-      # 2. When +flags+ is set with ZMQ::NOBLOCK and the socket returned EAGAIN.
-      #
-      # With a -1 return code, the user must check ZMQ.errno to determine the
-      # cause.
-      #
-      def recv_string string, flags = 0
-        message = @receiver_klass.new
-        rc = recv message, flags
-        string.replace(message.copy_out_string) if Util.resultcode_ok?(rc)
-        message.close
-        rc
-      end
-
-      # Receive a multipart message as a list of strings.
-      #
-      # +list+ should be an object that responds to #append or #<< so received
-      # strings can be appended to it
-      # +flag+ may be ZMQ::NOBLOCK. Any other flag will be removed
-      #
-      # Returns 0 when all messages were successfully dequeued.
-      # Returns -1 under two conditions.
-      # 1. A message could not be dequeued
-      # 2. When +flags+ is set with ZMQ::NOBLOCK and the socket returned EAGAIN.
-      #
-      # With a -1 return code, the user must check ZMQ.errno to determine the
-      # cause. Also, the +list+ will not be modified when there was an error.
-      #
-      def recv_strings list, flag = 0
-        array = []
-        rc = recvmsgs array, flag
 
-        if Util.resultcode_ok?(rc)
-          array.each do |message|
-            list << message.copy_out_string
-            message.close
-          end
-        end
-
-        rc
-      end
-
-      # Receive a multipart message as an array of objects
-      # (by default these are instances of Message).
-      #
-      # +list+ should be an object that responds to #append or #<< so received
-      # messages can be appended to it
-      # +flag+ may be ZMQ::NOBLOCK. Any other flag will be
-      # removed.
-      #
-      # Returns 0 when all messages were successfully dequeued.
-      # Returns -1 under two conditions.
-      # 1. A message could not be dequeued
-      # 2. When +flags+ is set with ZMQ::NOBLOCK and the socket returned EAGAIN.
-      #
-      # With a -1 return code, the user must check ZMQ.errno to determine the
-      # cause. Also, the +list+ will not be modified when there was an error.
-      #
-      def recvmsgs list, flag = 0
-        flag = NOBLOCK if noblock?(flag)
-
-        message = @receiver_klass.new
-        rc = recv message, flag
-
-        if Util.resultcode_ok?(rc)
-          list << message
-
-          # check rc *first*; necessary because the call to #more_parts? can reset
-          # the zmq_errno to a weird value, so the zmq_errno that was set on the
-          # call to #recv gets lost
-          while Util.resultcode_ok?(rc) && more_parts?
-            message = @receiver_klass.new
-            rc = recv message, flag
-
-            if Util.resultcode_ok?(rc)
-              list << message
-            else
-              message.close
-              list.each { |msg| msg.close }
-              list.clear
-            end
-          end
-        else
-          message.close
-        end
+      private
 
-        rc
+      def __sendmsg__(socket, address, flags)
+        LibZMQ.zmq_send(socket, address, flags)
       end
 
-      # Should only be used for XREQ, XREP, DEALER and ROUTER type sockets. Takes
-      # a +list+ for receiving the message body parts and a +routing_envelope+
-      # for receiving the message parts comprising the 0mq routing information.
-      #
-      # Returns 0 when all messages were successfully dequeued.
-      # Returns -1 under two conditions.
-      # 1. A message could not be dequeued
-      # 2. When +flags+ is set with ZMQ::NOBLOCK and the socket returned EAGAIN.
-      #
-      # With a -1 return code, the user must check ZMQ.errno to determine the
-      # cause. Also, the +list+ *may* be modified when there was an error.
-      #
-      def recv_multipart list, routing_envelope, flag = 0
-        parts = []
-        rc = recvmsgs parts, flag
-
-        if Util.resultcode_ok?(rc)
-          routing = true
-          parts.each do |part|
-            if routing
-              routing_envelope << part
-              routing = part.size > 0
-            else
-              list << part
-            end
-          end
-        end
-
-        rc
+      def __recvmsg__(socket, address, flags)
+        LibZMQ.zmq_recv(socket, address, flags)
       end
 
+      def populate_option_lookup
+        super()
 
-      private
+        # integer options
+        [RECONNECT_IVL_MAX].each { |option| @option_lookup[option] = 0 }
 
-      def noblock? flags
-        (NOBLOCK & flags) == NOBLOCK
+        # long long options
+        [HWM, SWAP, RATE, RECOVERY_IVL, RECOVERY_IVL_MSEC, MCAST_LOOP, SNDBUF, RCVBUF].each { |option| @option_lookup[option] = 1 }
       end
-    
-    def populate_option_lookup
-      super()
-      
-      # integer options
-      [RECONNECT_IVL_MAX].each { |option| @option_lookup[option] = 0 }
-
-      # long long options
-      [HWM, SWAP, RATE, RECOVERY_IVL, RECOVERY_IVL_MSEC, MCAST_LOOP, SNDBUF, RCVBUF].each { |option| @option_lookup[option] = 1 }
-    end
 
       # these finalizer-related methods cannot live in the CommonSocketBehavior
       # module; they *must* be in the class definition directly
@@ -702,6 +685,7 @@ module ZMQ
       #  ZMQ::RECONNECT_IVL - integer measured in milliseconds
       #  ZMQ::BACKLOG - integer
       #  ZMQ::RECOVER_IVL_MSEC - integer measured in milliseconds
+      #  ZMQ::IPV4ONLY - integer
       #
       # Returns 0 when the operation completed successfully.
       # Returns -1 when this operation failed.
@@ -724,263 +708,45 @@ module ZMQ
 
         rc
       end
-
-      # Queues the message for transmission. Message is assumed to conform to the
-      # same public API as #Message.
-      #
-      # +flags+ may take two values:
-      # * 0 (default) - blocking operation
-      # * ZMQ::DONTWAIT - non-blocking operation
-      # * ZMQ::SNDMORE - this message is part of a multi-part message
-      #
-      # Returns 0 when the message was successfully enqueued.
-      # Returns -1 under two conditions.
-      # 1. The message could not be enqueued
-      # 2. When +flags+ is set with ZMQ::DONTWAIT and the socket returned EAGAIN.
-      #
-      # With a -1 return code, the user must check ZMQ.errno to determine the
-      # cause.
-      #
-      def sendmsg message, flags = 0
-        LibZMQ.zmq_sendmsg @socket, message.address, flags
-      end
-
-      # Helper method to make a new #Message instance out of the +string+ passed
-      # in for transmission.
-      #
-      # +flags+ may be ZMQ::DONTWAIT and ZMQ::SNDMORE.
-      #
-      # Returns 0 when the message was successfully enqueued.
-      # Returns -1 under two conditions.
-      # 1. The message could not be enqueued
-      # 2. When +flags+ is set with ZMQ::DONTWAIT and the socket returned EAGAIN.
-      #
-      # With a -1 return code, the user must check ZMQ.errno to determine the
-      # cause.
-      #
-      def send_string string, flags = 0
-        message = Message.new string
-        send_and_close message, flags
-      end
-
-      # Send a sequence of strings as a multipart message out of the +parts+
-      # passed in for transmission. Every element of +parts+ should be
-      # a String.
-      #
-      # +flags+ may be ZMQ::DONTWAIT.
-      #
-      # Returns 0 when the messages were successfully enqueued.
-      # Returns -1 under two conditions.
-      # 1. A message could not be enqueued
-      # 2. When +flags+ is set with ZMQ::DONTWAIT and the socket returned EAGAIN.
-      #
-      # With a -1 return code, the user must check ZMQ.errno to determine the
-      # cause.
-      #
-      def send_strings parts, flags = 0
-        return -1 if !parts || parts.empty?
-        flags = DONTWAIT if dontwait?(flags)
-
-        parts[0..-2].each do |part|
-          rc = send_string part, (flags | ZMQ::SNDMORE)
-          return rc unless Util.resultcode_ok?(rc)
-        end
-
-        send_string parts[-1], flags
-      end
-
-      # Send a sequence of messages as a multipart message out of the +parts+
-      # passed in for transmission. Every element of +parts+ should be
-      # a Message (or subclass).
-      #
-      # +flags+ may be ZMQ::DONTWAIT.
-      #
-      # Returns 0 when the messages were successfully enqueued.
-      # Returns -1 under two conditions.
-      # 1. A message could not be enqueued
-      # 2. When +flags+ is set with ZMQ::DONTWAIT and the socket returned EAGAIN.
-      #
-      # With a -1 return code, the user must check ZMQ.errno to determine the
-      # cause.
-      #
-      def sendmsgs parts, flags = 0
-        return -1 if !parts || parts.empty?
-        flags = DONTWAIT if dontwait?(flags)
-
-        parts[0..-2].each do |part|
-          rc = sendmsg part, (flags | ZMQ::SNDMORE)
-          return rc unless Util.resultcode_ok?(rc)
-        end
-
-        sendmsg parts[-1], flags
-      end
-
-      # Sends a message. This will automatically close the +message+ for both successful
-      # and failed sends.
-      #
-      # Returns 0 when the message was successfully enqueued.
-      # Returns -1 under two conditions.
-      # 1. The message could not be enqueued
-      # 2. When +flags+ is set with ZMQ::DONTWAIT and the socket returned EAGAIN.
-      #
-      # With a -1 return code, the user must check ZMQ.errno to determine the
-      # cause.
-      #
-      def send_and_close message, flags = 0
-        rc = sendmsg message, flags
-        message.close
-        rc
-      end
-
-      # Dequeues a message from the underlying queue. By default, this is a blocking operation.
-      #
-      # +flags+ may take two values:
-      #  0 (default) - blocking operation
-      #  ZMQ::DONTWAIT - non-blocking operation
-      #
-      # Returns 0 when the message was successfully dequeued.
-      # Returns -1 under two conditions.
-      # 1. The message could not be dequeued
-      # 2. When +flags+ is set with ZMQ::DONTWAIT and the socket returned EAGAIN.
-      #
-      # With a -1 return code, the user must check ZMQ.errno to determine the
-      # cause.
+      
+      # Version3 only
       #
-      # The application code is responsible for handling the +message+ object lifecycle
-      # when #recv returns an error code.
+      # Disconnect the socket from the given +endpoint+.
       #
-      def recvmsg message, flags = 0
-        LibZMQ.zmq_recvmsg @socket, message.address, flags
+      def disconnect(endpoint)
+        LibZMQ.zmq_disconnect(endpoint)
       end
-
-      # Helper method to make a new #Message instance and convert its payload
-      # to a string.
-      #
-      # +flags+ may be ZMQ::DONTWAIT.
-      #
-      # Returns 0 when the message was successfully dequeued.
-      # Returns -1 under two conditions.
-      # 1. The message could not be dequeued
-      # 2. When +flags+ is set with ZMQ::DONTWAIT and the socket returned EAGAIN.
-      #
-      # With a -1 return code, the user must check ZMQ.errno to determine the
-      # cause.
+      
+      # Version3 only
       #
-      # The application code is responsible for handling the +message+ object lifecycle
-      # when #recv returns an error code.
+      # Unbind the socket from the given +endpoint+.
       #
-      def recv_string string, flags = 0
-        message = @receiver_klass.new
-        rc = recvmsg message, flags
-        string.replace(message.copy_out_string) if Util.resultcode_ok?(rc)
-        message.close
-        rc
+      def unbind(endpoint)
+        LibZMQ.zmq_unbind(endpoint)
       end
 
-      # Receive a multipart message as a list of strings.
-      #
-      # +flag+ may be ZMQ::DONTWAIT. Any other flag will be
-      # removed.
-      #
-      def recv_strings list, flag = 0
-        array = []
-        rc = recvmsgs array, flag
-
-        if Util.resultcode_ok?(rc)
-          array.each do |message|
-            list << message.copy_out_string
-            message.close
-          end
-        end
-
-        rc
-      end
 
-      # Receive a multipart message as an array of objects
-      # (by default these are instances of Message).
-      #
-      # +flag+ may be ZMQ::DONTWAIT. Any other flag will be
-      # removed.
-      #
-      def recvmsgs list, flag = 0
-        flag = DONTWAIT if dontwait?(flag)
-
-        message = @receiver_klass.new
-        rc = recvmsg message, flag
-
-        if Util.resultcode_ok?(rc)
-          list << message
-
-          # check rc *first*; necessary because the call to #more_parts? can reset
-          # the zmq_errno to a weird value, so the zmq_errno that was set on the
-          # call to #recv gets lost
-          while Util.resultcode_ok?(rc) && more_parts?
-            message = @receiver_klass.new
-            rc = recvmsg message, flag
-            
-            if Util.resultcode_ok?(rc)
-              list << message
-            else
-              message.close
-              list.each { |msg| msg.close }
-              list.clear
-            end
-          end
-        else
-          message.close
-        end
+      private
 
-        rc
+      def __sendmsg__(socket, address, flags)
+        LibZMQ.zmq_sendmsg(socket, address, flags)
       end
 
-      # Should only be used for XREQ, XREP, DEALER and ROUTER type sockets. Takes
-      # a +list+ for receiving the message body parts and a +routing_envelope+
-      # for receiving the message parts comprising the 0mq routing information.
-      #
-      def recv_multipart list, routing_envelope, flag = 0
-        parts = []
-        rc = recvmsgs parts, flag
-
-        if Util.resultcode_ok?(rc)
-          routing = true
-          parts.each do |part|
-            if routing
-              routing_envelope << part
-              routing = part.size > 0
-            else
-              list << part
-            end
-          end
-        end
-
-        rc
+      def __recvmsg__(socket, address, flags)
+        LibZMQ.zmq_recvmsg(socket, address, flags)
       end
 
+      def populate_option_lookup
+        super()
 
-      private
-
-      def dontwait? flags
-        (DONTWAIT & flags) == DONTWAIT
+        # integer options
+        [RECONNECT_IVL_MAX, RCVHWM, SNDHWM, RATE, RECOVERY_IVL, SNDBUF, RCVBUF, IPV4ONLY,
+          ROUTER_BEHAVIOR, TCP_KEEPALIVE, TCP_KEEPALIVE_CNT,
+          TCP_KEEPALIVE_IDLE, TCP_KEEPALIVE_INTVL, TCP_ACCEPT_FILTER].each { |option| @option_lookup[option] = 0 }
+          
+        # long long options
+        [MAXMSGSIZE].each { |option| @option_lookup[option] = 1 }
       end
-      alias :noblock? :dontwait?
-
-      def int_option? name
-        super(name) ||
-        RECONNECT_IVL_MAX == name ||
-        RCVHWM            == name ||
-        SNDHWM            == name ||
-        RATE              == name ||
-        RECOVERY_IVL      == name ||
-        SNDBUF            == name ||
-        RCVBUF            == name
-      end
-    
-    def populate_option_lookup
-      super()
-      
-      # integer options
-      [RECONNECT_IVL_MAX, RCVHWM, SNDHWM, RATE, RECOVERY_IVL, SNDBUF, RCVBUF].each { |option| @option_lookup[option] = 0 }
-    end
 
       # these finalizer-related methods cannot live in the CommonSocketBehavior
       # module; they *must* be in the class definition directly