rubysl-socket 2.0.1 → 2.1.0

data/lib/rubysl/socket/foreign/addrinfo.rb

@@ -0,0 +1,10 @@
+module RubySL
+  module Socket
+    module Foreign
+      class Addrinfo < Rubinius::FFI::Struct
+        config("rbx.platform.addrinfo", :ai_flags, :ai_family, :ai_socktype,
+               :ai_protocol, :ai_addrlen, :ai_addr, :ai_canonname, :ai_next)
+      end
+    end
+  end
+end

data/lib/rubysl/socket/foreign/hostent.rb

@@ -0,0 +1,36 @@
+module RubySL
+  module Socket
+    module Foreign
+      class Hostent < Rubinius::FFI::Struct
+        config('rbx.platform.hostent', :h_name, :h_aliases, :h_addrtype,
+               :h_length, :h_addr_list)
+
+        def hostname
+          self[:h_name]
+        end
+
+        def type
+          self[:h_addrtype]
+        end
+
+        def aliases
+          return [] unless self[:h_aliases]
+
+          RubySL::Socket::Foreign.pointers_of_type(self[:h_aliases], :string)
+            .map(&:read_string)
+        end
+
+        def addresses
+          return [] unless self[:h_addr_list]
+
+          RubySL::Socket::Foreign.pointers_of_type(self[:h_addr_list], :string)
+            .map { |pointer| pointer.read_string(self[:h_length]) }
+        end
+
+        def to_s
+          pointer.read_string(size)
+        end
+      end
+    end
+  end
+end

data/lib/rubysl/socket/foreign/ifaddrs.rb

@@ -0,0 +1,129 @@
+module RubySL
+  module Socket
+    module Foreign
+      # Class representing an "ifaddrs" C structure.
+      #
+      # The memory used by this structure should be free'd using
+      # `RubySL::Socket::Foreign.freeifaddrs` _only_ as following:
+      #
+      #     RubySL::Socket::Foreign.freeifaddrs(initial_ifaddrs_struct)
+      #
+      # To ensure Rubinius doesn't accidentally free invalid pointers all
+      # pointers (including the pointer of "self") stored in this class have the
+      # "autorelease" option set to false.
+      class Ifaddrs < Rubinius::FFI::Struct
+        config("rbx.platform.ifaddrs", :ifa_next, :ifa_name, :ifa_flags,
+               :ifa_addr, :ifa_netmask, :ifa_broadaddr, :ifa_dstaddr)
+
+        POINTERS = [
+          :address, :next, :broadcast_address, :destination_address,
+          :netmask_address
+        ]
+
+        def initialize(*args)
+          super
+
+          POINTERS.each do |name|
+            pointer = __send__(name)
+
+            pointer.autorelease = false if pointer
+          end
+
+          pointer.autorelease = false
+        end
+
+        def name
+          self[:ifa_name]
+        end
+
+        def flags
+          self[:ifa_flags]
+        end
+
+        def data
+          @data ||= self[:ifa_data]
+        end
+
+        def next
+          @next ||= self[:ifa_next]
+        end
+
+        def address
+          @address ||= self[:ifa_addr]
+        end
+
+        def broadcast_address
+          @broadcast_address ||= self[:ifa_broadaddr]
+        end
+
+        def destination_address
+          @destination_address ||= self[:ifa_dstaddr]
+        end
+
+        def netmask_address
+          @netmask_address ||= self[:ifa_netmask]
+        end
+
+        def each_address
+          next_pointer = self.next
+
+          while next_pointer
+            struct = self.class.new(next_pointer)
+
+            yield struct
+
+            next_pointer = struct.next
+          end
+        end
+
+        def broadcast?
+          flags & ::Socket::IFF_BROADCAST > 0
+        end
+
+        def point_to_point?
+          flags & ::Socket::IFF_POINTOPOINT > 0
+        end
+
+        def address_to_addrinfo
+          return unless address
+
+          sockaddr = Sockaddr.new(address)
+
+          if sockaddr.family == ::Socket::AF_INET
+            ::Addrinfo.new(SockaddrIn.new(address).to_s)
+          elsif sockaddr.family == ::Socket::AF_INET6
+            ::Addrinfo.new(SockaddrIn6.new(address).to_s)
+          else
+            nil
+          end
+        end
+
+        def broadcast_to_addrinfo
+          return if !broadcast? || !broadcast_address
+
+          ::Addrinfo.raw_with_family(Sockaddr.new(broadcast_address).family)
+        end
+
+        def destination_to_addrinfo
+          return if !point_to_point? || !destination_address
+
+          ::Addrinfo.raw_with_family(Sockaddr.new(destination_address).family)
+        end
+
+        def netmask_to_addrinfo
+          return unless netmask_address
+
+          sockaddr = Sockaddr.new(netmask_address)
+
+          if sockaddr.family == ::Socket::AF_INET
+            ::Addrinfo.new(SockaddrIn.new(netmask_address).to_s)
+          elsif sockaddr.family == ::Socket::AF_INET6
+            ::Addrinfo.new(SockaddrIn6.new(netmask_address).to_s)
+          else
+            ::Addrinfo.raw_with_family(sockaddr.family)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubysl/socket/foreign/iovec.rb

