ionian 0.4.1 → 0.5.0

data/lib/ionian/extension/socket.rb

@@ -1,5 +1,6 @@
 require 'ionian/extension/io'
 require 'socket'
+require 'ipaddr'
 
 module Ionian
   module Extension
@@ -23,20 +24,223 @@ module Ionian
       def initialize_ionian_socket
       end
       
-      # Returns true if the TCP_NODELAY flag is enabled (Nagle disabled).
-      # Otherwise false.
+      # Returns true if local address reuse is allowed.
+      # ( SO_REUSEADDR )
+      def reuse_addr
+        param = self.getsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEADDR)
+          .data.unpack('i').first
+        param > 0 ? true : false
+      end
+      
+      alias_method :reuse_addr?, :reuse_addr
+      
+      # Allows local address reuse if true.
+      # ( SO_REUSEADDR )
+      def reuse_addr=(value)
+        param = value ? 1 : 0
+        self.setsockopt ::Socket::SOL_SOCKET, ::Socket::SO_REUSEADDR, [param].pack('i')
+      end
+      
+      # Returns the time to live (hop limit).
+      # ( IP_TTL )
+      def ttl
+        self.getsockopt(::Socket::IPPROTO_IP, ::Socket::IP_TTL)
+          .data.unpack('i').first
+      end
+      
+      alias_method :ttl?, :ttl
+      
+      # Sets the time to live (hop limit).
+      # ( IP_TTL )
+      def ttl=(value)
+        self.setsockopt ::Socket::IPPROTO_IP, ::Socket::IP_TTL, [value].pack('i')
+      end
+      
+      # Returns true if the Nagle algorithm is disabled.
+      # ( TCP_NODELAY )
       def no_delay
-        nagle_disabled = self.getsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY).data.ord
-        nagle_disabled > 0 ? true : false
+        param = self.getsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY)
+          .data.unpack('i').first
+        param > 0 ? true : false
       end
       
-      # Setting to true enables the TCP_NODELAY flag (disables Nagle).
-      # Setting to false disables the flag (enables Nagle).
+      alias_method :no_delay?, :no_delay
+      
+      # Disables the Nagle algorithm if true.
+      # ( TCP_NODELAY )
       def no_delay=(value)
