rubysl-socket 2.0.1 → 2.1.0

data/lib/socket/ifaddr.rb

@@ -0,0 +1,29 @@
+class Socket < BasicSocket
+  class Ifaddr < Data
+    attr_reader :addr, :broadaddr, :dstaddr, :flags, :ifindex, :name, :netmask
+
+    def initialize(addr: nil, broadaddr: nil, dstaddr: nil, flags: nil, ifindex: nil, name: nil, netmask: nil)
+      @addr      = addr
+      @broadaddr = broadaddr
+      @dstaddr   = dstaddr
+      @flags     = flags
+      @ifindex   = ifindex
+      @name      = name
+      @netmask   = netmask
+    end
+
+    def inspect
+      out = "#<Socket::Ifaddr #{name}"
+
+      if addr
+        out << " #{addr.inspect_sockaddr}"
+      end
+
+      if netmask
+        out << " netmask=#{netmask.inspect_sockaddr}"
+      end
+
+      out + '>'
+    end
+  end
+end

data/lib/socket/ip_socket.rb

@@ -0,0 +1,37 @@
+class IPSocket < BasicSocket
+  undef_method :getpeereid
+
+  def self.getaddress(host)
+    RubySL::Socket::Foreign.getaddress(host)
+  end
+
+  def addr(reverse_lookup = nil)
+    RubySL::Socket.address_info(:getsockname, self, reverse_lookup)
+  end
+
+  def peeraddr(reverse_lookup=nil)
+    RubySL::Socket.address_info(:getpeername, self, reverse_lookup)
+  end
+
+  def recvfrom(maxlen, flags = 0)
+    flags = 0 if flags.nil?
+
+    message, addr = recvmsg(maxlen, flags)
+
+    aname    = RubySL::Socket.address_family_name(addr.afamily)
+    hostname = addr.ip_address
+
+    # We're re-using recvmsg which doesn't return the reverse hostname, thus
+    # we'll do an extra lookup in case this is needed.
+    unless do_not_reverse_lookup
+      addrinfos = Socket.getaddrinfo(addr.ip_address, nil, addr.afamily,
+                                     addr.socktype, addr.protocol, 0, true)
+
+      unless addrinfos.empty?
+        hostname = addrinfos[0][2]
+      end
+    end
+
+    return message, [aname, addr.ip_port, hostname, addr.ip_address]
+  end
+end

data/lib/socket/mri.rb