@@ -0,0 +1,18 @@
+module RubySL
+  module Socket
+    module Foreign
+      class Iovec < Rubinius::FFI::Struct
+        config('rbx.platform.iovec', :iov_base, :iov_len)
+
+        def self.with_buffer(buffer)
+          vec = new
+
+          vec[:iov_base] = buffer
+          vec[:iov_len]  = buffer.total
+
+          vec
+        end
+      end
+    end
+  end
+end

data/lib/rubysl/socket/foreign/linger.rb

@@ -0,0 +1,41 @@
+module RubySL
+  module Socket
+    module Foreign
+      class Linger < Rubinius::FFI::Struct
+        config('rbx.platform.linger', :l_onoff, :l_linger)
+
+        def self.from_string(string)
+          linger = new
+
+          linger.pointer.write_string(string, string.bytesize)
+
+          linger
+        end
+
+        def on_off
+          self[:l_onoff]
+        end
+
+        def linger
+          self[:l_linger].to_i
+        end
+
+        def on_off=(value)
+          if value.is_a?(Integer)
+            self[:l_onoff] = value
+          else
+            self[:l_onoff] = value ? 1 : 0
+          end
+        end
+
+        def linger=(value)
+          self[:l_linger] = value
+        end
+
+        def to_s
+          pointer.read_string(pointer.total)
+        end
+      end
+    end
+  end
+end

data/lib/rubysl/socket/foreign/msghdr.rb

@@ -0,0 +1,41 @@
+module RubySL
+  module Socket
+    module Foreign
+      class Msghdr < Rubinius::FFI::Struct
+        config('rbx.platform.msghdr', :msg_name, :msg_namelen, :msg_iov,
+               :msg_iovlen, :msg_control, :msg_controllen, :msg_flags)
+
+        def self.with_buffers(address, io_vec)
+          header = new
+
+          header.address = address
+          header.message = io_vec
+
+          header
+        end
+
+        def address=(address)
+          self[:msg_name]    = address.pointer
+          self[:msg_namelen] = address.pointer.total
+        end
+
+        def message=(vec)
+          self[:msg_iov]    = vec.pointer
+          self[:msg_iovlen] = 1
+        end
+
+        def address_size
+          self[:msg_namelen]
+        end
+
+        def flags
+          self[:msg_flags]
+        end
+
+        def message_truncated?
+          flags & ::Socket::MSG_TRUNC > 0
+        end
+      end
+    end
+  end
+end

data/lib/rubysl/socket/foreign/servent.rb

@@ -0,0 +1,17 @@
+module RubySL
+  module Socket
+    module Foreign
+      class Servent < Rubinius::FFI::Struct
+        config('rbx.platform.servent', :s_name, :s_aliases, :s_port, :s_proto)
+
+        def name
+          self[:s_name].read_string
+        end
+
+        def port
+          self[:s_port]
+        end
+      end
+    end
+  end
+end

data/lib/rubysl/socket/foreign/sockaddr.rb