-        disable_nagle = value ? 1 : 0
-        self.setsockopt ::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, disable_nagle
+        param = value ? 1 : 0
+        self.setsockopt ::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, [param].pack('i')
+      end
+      
+      # Returns true if multiple writes are buffered into a single segment.
+      # See #recork.
+      # Linux only.
+      # ( TCP_CORK )
+      def cork
+        param = self.getsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_CORK)
+          .data.unpack('i').first
+        param > 0 ? true : false
+      end
+      
+      alias_method :cork?, :cork
+      
+      # Buffers multiple writes into a single segment if true.
+      # The segment is sent once the cork flag is disabled,
+      # the upper limit on the size of a segment is reached,
+      # the socket is closed, or 200ms elapses from the time
+      # the first corked byte is written.
+      # See #recork.
+      # Linux only.
+      # ( TCP_CORK )
+      def cork=(value)
+        param = value ? 1 : 0
+        self.setsockopt ::Socket::IPPROTO_TCP, ::Socket::TCP_CORK, [param].pack('i')
+      end
+      
+      # Unsets cork to transmit data, then reapplies cork.
+      # ( TCP_CORK )
+      def recork
+        self.setsockopt ::Socket::IPPROTO_TCP, ::Socket::TCP_CORK, [0].pack('i')
+        self.setsockopt ::Socket::IPPROTO_TCP, ::Socket::TCP_CORK, [1].pack('i')
+      end
+      
+      # Join a multicast group.
+      # Address is the class D multicast address (uses remote
+      # address if not specified). 
+      # Interface is the local network interface to receive the
+      # multicast traffic on (all interfaces if not specified).
+      # ( IP_ADD_MEMBERSHIP )
+     def ip_add_membership(address = nil, interface = nil)
+        address   ||= self.remote_address.ip_address
+        interface ||= '0.0.0.0'
+        
+        self.setsockopt \
+            ::Socket::IPPROTO_IP,
+            ::Socket::IP_ADD_MEMBERSHIP,
+            IPAddr.new(address).hton + IPAddr.new(interface).hton
+      end
+      
+      # Leave a multicast group.
+      # Address is the class D multicast address (uses remote
+      # address if not specified). 
+      # Interface is the local network interface the multicast
+      # traffic is received on (all interfaces if not specified).
+      # ( IP_DROP_MEMBERSHIP )
+      def ip_drop_membership(address = nil, interface = nil)
+        address   ||= self.remote_address.ip_address
+        interface ||= '0.0.0.0'
+        
+        self.setsockopt \
+            ::Socket::IPPROTO_IP,
+            ::Socket::IP_DROP_MEMBERSHIP,
+            IPAddr.new(address).hton + IPAddr.new(interface).hton
+      end
+      
+      # Returns the default interface for outgoing multicasts.
+      # ( IP_MULTICAST_IF )
+      def ip_multicast_if
+        self.getsockopt(::Socket::IPPROTO_IP, ::Socket::IP_MULTICAST_IF)
+          .data.unpack('CCCC').join('.')
+      end
+      
+      # Specify default interface for outgoing multicasts.
+      # ( IP_MULTICAST_IF )
+      def ip_multicast_if=(interface = nil)
+        interface ||= '0.0.0.0'
+        
+        self.setsockopt \
+          ::Socket::IPPROTO_IP,
+          ::Socket::IP_MULTICAST_IF,
+          IPAddr.new(interface).hton
+      end
+      
+      # Returns the time to live (hop limit) for outgoing multicasts.
+      # ( IP_MULTICAST_TTL )
+      def ip_multicast_ttl
+        self.getsockopt(::Socket::IPPROTO_IP, ::Socket::IP_MULTICAST_TTL)
+          .data.unpack('C').first
+      end
+      
+      # Set the time to live (hop limit) for outgoing multicasts.
+      # ( IP_MULTICAST_TTL )
+      def ip_multicast_ttl=(value)
+        self.setsockopt ::Socket::IPPROTO_IP, ::Socket::IP_MULTICAST_TTL, [value].pack('C')
+      end
+      
+      # Returns true if loopback of outgoing multicasts is enabled.
+      # ( IP_MULTICAST_LOOP )
+      def ip_multicast_loop
+        param = self.getsockopt(::Socket::IPPROTO_IP, ::Socket::IP_MULTICAST_LOOP)
+          .data.unpack('C').first
+        param > 0 ? true : false
+      end
+      
+      alias_method :ip_multicast_loop?, :ip_multicast_loop
+      
+      # Enables loopback of outgoing multicasts if true.
+      # ( IP_MULTICAST_LOOP )
+      def ip_multicast_loop=(value)
+        param = value ? 1 : 0
+        self.setsockopt ::Socket::IPPROTO_IP, ::Socket::IP_MULTICAST_LOOP, [param].pack('C')
+      end
+      
+      def ipv6_add_membership
+        # TODO: Implement
+        false
       end
       
+      def ipv6_drop_membership
+        # TODO: Implement
+        false
+      end
+      
+      def ipv6_multicast_if
+        # TODO: Implement
+        false
+      end
+      
+      def ipv6_multicast_if=(value)
+        # TODO: Implement
+      end
+      
+      def ipv6_multicast_hops
+        # TODO: Implement
+        false
+      end
+      
+      def ipv6_multicast_hops=(value)
+        # TODO: Implement
+      end
+      
+      def ipv6_multicast_loop
+        # TODO: Implement
+        false
+      end
+      
+      alias_method :ipv6_multicast_loop?, :ipv6_multicast_loop
+      
+      def ipv6_multicast_loop=(value)
+        # TODO: Implement
+      end
+      
+      
+      class << self
+        # Returns true if the given address is within the multicast range.
+        def multicast(address)
+          address >= '224.0.0.0' and address <= '239.255.255.255' ? true : false
+        end
+        
+        alias_method :multicast?, :multicast
+      end
+      
+      # Returns true if the socket's address is in the multicast range.
+      def multicast
+        Ionian::Extension::Socket.multicast self.remote_address.ip_address
+      end
+      
+      alias_method :multicast?, :multicast
+      
     end
   end
 end