@@ -0,0 +1,928 @@
+# Everything below is copied from the MRI codebase. The Ruby license is
+# attached below.
+#
+# Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.jp>.
+# You can redistribute it and/or modify it under either the terms of the
+# 2-clause BSDL (see the file BSDL), or the conditions below:
+#
+#   1. You may make and give away verbatim copies of the source form of the
+#      software without restriction, provided that you duplicate all of the
+#      original copyright notices and associated disclaimers.
+#
+#   2. You may modify your copy of the software in any way, provided that
+#      you do at least ONE of the following:
+#
+#        a) place your modifications in the Public Domain or otherwise
+#           make them Freely Available, such as by posting said
+# 	  modifications to Usenet or an equivalent medium, or by allowing
+# 	  the author to include your modifications in the software.
+#
+#        b) use the modified software only within your corporation or
+#           organization.
+#
+#        c) give non-standard binaries non-standard names, with
+#           instructions on where to get the original software distribution.
+#
+#        d) make other distribution arrangements with the author.
+#
+#   3. You may distribute the software in object code or binary form,
+#      provided that you do at least ONE of the following:
+#
+#        a) distribute the binaries and library files of the software,
+# 	  together with instructions (in the manual page or equivalent)
+# 	  on where to get the original distribution.
+#
+#        b) accompany the distribution with the machine-readable source of
+# 	  the software.
+#
+#        c) give non-standard binaries non-standard names, with
+#           instructions on where to get the original software distribution.
+#
+#        d) make other distribution arrangements with the author.
+#
+#   4. You may modify and include the part of the software into any other
+#      software (possibly commercial).  But some files in the distribution
+#      are not written by the author, so that they are not under these terms.
+#
+#      For the list of those files and their copying conditions, see the
+#      file LEGAL.
+#
+#   5. The scripts and library files supplied as input to or produced as
+#      output from the software do not automatically fall under the
+#      copyright of the software, but belong to whomever generated them,
+#      and may be sold commercially, and may be aggregated with this
+#      software.
+#
+#   6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+#      IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+#      WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+#      PURPOSE.
+
+class Addrinfo
+  # creates an Addrinfo object from the arguments.
+  #
+  # The arguments are interpreted as similar to self.
+  #
+  #   Addrinfo.tcp("0.0.0.0", 4649).family_addrinfo("www.ruby-lang.org", 80)
+  #   #=> #<Addrinfo: 221.186.184.68:80 TCP (www.ruby-lang.org:80)>
+  #
+  #   Addrinfo.unix("/tmp/sock").family_addrinfo("/tmp/sock2")
+  #   #=> #<Addrinfo: /tmp/sock2 SOCK_STREAM>
+  #
+  def family_addrinfo(*args)
+    if args.empty?
+      raise ArgumentError, "no address specified"
+    elsif Addrinfo === args.first
+      raise ArgumentError, "too many arguments" if args.length != 1
+      addrinfo = args.first
+      if (self.pfamily != addrinfo.pfamily) ||
+         (self.socktype != addrinfo.socktype)
+        raise ArgumentError, "Addrinfo type mismatch"
+      end
+      addrinfo
+    elsif self.ip?
+      raise ArgumentError, "IP address needs host and port but #{args.length} arguments given" if args.length != 2
+      host, port = args
+      Addrinfo.getaddrinfo(host, port, self.pfamily, self.socktype, self.protocol)[0]
+    elsif self.unix?
+      raise ArgumentError, "UNIX socket needs single path argument but #{args.length} arguments given" if args.length != 1
+      path, = args
+      Addrinfo.unix(path)
+    else
+      raise ArgumentError, "unexpected family"
+    end
+  end
+
+  # creates a new Socket connected to the address of +local_addrinfo+.
+  #
+  # If _local_addrinfo_ is nil, the address of the socket is not bound.
+  #
+  # The _timeout_ specify the seconds for timeout.
+  # Errno::ETIMEDOUT is raised when timeout occur.
+  #
+  # If a block is given the created socket is yielded for each address.
+  #
+  def connect_internal(local_addrinfo, timeout=nil) # :yields: socket
+    sock = Socket.new(self.pfamily, self.socktype, self.protocol)
+    begin
+      sock.ipv6only! if self.ipv6?
+      sock.bind local_addrinfo if local_addrinfo
+      if timeout
+        begin
+          sock.connect_nonblock(self)
+        rescue IO::WaitWritable
+          if !IO.select(nil, [sock], nil, timeout)
+            raise Errno::ETIMEDOUT, 'user specified timeout'
+          end
+          begin
+            sock.connect_nonblock(self) # check connection failure
+          rescue Errno::EISCONN
+          end
+        end
+      else
+        sock.connect(self)
+      end
+    rescue Exception
+      sock.close
+      raise
+    end
+    if block_given?
+      begin
+        yield sock
+      ensure
+        sock.close if !sock.closed?
+      end
+    else
+      sock
+    end
+  end
+  private :connect_internal
+
+  # :call-seq:
+  #   addrinfo.connect_from([local_addr_args], [opts]) {|socket| ... }
+  #   addrinfo.connect_from([local_addr_args], [opts])
+  #
+  # creates a socket connected to the address of self.
+  #
+  # If one or more arguments given as _local_addr_args_,
+  # it is used as the local address of the socket.
+  # _local_addr_args_ is given for family_addrinfo to obtain actual address.
+  #
+  # If _local_addr_args_ is not given, the local address of the socket is not bound.
+  #
+  # The optional last argument _opts_ is options represented by a hash.
+  # _opts_ may have following options:
+  #
+  # [:timeout] specify the timeout in seconds.
+  #
+  # If a block is given, it is called with the socket and the value of the block is returned.
+  # The socket is returned otherwise.
+  #
+  #   Addrinfo.tcp("www.ruby-lang.org", 80).connect_from("0.0.0.0", 4649) {|s|
+  #     s.print "GET / HTTP/1.0\r\nHost: www.ruby-lang.org\r\n\r\n"
+  #     puts s.read
+  #   }
+  #
+  #   # Addrinfo object can be taken for the argument.
+  #   Addrinfo.tcp("www.ruby-lang.org", 80).connect_from(Addrinfo.tcp("0.0.0.0", 4649)) {|s|
+  #     s.print "GET / HTTP/1.0\r\nHost: www.ruby-lang.org\r\n\r\n"
+  #     puts s.read
+  #   }
+  #
+  def connect_from(*args, &block)
+    opts = Hash === args.last ? args.pop : {}
+    local_addr_args = args
+    connect_internal(family_addrinfo(*local_addr_args), opts[:timeout], &block)
+  end
+
+  # :call-seq:
+  #   addrinfo.connect([opts]) {|socket| ... }
+  #   addrinfo.connect([opts])
+  #
+  # creates a socket connected to the address of self.
+  #
+  # The optional argument _opts_ is options represented by a hash.
+  # _opts_ may have following options:
+  #
+  # [:timeout] specify the timeout in seconds.
+  #
+  # If a block is given, it is called with the socket and the value of the block is returned.
+  # The socket is returned otherwise.
+  #
+  #   Addrinfo.tcp("www.ruby-lang.org", 80).connect {|s|
+  #     s.print "GET / HTTP/1.0\r\nHost: www.ruby-lang.org\r\n\r\n"
+  #     puts s.read
+  #   }
+  #
+  def connect(opts={}, &block)
+    connect_internal(nil, opts[:timeout], &block)
+  end
+
+  # :call-seq:
+  #   addrinfo.connect_to([remote_addr_args], [opts]) {|socket| ... }
+  #   addrinfo.connect_to([remote_addr_args], [opts])
+  #
+  # creates a socket connected to _remote_addr_args_ and bound to self.
+  #
+  # The optional last argument _opts_ is options represented by a hash.
+  # _opts_ may have following options:
+  #
+  # [:timeout] specify the timeout in seconds.
+  #
+  # If a block is given, it is called with the socket and the value of the block is returned.
+  # The socket is returned otherwise.
+  #
+  #   Addrinfo.tcp("0.0.0.0", 4649).connect_to("www.ruby-lang.org", 80) {|s|
+  #     s.print "GET / HTTP/1.0\r\nHost: www.ruby-lang.org\r\n\r\n"
+  #     puts s.read
+  #   }
+  #
+  def connect_to(*args, &block)
+    opts = Hash === args.last ? args.pop : {}
+    remote_addr_args = args
+    remote_addrinfo = family_addrinfo(*remote_addr_args)
+    remote_addrinfo.send(:connect_internal, self, opts[:timeout], &block)
+  end
+
+  # creates a socket bound to self.
+  #
+  # If a block is given, it is called with the socket and the value of the block is returned.
+  # The socket is returned otherwise.
+  #
+  #   Addrinfo.udp("0.0.0.0", 9981).bind {|s|
+  #     s.local_address.connect {|s| s.send "hello", 0 }
+  #     p s.recv(10) #=> "hello"
+  #   }
+  #
+  def bind
+    sock = Socket.new(self.pfamily, self.socktype, self.protocol)
+    begin
+      sock.ipv6only! if self.ipv6?
+      sock.setsockopt(:SOCKET, :REUSEADDR, 1)
+      sock.bind(self)
+    rescue Exception
+      sock.close
+      raise
+    end
+    if block_given?
+      begin
+        yield sock
+      ensure
+        sock.close if !sock.closed?
+      end
+    else
+      sock
+    end
+  end
+
+  # creates a listening socket bound to self.
+  def listen(backlog=Socket::SOMAXCONN)
+    sock = Socket.new(self.pfamily, self.socktype, self.protocol)
+    begin
+      sock.ipv6only! if self.ipv6?
+      sock.setsockopt(:SOCKET, :REUSEADDR, 1)
+      sock.bind(self)
+      sock.listen(backlog)
+    rescue Exception
+      sock.close
+      raise
+    end
+    if block_given?
+      begin
+        yield sock
+      ensure
+        sock.close if !sock.closed?
+      end
+    else
+      sock
+    end
+  end
+
+  # iterates over the list of Addrinfo objects obtained by Addrinfo.getaddrinfo.
+  #
+  #   Addrinfo.foreach(nil, 80) {|x| p x }
+  #   #=> #<Addrinfo: 127.0.0.1:80 TCP (:80)>
+  #   #   #<Addrinfo: 127.0.0.1:80 UDP (:80)>
+  #   #   #<Addrinfo: [::1]:80 TCP (:80)>
+  #   #   #<Addrinfo: [::1]:80 UDP (:80)>
+  #
+  def self.foreach(nodename, service, family=nil, socktype=nil, protocol=nil, flags=nil, &block)
+    Addrinfo.getaddrinfo(nodename, service, family, socktype, protocol, flags).each(&block)
+  end
+end
+
+class BasicSocket < IO
+  # Returns an address of the socket suitable for connect in the local machine.
+  #
+  # This method returns _self_.local_address, except following condition.
+  #
+  # - IPv4 unspecified address (0.0.0.0) is replaced by IPv4 loopback address (127.0.0.1).
+  # - IPv6 unspecified address (::) is replaced by IPv6 loopback address (::1).
+  #
+  # If the local address is not suitable for connect, SocketError is raised.
+  # IPv4 and IPv6 address which port is 0 is not suitable for connect.
+  # Unix domain socket which has no path is not suitable for connect.
+  #
+  #   Addrinfo.tcp("0.0.0.0", 0).listen {|serv|
+  #     p serv.connect_address #=> #<Addrinfo: 127.0.0.1:53660 TCP>
+  #     serv.connect_address.connect {|c|
+  #       s, _ = serv.accept
+  #       p [c, s] #=> [#<Socket:fd 4>, #<Socket:fd 6>]
+  #     }
+  #   }
+  #
+  def connect_address
+    addr = local_address
+    afamily = addr.afamily
+    if afamily == Socket::AF_INET
+      raise SocketError, "unbound IPv4 socket" if addr.ip_port == 0
+      if addr.ip_address == "0.0.0.0"
+        addr = Addrinfo.new(["AF_INET", addr.ip_port, nil, "127.0.0.1"], addr.pfamily, addr.socktype, addr.protocol)
+      end
+    elsif defined?(Socket::AF_INET6) && afamily == Socket::AF_INET6
+      raise SocketError, "unbound IPv6 socket" if addr.ip_port == 0
+      if addr.ip_address == "::"
+        addr = Addrinfo.new(["AF_INET6", addr.ip_port, nil, "::1"], addr.pfamily, addr.socktype, addr.protocol)
+      elsif addr.ip_address == "0.0.0.0" # MacOS X 10.4 returns "a.b.c.d" for IPv4-mapped IPv6 address.
+        addr = Addrinfo.new(["AF_INET6", addr.ip_port, nil, "::1"], addr.pfamily, addr.socktype, addr.protocol)
+      elsif addr.ip_address == "::ffff:0.0.0.0" # MacOS X 10.6 returns "::ffff:a.b.c.d" for IPv4-mapped IPv6 address.
+        addr = Addrinfo.new(["AF_INET6", addr.ip_port, nil, "::1"], addr.pfamily, addr.socktype, addr.protocol)
+      end
+    elsif defined?(Socket::AF_UNIX) && afamily == Socket::AF_UNIX
+      raise SocketError, "unbound Unix socket" if addr.unix_path == ""
+    end
+    addr
+  end
+end
+
+class Socket < BasicSocket
+  # enable the socket option IPV6_V6ONLY if IPV6_V6ONLY is available.
+  def ipv6only!
+    if defined? Socket::IPV6_V6ONLY
+      self.setsockopt(:IPV6, :V6ONLY, 1)
+    end
+  end
+
+  # :call-seq:
+  #   Socket.tcp(host, port, local_host=nil, local_port=nil, [opts]) {|socket| ... }
+  #   Socket.tcp(host, port, local_host=nil, local_port=nil, [opts])
+  #
+  # creates a new socket object connected to host:port using TCP/IP.
+  #
+  # If local_host:local_port is given,
+  # the socket is bound to it.
+  #
+  # The optional last argument _opts_ is options represented by a hash.
+  # _opts_ may have following options:
+  #
+  # [:connect_timeout] specify the timeout in seconds.
+  #
+  # If a block is given, the block is called with the socket.
+  # The value of the block is returned.
+  # The socket is closed when this method returns.
+  #
+  # If no block is given, the socket is returned.
+  #
+  #   Socket.tcp("www.ruby-lang.org", 80) {|sock|
+  #     sock.print "GET / HTTP/1.0\r\nHost: www.ruby-lang.org\r\n\r\n"
+  #     sock.close_write
+  #     puts sock.read
+  #   }
+  #
+  def self.tcp(host, port, *rest) # :yield: socket
+    opts = Hash === rest.last ? rest.pop : {}
+    raise ArgumentError, "wrong number of arguments (#{rest.length} for 2)" if 2 < rest.length
+    local_host, local_port = rest
+    last_error = nil
+    ret = nil
+
+    connect_timeout = opts[:connect_timeout]
+
+    local_addr_list = nil
+    if local_host != nil || local_port != nil
+      local_addr_list = Addrinfo.getaddrinfo(local_host, local_port, nil, :STREAM, nil)
+    end
+
+    Addrinfo.foreach(host, port, nil, :STREAM) {|ai|
+      if local_addr_list
+        local_addr = local_addr_list.find {|local_ai| local_ai.afamily == ai.afamily }
+        next if !local_addr
+      else
+        local_addr = nil
+      end
+      begin
+        sock = local_addr ?
+          ai.connect_from(local_addr, :timeout => connect_timeout) :
+          ai.connect(:timeout => connect_timeout)
+      rescue SystemCallError
+        last_error = $!
+        next
+      end
+      ret = sock
+      break
+    }
+    if !ret
+      if last_error
+        raise last_error
+      else
+        raise SocketError, "no appropriate local address"
+      end
+    end
+    if block_given?
+      begin
+        yield ret
+      ensure
+        ret.close if !ret.closed?
+      end
+    else
+      ret
+    end
+  end
+
+  # :stopdoc:
+  def self.ip_sockets_port0(ai_list, reuseaddr)
+    sockets = []
+    begin
+      sockets.clear
+      port = nil
+      ai_list.each {|ai|
+        begin
+          s = Socket.new(ai.pfamily, ai.socktype, ai.protocol)
+        rescue SystemCallError
+          next
+        end
+        sockets << s
+        s.ipv6only! if ai.ipv6?
+        if reuseaddr
+          s.setsockopt(:SOCKET, :REUSEADDR, 1)
+        end
+        if !port
+          s.bind(ai)
+          port = s.local_address.ip_port
+        else
+          s.bind(ai.family_addrinfo(ai.ip_address, port))
+        end
+      }
+    rescue Errno::EADDRINUSE
+      sockets.each {|s| s.close }
+      retry
+    rescue Exception
+      sockets.each {|s| s.close }
+      raise
+    end
+    sockets
+  end
+  class << self
+    private :ip_sockets_port0
+  end
+
+  def self.tcp_server_sockets_port0(host)
+    ai_list = Addrinfo.getaddrinfo(host, 0, nil, :STREAM, nil, Socket::AI_PASSIVE)
+    sockets = ip_sockets_port0(ai_list, true)
+    begin
+      sockets.each {|s|
+        s.listen(Socket::SOMAXCONN)
+      }
+    rescue Exception
+      sockets.each {|s| s.close }
+      raise
+    end
+    sockets
+  end
+  class << self
+    private :tcp_server_sockets_port0
+  end
+  # :startdoc:
+
+  # creates TCP/IP server sockets for _host_ and _port_.
+  # _host_ is optional.
+  #
+  # If no block given,
+  # it returns an array of listening sockets.
+  #
+  # If a block is given, the block is called with the sockets.
+  # The value of the block is returned.
+  # The socket is closed when this method returns.
+  #
+  # If _port_ is 0, actual port number is chosen dynamically.
+  # However all sockets in the result has same port number.
+  #
+  #   # tcp_server_sockets returns two sockets.
+  #   sockets = Socket.tcp_server_sockets(1296)
+  #   p sockets #=> [#<Socket:fd 3>, #<Socket:fd 4>]
+  #
+  #   # The sockets contains IPv6 and IPv4 sockets.
+  #   sockets.each {|s| p s.local_address }
+  #   #=> #<Addrinfo: [::]:1296 TCP>
+  #   #   #<Addrinfo: 0.0.0.0:1296 TCP>
+  #
+  #   # IPv6 and IPv4 socket has same port number, 53114, even if it is chosen dynamically.
+  #   sockets = Socket.tcp_server_sockets(0)
+  #   sockets.each {|s| p s.local_address }
+  #   #=> #<Addrinfo: [::]:53114 TCP>
+  #   #   #<Addrinfo: 0.0.0.0:53114 TCP>
+  #
+  #   # The block is called with the sockets.
+  #   Socket.tcp_server_sockets(0) {|sockets|
+  #     p sockets #=> [#<Socket:fd 3>, #<Socket:fd 4>]
+  #   }
+  #
+  def self.tcp_server_sockets(host=nil, port)
+    if port == 0
+      sockets = tcp_server_sockets_port0(host)
+    else
+      last_error = nil
+      sockets = []
+      begin
+        Addrinfo.foreach(host, port, nil, :STREAM, nil, Socket::AI_PASSIVE) {|ai|
+          begin
+            s = ai.listen
+          rescue SystemCallError
+            last_error = $!
+            next
+          end
+          sockets << s
+        }
+        if sockets.empty?
+          raise last_error
+        end
+      rescue Exception
+        sockets.each {|s| s.close }
+        raise
+      end
+    end
+    if block_given?
+      begin
+        yield sockets
+      ensure
+        sockets.each {|s| s.close if !s.closed? }
+      end
+    else
+      sockets
+    end
+  end
+
+  # yield socket and client address for each a connection accepted via given sockets.
+  #
+  # The arguments are a list of sockets.
+  # The individual argument should be a socket or an array of sockets.
+  #
+  # This method yields the block sequentially.
+  # It means that the next connection is not accepted until the block returns.
+  # So concurrent mechanism, thread for example, should be used to service multiple clients at a time.
+  #
+  def self.accept_loop(*sockets) # :yield: socket, client_addrinfo
+    sockets.flatten!(1)
+    if sockets.empty?
+      raise ArgumentError, "no sockets"
+    end
+    loop {
+      readable, _, _ = IO.select(sockets)
+      readable.each {|r|
+        begin
+          sock, addr = r.accept_nonblock
+        rescue IO::WaitReadable
+          next
+        end
+        yield sock, addr
+      }
+    }
+  end
+
+  # creates a TCP/IP server on _port_ and calls the block for each connection accepted.
+  # The block is called with a socket and a client_address as an Addrinfo object.
+  #
+  # If _host_ is specified, it is used with _port_ to determine the server addresses.
+  #
+  # The socket is *not* closed when the block returns.
+  # So application should close it explicitly.
+  #
+  # This method calls the block sequentially.
+  # It means that the next connection is not accepted until the block returns.
+  # So concurrent mechanism, thread for example, should be used to service multiple clients at a time.
+  #
+  # Note that Addrinfo.getaddrinfo is used to determine the server socket addresses.
+  # When Addrinfo.getaddrinfo returns two or more addresses,
+  # IPv4 and IPv6 address for example,
+  # all of them are used.
+  # Socket.tcp_server_loop succeeds if one socket can be used at least.
+  #
+  #   # Sequential echo server.
+  #   # It services only one client at a time.
+  #   Socket.tcp_server_loop(16807) {|sock, client_addrinfo|
+  #     begin
+  #       IO.copy_stream(sock, sock)
+  #     ensure
+  #       sock.close
+  #     end
+  #   }
+  #
+  #   # Threaded echo server
+  #   # It services multiple clients at a time.
+  #   # Note that it may accept connections too much.
+  #   Socket.tcp_server_loop(16807) {|sock, client_addrinfo|
+  #     Thread.new {
+  #       begin
+  #         IO.copy_stream(sock, sock)
+  #       ensure
+  #         sock.close
+  #       end
+  #     }
+  #   }
+  #
+  def self.tcp_server_loop(host=nil, port, &b) # :yield: socket, client_addrinfo
+    tcp_server_sockets(host, port) {|sockets|
+      accept_loop(sockets, &b)
+    }
+  end
+
+  # :call-seq:
+  #   Socket.udp_server_sockets([host, ] port)
+  #
+  # Creates UDP/IP sockets for a UDP server.
+  #
+  # If no block given, it returns an array of sockets.
+  #
+  # If a block is given, the block is called with the sockets.
+  # The value of the block is returned.
+  # The sockets are closed when this method returns.
+  #
+  # If _port_ is zero, some port is chosen.
+  # But the chosen port is used for the all sockets.
+  #
+  #   # UDP/IP echo server
+  #   Socket.udp_server_sockets(0) {|sockets|
+  #     p sockets.first.local_address.ip_port     #=> 32963
+  #     Socket.udp_server_loop_on(sockets) {|msg, msg_src|
+  #       msg_src.reply msg
+  #     }
+  #   }
+  #
+  def self.udp_server_sockets(host=nil, port)
+    last_error = nil
+    sockets = []
+
+    ipv6_recvpktinfo = nil
+    if defined? Socket::AncillaryData
+      if defined? Socket::IPV6_RECVPKTINFO # RFC 3542
+        ipv6_recvpktinfo = Socket::IPV6_RECVPKTINFO
+      elsif defined? Socket::IPV6_PKTINFO # RFC 2292
+        ipv6_recvpktinfo = Socket::IPV6_PKTINFO
+      end
+    end
+
+    local_addrs = Socket.ip_address_list
+
+    ip_list = []
+    Addrinfo.foreach(host, port, nil, :DGRAM, nil, Socket::AI_PASSIVE) {|ai|
+      if ai.ipv4? && ai.ip_address == "0.0.0.0"
+        local_addrs.each {|a|
+          next if !a.ipv4?
+          ip_list << Addrinfo.new(a.to_sockaddr, :INET, :DGRAM, 0);
+        }
+      elsif ai.ipv6? && ai.ip_address == "::" && !ipv6_recvpktinfo
+        local_addrs.each {|a|
+          next if !a.ipv6?
+          ip_list << Addrinfo.new(a.to_sockaddr, :INET6, :DGRAM, 0);
+        }
+      else
+        ip_list << ai
+      end
+    }
+
+    if port == 0
+      sockets = ip_sockets_port0(ip_list, false)
+    else
+      ip_list.each {|ip|
+        ai = Addrinfo.udp(ip.ip_address, port)
+        begin
+          s = ai.bind
+        rescue SystemCallError
+          last_error = $!
+          next
+        end
+        sockets << s
+      }
+      if sockets.empty?
+        raise last_error
+      end
+    end
+
+    sockets.each {|s|
+      ai = s.local_address
+      if ipv6_recvpktinfo && ai.ipv6? && ai.ip_address == "::"
+        s.setsockopt(:IPV6, ipv6_recvpktinfo, 1)
+      end
+    }
+
+    if block_given?
+      begin
+        yield sockets
+      ensure
+        sockets.each {|s| s.close if !s.closed? } if sockets
+      end
+    else
+      sockets
+    end
+  end
+
+  # :call-seq:
+  #   Socket.udp_server_recv(sockets) {|msg, msg_src| ... }
+  #
+  # Receive UDP/IP packets from the given _sockets_.
+  # For each packet received, the block is called.
+  #
+  # The block receives _msg_ and _msg_src_.
+  # _msg_ is a string which is the payload of the received packet.
+  # _msg_src_ is a Socket::UDPSource object which is used for reply.
+  #
+  # Socket.udp_server_loop can be implemented using this method as follows.
+  #
+  #   udp_server_sockets(host, port) {|sockets|
+  #     loop {
+  #       readable, _, _ = IO.select(sockets)
+  #       udp_server_recv(readable) {|msg, msg_src| ... }
+  #     }
+  #   }
+  #
+  def self.udp_server_recv(sockets)
+    sockets.each {|r|
+      begin
+        msg, sender_addrinfo, _, *controls = r.recvmsg_nonblock
+      rescue IO::WaitReadable
+        next
+      end
+      ai = r.local_address
+      if ai.ipv6? and pktinfo = controls.find {|c| c.cmsg_is?(:IPV6, :PKTINFO) }
+        ai = Addrinfo.udp(pktinfo.ipv6_pktinfo_addr.ip_address, ai.ip_port)
+        yield msg, UDPSource.new(sender_addrinfo, ai) {|reply_msg|
+          r.sendmsg reply_msg, 0, sender_addrinfo, pktinfo
+        }
+      else
+        yield msg, UDPSource.new(sender_addrinfo, ai) {|reply_msg|
+          r.send reply_msg, 0, sender_addrinfo
+        }
+      end
+    }
+  end
+
+  # :call-seq:
+  #   Socket.udp_server_loop_on(sockets) {|msg, msg_src| ... }
+  #
+  # Run UDP/IP server loop on the given sockets.
+  #
+  # The return value of Socket.udp_server_sockets is appropriate for the argument.
+  #
+  # It calls the block for each message received.
+  #
+  def self.udp_server_loop_on(sockets, &b) # :yield: msg, msg_src
+    loop {
+      readable, _, _ = IO.select(sockets)
+      udp_server_recv(readable, &b)
+    }
+  end
+
+  # :call-seq:
+  #   Socket.udp_server_loop(port) {|msg, msg_src| ... }
+  #   Socket.udp_server_loop(host, port) {|msg, msg_src| ... }
+  #
+  # creates a UDP/IP server on _port_ and calls the block for each message arrived.
+  # The block is called with the message and its source information.
+  #
+  # This method allocates sockets internally using _port_.
+  # If _host_ is specified, it is used conjunction with _port_ to determine the server addresses.
+  #
+  # The _msg_ is a string.
+  #
+  # The _msg_src_ is a Socket::UDPSource object.
+  # It is used for reply.
+  #
+  #   # UDP/IP echo server.
+  #   Socket.udp_server_loop(9261) {|msg, msg_src|
+  #     msg_src.reply msg
+  #   }
+  #
+  def self.udp_server_loop(host=nil, port, &b) # :yield: message, message_source
+    udp_server_sockets(host, port) {|sockets|
+      udp_server_loop_on(sockets, &b)
+    }
+  end
+
+  # UDP/IP address information used by Socket.udp_server_loop.
+  class UDPSource
+    # +remote_address+ is an Addrinfo object.
+    #
+    # +local_address+ is an Addrinfo object.
+    #
+    # +reply_proc+ is a Proc used to send reply back to the source.
+    def initialize(remote_address, local_address, &reply_proc)
+      @remote_address = remote_address
+      @local_address = local_address
+      @reply_proc = reply_proc
+    end
+
+    # Address of the source
+    attr_reader :remote_address
+
+    # Local address
+    attr_reader :local_address
+
+    def inspect # :nodoc:
+      "\#<#{self.class}: #{@remote_address.inspect_sockaddr} to #{@local_address.inspect_sockaddr}>"
+    end
+
+    # Sends the String +msg+ to the source
+    def reply(msg)
+      @reply_proc.call msg
+    end
+  end
+
+  # creates a new socket connected to path using UNIX socket socket.
+  #
+  # If a block is given, the block is called with the socket.
+  # The value of the block is returned.
+  # The socket is closed when this method returns.
+  #
+  # If no block is given, the socket is returned.
+  #
+  #   # talk to /tmp/sock socket.
+  #   Socket.unix("/tmp/sock") {|sock|
+  #     t = Thread.new { IO.copy_stream(sock, STDOUT) }
+  #     IO.copy_stream(STDIN, sock)
+  #     t.join
+  #   }
+  #
+  def self.unix(path) # :yield: socket
+    addr = Addrinfo.unix(path)
+    sock = addr.connect
+    if block_given?
+      begin
+        yield sock
+      ensure
+        sock.close if !sock.closed?
+      end
+    else
+      sock
+    end
+  end
+
+  # creates a UNIX server socket on _path_
+  #
+  # If no block given, it returns a listening socket.
+  #
+  # If a block is given, it is called with the socket and the block value is returned.
+  # When the block exits, the socket is closed and the socket file is removed.
+  #
+  #   socket = Socket.unix_server_socket("/tmp/s")
+  #   p socket                  #=> #<Socket:fd 3>
+  #   p socket.local_address    #=> #<Addrinfo: /tmp/s SOCK_STREAM>
+  #
+  #   Socket.unix_server_socket("/tmp/sock") {|s|
+  #     p s                     #=> #<Socket:fd 3>
+  #     p s.local_address       #=> # #<Addrinfo: /tmp/sock SOCK_STREAM>
+  #   }
+  #
+  def self.unix_server_socket(path)
+    if !unix_socket_abstract_name?(path)
+      begin
+        st = File.lstat(path)
+      rescue Errno::ENOENT
+      end
+      if st && st.socket? && st.owned?
+        File.unlink path
+      end
+    end
+    s = Addrinfo.unix(path).listen
+    if block_given?
+      begin
+        yield s
+      ensure
+        s.close if !s.closed?
+        if !unix_socket_abstract_name?(path)
+          File.unlink path
+        end
+      end
+    else
+      s
+    end
+  end
+
+  class << self
+    private
+
+    def unix_socket_abstract_name?(path)
+      /linux/ =~ RUBY_PLATFORM && /\A(\0|\z)/ =~ path
+    end
+  end
+
+  # creates a UNIX socket server on _path_.
+  # It calls the block for each socket accepted.
+  #
+  # If _host_ is specified, it is used with _port_ to determine the server ports.
+  #
+  # The socket is *not* closed when the block returns.
+  # So application should close it.
+  #
+  # This method deletes the socket file pointed by _path_ at first if
+  # the file is a socket file and it is owned by the user of the application.
+  # This is safe only if the directory of _path_ is not changed by a malicious user.
+  # So don't use /tmp/malicious-users-directory/socket.
+  # Note that /tmp/socket and /tmp/your-private-directory/socket is safe assuming that /tmp has sticky bit.
+  #
+  #   # Sequential echo server.
+  #   # It services only one client at a time.
+  #   Socket.unix_server_loop("/tmp/sock") {|sock, client_addrinfo|
+  #     begin
+  #       IO.copy_stream(sock, sock)
+  #     ensure
+  #       sock.close
+  #     end
+  #   }
+  #
+  def self.unix_server_loop(path, &b) # :yield: socket, client_addrinfo
+    unix_server_socket(path) {|serv|
+      accept_loop(serv, &b)
+    }
+  end
+
+end