@@ -0,0 +1,21 @@
+module RubySL
+  module Socket
+    module Foreign
+      class Sockaddr < Rubinius::FFI::Struct
+        config("rbx.platform.sockaddr", :sa_data, :sa_family)
+
+        def data
+          self[:sa_data]
+        end
+
+        def family
+          self[:sa_family]
+        end
+
+        def to_s
+          pointer.read_string(self.class.size)
+        end
+      end
+    end
+  end
+end

data/lib/rubysl/socket/foreign/sockaddr_in.rb

@@ -0,0 +1,25 @@
+module RubySL
+  module Socket
+    module Foreign
+      class SockaddrIn < Rubinius::FFI::Struct
+        config("rbx.platform.sockaddr_in",
+               :sin_family, :sin_port, :sin_addr, :sin_zero)
+
+        def self.with_sockaddr(addr)
+          pointer = Foreign.memory_pointer(addr.bytesize)
+          pointer.write_string(addr, addr.bytesize)
+
+          new(pointer)
+        end
+
+        def family
+          self[:sin_family]
+        end
+
+        def to_s
+          pointer.read_string(self.class.size)
+        end
+      end
+    end
+  end
+end

data/lib/rubysl/socket/foreign/sockaddr_in6.rb

@@ -0,0 +1,25 @@
+module RubySL
+  module Socket
+    module Foreign
+      class SockaddrIn6 < Rubinius::FFI::Struct
+        config("rbx.platform.sockaddr_in6", :sin6_family, :sin6_port,
+               :sin6_flowinfo, :sin6_addr, :sin6_scope_id)
+
+        def self.with_sockaddr(addr)
+          pointer = Foreign.memory_pointer(addr.bytesize)
+          pointer.write_string(addr, addr.bytesize)
+
+          new(pointer)
+        end
+
+        def family
+          self[:sin6_family]
+        end
+
+        def to_s
+          pointer.read_string(self.class.size)
+        end
+      end
+    end
+  end
+end

data/lib/rubysl/socket/foreign/sockaddr_un.rb

@@ -0,0 +1,29 @@
+module RubySL
+  module Socket
+    module Foreign
+      class SockaddrUn < Rubinius::FFI::Struct
+        config('rbx.platform.sockaddr_un', :sun_family, :sun_path)
+
+        def self.with_sockaddr(addr)
+          if addr.bytesize > size
+            raise ArgumentError,
+              "UNIX socket path is too long (max: #{size} bytes)"
+          end
+
+          pointer = Foreign.memory_pointer(size)
+          pointer.write_string(addr, addr.bytesize)
+
+          new(pointer)
+        end
+
+        def family
+          self[:sun_family]
+        end
+
+        def to_s
+          pointer.read_string(pointer.total)
+        end
+      end
+    end
+  end
+end

data/lib/rubysl/socket/ipv6.rb

@@ -0,0 +1,38 @@
+module RubySL
+  module Socket
+    module IPv6
+      # The IPv6 loopback address as produced by inet_pton(INET6, "::1")
+      LOOPBACK = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
+
+      # The bytes used for an unspecified IPv6 address.
+      UNSPECIFIED = [0] * 16
+
+      # The first 10 bytes of an IPv4 compatible IPv6 address.
+      COMPAT_PREFIX = [0] * 10
+
+      def self.ipv4_embedded?(bytes)
+        ipv4_mapped?(bytes) || ipv4_compatible?(bytes)
+      end
+
+      def self.ipv4_mapped?(bytes)
+        prefix = bytes.first(10)
+        follow = bytes[10..11]
+
+        prefix == COMPAT_PREFIX &&
+          follow[0] == 255 &&
+          follow[1] == 255 &&
+          (bytes[-4] > 0 || bytes[-3] > 0 || bytes[-2] > 0)
+      end
+
+      def self.ipv4_compatible?(bytes)
+        prefix = bytes.first(10)
+        follow = bytes[10..11]
+
+        prefix == COMPAT_PREFIX &&
+          follow[0] == 0 &&
+          follow[1] == 0 &&
+          (bytes[-4] > 0 || bytes[-3] > 0 || bytes[-2] > 0)
+      end
+    end
+  end
+end