data/lib/ionian/socket.rb

@@ -6,22 +6,43 @@ module Ionian
   class Socket
     
     # Args:
-    #   host: IP or hostname to connect to.
-    #   port: Connection's port number. Default is 23. Unused by :unix protocol.
-    #   protocol: Type of socket to create. :tcp, :udp, :unix. Default is :tcp.
+    #   host:       IP or hostname to connect to.
+    #   port:       Connection's port number. Default is 23. Unused by :unix protocol.
+    #   protocol:   Type of socket to create. :tcp, :udp, :unix. Default is :tcp.
+    #               :udp will be automatically selected for addresses in the multicast range.
     #   persistent: The socket remains open after data is sent if this is true.
     #               The socket closes after data is sent and a packet is received
     #               if this is false. Default is true.
+    #   bind_port:  Local UDP port to bind to for receiving data, if different than
+    #               the remote port being connected to.
+    #   reuse_addr: Set true to enable the SO_REUSEADDR flag. Allows local address reuse.
+    #   no_delay:   Set true to enable the TCP_NODELAY flag. Disables Nagle algorithm.
+    #   cork:       Set true to enable the TCP_CORK flag. Buffers multiple writes
+    #               into one segment.
     #   expression: Overrides the #read_match regular expression for received data.
     def initialize(**kwargs)
       @socket         = nil
       
+      # TODO: Should be able to parse the port out of host.
+      #       :port should override this parsed value.
+      
       @host           = kwargs.fetch :host
-      @port           = kwargs.fetch :port, 23
-      @protocol       = kwargs.fetch :protocol, :tcp
+      @port           = kwargs.fetch :port,       23
+      @bind_port      = kwargs.fetch :bind_port,  @port
+      
+      # Automatically select UDP for the multicast range. Otherwise default to TCP.
+      default_protocol = :tcp
+      default_protocol = :udp  if Ionian::Extension::Socket.multicast? @host
+      default_protocol = :unix if @host.start_with? '/'
+      
+      @protocol       = kwargs.fetch :protocol,   default_protocol
       @persistent     = kwargs.fetch :persistent, true
       @expression     = kwargs.fetch :expression, nil
       
+      @reuse_addr     = kwargs.fetch :reuse_addr, false
+      @no_delay       = kwargs.fetch :no_delay,   false
+      @cork           = kwargs.fetch :cork,       false
+      
       create_socket if @persistent
     end
         
@@ -123,15 +144,30 @@ module Ionian
       case @protocol
       when :tcp
         @socket = ::TCPSocket.new @host, @port
+        @socket.extend Ionian::Extension::Socket
+        @socket.no_delay = true if @no_delay
+        @socket.cork = true if @cork
+        
       when :udp
         @socket = ::UDPSocket.new
-        @socket.bind '', @port
+        @socket.extend Ionian::Extension::Socket
+        
+        @socket.reuse_addr = true if
+          @reuse_addr or Ionian::Extension::Socket.multicast? @host
+        
+        @socket.bind ::Socket::INADDR_ANY, @bind_port
         @socket.connect @host, @port
+        
+        @socket.ip_add_membership if Ionian::Extension::Socket.multicast? @host
+        
       when :unix
         @socket = ::UNIXSocket.new @host
+        @socket.extend Ionian::Extension::Socket
       end
       
-      @socket.extend Ionian::Extension::Socket
+      # TODO: Implement SO_LINGER flag for non-persistent sockets;
+      #       especially send-and-forget.
+      
       @socket.expression = @expression if @expression
       
       initialize_socket_methods

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ionian
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Alex McLain
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-03 00:00:00.000000000 Z
+date: 2013-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake