rubysl-resolv 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0c986938060ce85ff5f500d024c015bb3fb76aac
-  data.tar.gz: 3adf0ca646fbbc18fff5f059f46fb27e6497de96
+  metadata.gz: 1f910ca03a2f2e7fc5ba345a15f7e35786dd07b5
+  data.tar.gz: 95ab27ed98857c6cc1055b92a6c47d008a9d3ec0
 SHA512:
-  metadata.gz: 2f96573ce73b14781b85f0a058ec9a0343b3f16edc9a6216821bd5d7a9a25a6be63815c2b05d589734c2b05cd24e1896114bd26ca84810752a6221d69eba9091
-  data.tar.gz: ad2990b751425197cc1be5f2cacd81f0940ec9ca397ac52c303796341e427e9f91cac3316f7c3bc6788a51763e8e62799200b071e182c0b748be490e2e5ed07f
+  metadata.gz: 8be3e9e9377c375c5bd7a88f3d6c48a7536af1fe6133e939b738f946af57525b6f70fc48993a015c1a5db04e440890bfbe78ce5dc22c9061c058b628ae18a24a
+  data.tar.gz: ec78bb44fc70c12de9caee8c9cfa7c9d8542f83b7eda0e43f7bd9dfa86ac38adafd6a7fba69c281993ce82673669534827584f3df96d0763ba28b69678ab387b

data/.travis.yml

@@ -3,5 +3,5 @@ env:
   - RUBYLIB=lib
 script: bundle exec mspec
 rvm:
-  - 1.8.7
-  - rbx-nightly-18mode
+  - 1.9.3
+  - rbx-nightly-19mode

data/lib/rubysl/resolv/resolv.rb

@@ -9,28 +9,28 @@ rescue LoadError
 end
 
 # Resolv is a thread-aware DNS resolver library written in Ruby.  Resolv can
-# handle multiple DNS requests concurrently without blocking.  The ruby
+# handle multiple DNS requests concurrently without blocking the entire ruby
 # interpreter.
 #
-# See also resolv-replace.rb to replace the libc resolver with # Resolv.
-# 
+# See also resolv-replace.rb to replace the libc resolver with Resolv.
+#
 # Resolv can look up various DNS resources using the DNS module directly.
-# 
+#
 # Examples:
-# 
+#
 #   p Resolv.getaddress "www.ruby-lang.org"
 #   p Resolv.getname "210.251.121.214"
-# 
+#
 #   Resolv::DNS.open do |dns|
 #     ress = dns.getresources "www.ruby-lang.org", Resolv::DNS::Resource::IN::A
 #     p ress.map { |r| r.address }
 #     ress = dns.getresources "ruby-lang.org", Resolv::DNS::Resource::IN::MX
 #     p ress.map { |r| [r.exchange.to_s, r.preference] }
 #   end
-# 
-# 
+#
+#
 # == Bugs
-# 
+#
 # * NIS is not supported.
 # * /etc/nsswitch.conf is not supported.
 
@@ -38,14 +38,14 @@ class Resolv
 
   ##
   # Looks up the first IP address for +name+.
-  
+
   def self.getaddress(name)
     DefaultResolver.getaddress(name)
   end
 
   ##
   # Looks up all IP address for +name+.
-  
+
   def self.getaddresses(name)
     DefaultResolver.getaddresses(name)
   end
@@ -87,7 +87,7 @@ class Resolv
 
   ##
   # Looks up the first IP address for +name+.
-  
+
   def getaddress(name)
     each_address(name) {|address| return address}
     raise ResolvError.new("no address for #{name}")
@@ -95,7 +95,7 @@ class Resolv
 
   ##
   # Looks up all IP address for +name+.
-  
+
   def getaddresses(name)
     ret = []
     each_address(name) {|address| ret << address}
@@ -162,10 +162,10 @@ class Resolv
   class ResolvTimeout < TimeoutError; end
 
   ##
-  # DNS::Hosts is a hostname resolver that uses the system hosts file.
+  # Resolv::Hosts is a hostname resolver that uses the system hosts file.
 
   class Hosts
-    if /mswin32|mingw|bccwin/ =~ RUBY_PLATFORM
+    if /mswin|mingw|bccwin/ =~ RUBY_PLATFORM
       require 'win32/resolv'
       DefaultFileName = Win32::Resolv.get_hosts_path
     else
@@ -173,7 +173,7 @@ class Resolv
     end
 
     ##
-    # Creates a new DNS::Hosts, using +filename+ for its data source.
+    # Creates a new Resolv::Hosts, using +filename+ for its data source.
 
     def initialize(filename = DefaultFileName)
       @filename = filename
@@ -289,11 +289,6 @@ class Resolv
 
     UDPSize = 512
 
-    ##
-    # Group of DNS resolver threads (obsolete)
-
-    DNSThreadGroup = ThreadGroup.new
-
     ##
     # Creates a new DNS resolver.  See Resolv::DNS.new for argument details.
     #
@@ -314,10 +309,20 @@ class Resolv
     # Creates a new DNS resolver.
     #
     # +config_info+ can be:
-    # 
+    #
     # nil:: Uses /etc/resolv.conf.
     # String:: Path to a file using /etc/resolv.conf's format.
     # Hash:: Must contain :nameserver, :search and :ndots keys.
+    # :nameserver_port can be used to specify port number of nameserver address.
+    #
+    # The value of :nameserver should be an address string or
+    # an array of address strings.
+    # - :nameserver => '8.8.8.8'
+    # - :nameserver => ['8.8.8.8', '8.8.4.4']
+    #
+    # The value of :nameserver_port should be an array of
+    # pair of nameserver address and port number.
+    # - :nameserver_port => [['8.8.8.8', 53], ['8.8.4.4', 53]]
     #
     # Example:
     #
@@ -331,6 +336,21 @@ class Resolv
       @initialized = nil
     end
 
+    # Sets the resolver timeouts.  This may be a single positive number
+    # or an array of positive numbers representing timeouts in seconds.
+    # If an array is specified, a DNS request will retry and wait for
+    # each successive interval in the array until a successful response
+    # is received.  Specifying +nil+ reverts to the default timeouts:
+    # [ 5, second = 5 * 2 / nameserver_count, 2 * second, 4 * second ]
+    #
+    # Example:
+    #
+    #   dns.timeouts = 3
+    #
+    def timeouts=(values)
+      @config.timeouts = values
+    end
+
     def lazy_initialize # :nodoc:
       @mutex.synchronize {
         unless @initialized
@@ -384,9 +404,21 @@ class Resolv
 
     def each_address(name)
       each_resource(name, Resource::IN::A) {|resource| yield resource.address}
-      each_resource(name, Resource::IN::AAAA) {|resource| yield resource.address}
+      if use_ipv6?
+        each_resource(name, Resource::IN::AAAA) {|resource| yield resource.address}
+      end
     end
 
+    def use_ipv6? # :nodoc:
+      begin
+        list = Socket.ip_address_list
+      rescue NotImplementedError
+        return true
+      end
+      list.any? {|a| a.ipv6? && !a.ipv6_loopback? && !a.ipv6_linklocal? }
+    end
+    private :use_ipv6?
+
     ##
     # Gets the hostname for +address+ from the DNS resolver.
     #
@@ -462,7 +494,7 @@ class Resolv
     ##
     # Looks up all +typeclass+ DNS resources for +name+.  See #getresource for
     # argument details.
-  
+
     def getresources(name, typeclass)
       ret = []
       each_resource(name, typeclass) {|resource| ret << resource}
@@ -472,24 +504,36 @@ class Resolv
     ##
     # Iterates over all +typeclass+ DNS resources for +name+.  See
     # #getresource for argument details.
-  
+
     def each_resource(name, typeclass, &proc)
       lazy_initialize
-      requester = make_requester
+      requester = make_udp_requester
       senders = {}
       begin
-        @config.resolv(name) {|candidate, tout, nameserver|
+        @config.resolv(name) {|candidate, tout, nameserver, port|
           msg = Message.new
           msg.rd = 1
           msg.add_question(candidate, typeclass)
-          unless sender = senders[[candidate, nameserver]]
-            sender = senders[[candidate, nameserver]] =
-              requester.sender(msg, candidate, nameserver)
+          unless sender = senders[[candidate, nameserver, port]]
+            sender = senders[[candidate, nameserver, port]] =
+              requester.sender(msg, candidate, nameserver, port)
           end
           reply, reply_name = requester.request(sender, tout)
           case reply.rcode
           when RCode::NoError
-            extract_resources(reply, reply_name, typeclass, &proc)
+            if reply.tc == 1 and not Requester::TCP === requester
+              requester.close
+              # Retry via TCP:
+              requester = make_tcp_requester(nameserver, port)
+              senders = {}
+              # This will use TCP for all remaining candidates (assuming the
+              # current candidate does not already respond successfully via
+              # TCP).  This makes sense because we already know the full
+              # response will not fit in an untruncated UDP packet.
+              redo
+            else
+              extract_resources(reply, reply_name, typeclass, &proc)
+            end
             return
           when RCode::NXDomain
             raise Config::NXDomain.new(reply_name.to_s)
@@ -502,14 +546,19 @@ class Resolv
       end
     end
 
-    def make_requester # :nodoc:
-      if nameserver = @config.single?
-        Requester::ConnectedUDP.new(nameserver)
+    def make_udp_requester # :nodoc:
+      nameserver_port = @config.nameserver_port
+      if nameserver_port.length == 1
+        Requester::ConnectedUDP.new(*nameserver_port[0])
       else
-        Requester::UnconnectedUDP.new
+        Requester::UnconnectedUDP.new(*nameserver_port)
       end
     end
 
+    def make_tcp_requester(host, port) # :nodoc:
+      return Requester::TCP.new(host, port)
+    end
+
     def extract_resources(msg, name, typeclass) # :nodoc:
       if typeclass < Resource::ANY
         n0 = Name.create(name)
@@ -565,8 +614,8 @@ class Resolv
       base + random(len)
     end
 
-    RequestID = {}
-    RequestIDMutex = Mutex.new
+    RequestID = {} # :nodoc:
+    RequestIDMutex = Mutex.new # :nodoc:
 
     def self.allocate_request_id(host, port) # :nodoc:
       id = nil
@@ -574,7 +623,7 @@ class Resolv
         h = (RequestID[[host, port]] ||= {})
         begin
           id = rangerand(0x0000..0xffff)
-        end while h[id] 
+        end while h[id]
         h[id] = true
       }
       id
@@ -592,10 +641,10 @@ class Resolv
       }
     end
 
-    def self.bind_random_port(udpsock) # :nodoc:
+    def self.bind_random_port(udpsock, bind_host="0.0.0.0") # :nodoc:
       begin
         port = rangerand(1024..65535)
-        udpsock.bind("", port)
+        udpsock.bind(bind_host, port)
       rescue Errno::EADDRINUSE
         retry
       end
@@ -604,18 +653,33 @@ class Resolv
     class Requester # :nodoc:
       def initialize
         @senders = {}
-        @sock = nil
+        @socks = nil
       end
 
       def request(sender, tout)
-        timelimit = Time.now + tout
+        start = Time.now
+        timelimit = start + tout
         sender.send
-        while (now = Time.now) < timelimit
-          timeout = timelimit - now
-          if !IO.select([@sock], nil, nil, timeout)
+        while true
+          before_select = Time.now
+          timeout = timelimit - before_select
+          if timeout <= 0
+            raise ResolvTimeout
+          end
+          select_result = IO.select(@socks, nil, nil, timeout)
+          if !select_result
+            after_select = Time.now
+            next if after_select < timelimit
+            raise ResolvTimeout
+          end
+          begin
+            reply, from = recv_reply(select_result[0])
+          rescue Errno::ECONNREFUSED, # GNU/Linux, FreeBSD
+                 Errno::ECONNRESET # Windows
+            # No name server running on the server?
+            # Don't wait anymore.
             raise ResolvTimeout
           end
-          reply, from = recv_reply
           begin
             msg = Message.decode(reply)
           rescue DecodeError
@@ -631,9 +695,11 @@ class Resolv
       end
 
       def close
-        sock = @sock
-        @sock = nil
-        sock.close if sock
+        socks = @socks
+        @socks = nil
+        if socks
+          socks.each {|sock| sock.close }
+        end
       end
 
       class Sender # :nodoc:
@@ -645,15 +711,31 @@ class Resolv
       end
 
       class UnconnectedUDP < Requester # :nodoc:
-        def initialize
+        def initialize(*nameserver_port)
           super()
-          @sock = UDPSocket.new
-          @sock.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) if defined? Fcntl::F_SETFD
-          DNS.bind_random_port(@sock)
+          @nameserver_port = nameserver_port
+          @socks_hash = {}
+          @socks = []
+          nameserver_port.each {|host, port|
+            if host.index(':')
+              bind_host = "::"
+              af = Socket::AF_INET6
+            else
+              bind_host = "0.0.0.0"
+              af = Socket::AF_INET
+            end
+            next if @socks_hash[bind_host]
+            sock = UDPSocket.new(af)
+            sock.do_not_reverse_lookup = true
+            sock.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) if defined? Fcntl::F_SETFD
+            DNS.bind_random_port(sock, bind_host)
+            @socks << sock
+            @socks_hash[bind_host] = sock
+          }
         end
 
-        def recv_reply
-          reply, from = @sock.recvfrom(UDPSize)
+        def recv_reply(readable_socks)
+          reply, from = readable_socks[0].recvfrom(UDPSize)
           return reply, [from[3],from[1]]
         end
 
@@ -662,8 +744,9 @@ class Resolv
           id = DNS.allocate_request_id(host, port)
           request = msg.encode
           request[0,2] = [id].pack('n')
+          sock = @socks_hash[host.index(':') ? "::" : "0.0.0.0"]
           return @senders[[service, id]] =
-            Sender.new(request, data, @sock, host, port)
+            Sender.new(request, data, sock, host, port)
         end
 
         def close
@@ -692,14 +775,17 @@ class Resolv
           super()
           @host = host
           @port = port
-          @sock = UDPSocket.new(host.index(':') ? Socket::AF_INET6 : Socket::AF_INET)
-          DNS.bind_random_port(@sock)
-          @sock.connect(host, port)
-          @sock.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) if defined? Fcntl::F_SETFD
+          is_ipv6 = host.index(':')
+          sock = UDPSocket.new(is_ipv6 ? Socket::AF_INET6 : Socket::AF_INET)
+          @socks = [sock]
+          sock.do_not_reverse_lookup = true
+          sock.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) if defined? Fcntl::F_SETFD
+          DNS.bind_random_port(sock, is_ipv6 ? "::" : "0.0.0.0")
+          sock.connect(host, port)
         end
 
-        def recv_reply
-          reply = @sock.recv(UDPSize)
+        def recv_reply(readable_socks)
+          reply = readable_socks[0].recv(UDPSize)
           return reply, nil
         end
 
@@ -710,7 +796,7 @@ class Resolv
           id = DNS.allocate_request_id(@host, @port)
           request = msg.encode
           request[0,2] = [id].pack('n')
-          return @senders[[nil,id]] = Sender.new(request, data, @sock)
+          return @senders[[nil,id]] = Sender.new(request, data, @socks[0])
         end
 
         def close
@@ -733,14 +819,15 @@ class Resolv
           super()
           @host = host
           @port = port
-          @sock = TCPSocket.new(@host, @port)
-          @sock.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) if defined? Fcntl::F_SETFD
+          sock = TCPSocket.new(@host, @port)
+          @socks = [sock]
+          sock.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) if defined? Fcntl::F_SETFD
           @senders = {}
         end
 
-        def recv_reply
-          len = @sock.read(2).unpack('n')[0]
-          reply = @sock.read(len)
+        def recv_reply(readable_socks)
+          len = readable_socks[0].read(2).unpack('n')[0]
+          reply = @socks[0].read(len)
           return reply, nil
         end
 
@@ -751,7 +838,7 @@ class Resolv
           id = DNS.allocate_request_id(@host, @port)
           request = msg.encode
           request[0,2] = [request.length, id].pack('nn')
-          return @senders[[nil,id]] = Sender.new(request, data, @sock)
+          return @senders[[nil,id]] = Sender.new(request, data, @socks[0])
         end
 
         class Sender < Requester::Sender # :nodoc:
@@ -782,6 +869,20 @@ class Resolv
         @mutex = Mutex.new
         @config_info = config_info
         @initialized = nil
+        @timeouts = nil
+      end
+
+      def timeouts=(values)
+        if values
+          values = Array(values)
+          values.each do |t|
+            Numeric === t or raise ArgumentError, "#{t.inspect} is not numeric"
+            t > 0.0 or raise ArgumentError, "timeout=#{t} must be postive"
+          end
+          @timeouts = values
+        else
+          @timeouts = nil
+        end
       end
 
       def Config.parse_resolv_conf(filename)
@@ -822,7 +923,7 @@ class Resolv
         if File.exist? filename
           config_hash = Config.parse_resolv_conf(filename)
         else
-          if /mswin32|cygwin|mingw|bccwin/ =~ RUBY_PLATFORM
+          if /mswin|cygwin|mingw|bccwin/ =~ RUBY_PLATFORM
             require 'win32/resolv'
             search, nameserver = Win32::Resolv.get_resolv_info
             config_hash = {}
@@ -830,13 +931,13 @@ class Resolv
             config_hash[:search] = [search].flatten if search
           end
         end
-        config_hash
+        config_hash || {}
       end
 
       def lazy_initialize
         @mutex.synchronize {
           unless @initialized
-            @nameserver = []
+            @nameserver_port = []
             @search = nil
             @ndots = 1
             case @config_info
@@ -855,11 +956,18 @@ class Resolv
             else
               raise ArgumentError.new("invalid resolv configuration: #{@config_info.inspect}")
             end
-            @nameserver = config_hash[:nameserver] if config_hash.include? :nameserver
+            if config_hash.include? :nameserver
+              @nameserver_port = config_hash[:nameserver].map {|ns| [ns, Port] }
+            end
+            if config_hash.include? :nameserver_port
+              @nameserver_port = config_hash[:nameserver_port].map {|ns, port| [ns, (port || Port)] }
+            end
             @search = config_hash[:search] if config_hash.include? :search
             @ndots = config_hash[:ndots] if config_hash.include? :ndots
 
-            @nameserver = ['0.0.0.0'] if @nameserver.empty?
+            if @nameserver_port.empty?
+              @nameserver_port << ['0.0.0.0', Port]
+            end
             if @search
               @search = @search.map {|arg| Label.split(arg) }
             else
@@ -871,9 +979,14 @@ class Resolv
               end
             end
 
-            if !@nameserver.kind_of?(Array) ||
-               !@nameserver.all? {|ns| String === ns }
-              raise ArgumentError.new("invalid nameserver config: #{@nameserver.inspect}")
+            if !@nameserver_port.kind_of?(Array) ||
+               @nameserver_port.any? {|ns_port|
+                  !(Array === ns_port) ||
+                  ns_port.length != 2
+                  !(String === ns_port[0]) ||
+                  !(Integer === ns_port[1])
+               }
+              raise ArgumentError.new("invalid nameserver config: #{@nameserver_port.inspect}")
             end
 
             if !@search.kind_of?(Array) ||
@@ -893,13 +1006,17 @@ class Resolv
 
       def single?
         lazy_initialize
-        if @nameserver.length == 1
-          return @nameserver[0]
+        if @nameserver_port.length == 1
+          return @nameserver_port[0]
         else
           return nil
         end
       end
 
+      def nameserver_port
+        @nameserver_port
+      end
+
       def generate_candidates(name)
         candidates = nil
         name = Name.create(name)
@@ -920,7 +1037,7 @@ class Resolv
 
       def generate_timeouts
         ts = [InitialTimeout]
-        ts << ts[-1] * 2 / @nameserver.length
+        ts << ts[-1] * 2 / @nameserver_port.length
         ts << ts[-1] * 2
         ts << ts[-1] * 2
         return ts
@@ -928,14 +1045,14 @@ class Resolv
 
       def resolv(name)
         candidates = generate_candidates(name)
-        timeouts = generate_timeouts
+        timeouts = @timeouts || generate_timeouts
         begin
           candidates.each {|candidate|
             begin
               timeouts.each {|tout|
-                @nameserver.each {|nameserver|
+                @nameserver_port.each {|nameserver, port|
                   begin
-                    yield candidate, tout, nameserver
+                    yield candidate, tout, nameserver, port
                   rescue ResolvTimeout
                   end
                 }
@@ -1042,7 +1159,7 @@ class Resolv
     # A representation of a DNS name.
 
     class Name
-      
+
       ##
       # Creates a new DNS name from +arg+.  +arg+ can be:
       #
@@ -1353,6 +1470,10 @@ class Resolv
           yield self
         end
 
+        def inspect
+          "\#<#{self.class}: #{@data[0, @index].inspect} #{@data[@index..-1].inspect}>"
+        end
+
         def get_length16
           len, = self.get_unpack('n')
           save_limit = @limit
@@ -1376,6 +1497,7 @@ class Resolv
         def get_unpack(template)
           len = 0
           template.each_byte {|byte|
+            byte = "%c" % byte
             case byte
             when ?c, ?C
               len += 1
@@ -1394,7 +1516,7 @@ class Resolv
         end
 
         def get_string
-          len = @data[@index]
+          len = @data[@index].ord
           raise DecodeError.new("limit exceeded") if @limit < @index + 1 + len
           d = @data[@index + 1, len]
           @index += 1 + len
@@ -1417,7 +1539,7 @@ class Resolv
           limit = @index if !limit || @index < limit
           d = []
           while true
-            case @data[@index]
+            case @data[@index].ord
             when 0
               @index += 1
               return d
@@ -1452,7 +1574,9 @@ class Resolv
           name = self.get_name
           type, klass, ttl = self.get_unpack('nnN')
           typeclass = Resource.get_class(type, klass)
-          return name, ttl, self.get_length16 {typeclass.decode_rdata(self)}
+          res = self.get_length16 { typeclass.decode_rdata self }
+          res.instance_variable_set :@ttl, ttl
+          return name, ttl, res
         end
       end
     end
@@ -1462,11 +1586,11 @@ class Resolv
 
     class Query
       def encode_rdata(msg) # :nodoc:
-        raise EncodeError.new("#{self.class} is query.") 
+        raise EncodeError.new("#{self.class} is query.")
       end
 
       def self.decode_rdata(msg) # :nodoc:
-        raise DecodeError.new("#{self.class} is query.") 
+        raise DecodeError.new("#{self.class} is query.")
       end
     end
 
@@ -1491,10 +1615,16 @@ class Resolv
       end
 
       def ==(other) # :nodoc:
-        return self.class == other.class &&
-          self.instance_variables == other.instance_variables &&
-          self.instance_variables.collect {|name| self.instance_eval name} ==
-            other.instance_variables.collect {|name| other.instance_eval name}
+        return false unless self.class == other.class
+        s_ivars = self.instance_variables
+        s_ivars.sort!
+        s_ivars.delete "@ttl"
+        o_ivars = other.instance_variables
+        o_ivars.sort!
+        o_ivars.delete "@ttl"
+        return s_ivars == o_ivars &&
+          s_ivars.collect {|name| self.instance_variable_get name} ==
+            o_ivars.collect {|name| other.instance_variable_get name}
       end
 
       def eql?(other) # :nodoc:
@@ -1503,8 +1633,10 @@ class Resolv
 
       def hash # :nodoc:
         h = 0
-        self.instance_variables.each {|name|
-          h ^= self.instance_eval("#{name}.hash")
+        vars = self.instance_variables
+        vars.delete "@ttl"
+        vars.each {|name|
+          h ^= self.instance_variable_get(name).hash
         }
         return h
       end
@@ -1933,7 +2065,7 @@ class Resolv
           def initialize(address)
             @address = IPv6.create(address)
           end
-          
+
           ##
           # The Resolv::IPv6 address for this AAAA.
 
@@ -1950,7 +2082,7 @@ class Resolv
 
         ##
         # SRV resource record defined in RFC 2782
-        # 
+        #
         # These records identify the hostname and port that a service is
         # available at.
 
@@ -2033,7 +2165,11 @@ class Resolv
     ##
     # Regular expression IPv4 addresses must match.
 
-    Regex = /\A(\d+)\.(\d+)\.(\d+)\.(\d+)\z/
+    Regex256 = /0
+               |1(?:[0-9][0-9]?)?
+               |2(?:[0-4][0-9]?|5[0-5]?|[6-9])?
+               |[3-9][0-9]?/x
+    Regex = /\A(#{Regex256})\.(#{Regex256})\.(#{Regex256})\.(#{Regex256})\z/
 
     def self.create(arg)
       case arg
@@ -2054,8 +2190,11 @@ class Resolv
     end
 
     def initialize(address) # :nodoc:
-      unless address.kind_of?(String) && address.length == 4
-        raise ArgumentError.new('IPv4 address must be 4 bytes')
+      unless address.kind_of?(String)
+        raise ArgumentError, 'IPv4 address must be a string'
+      end
+      unless address.length == 4
+        raise ArgumentError, "IPv4 address expects 4 bytes but #{address.length} bytes"
       end
       @address = address
     end

data/lib/rubysl/resolv/version.rb

@@ -1,5 +1,5 @@
 module RubySL
   module Resolv
-    VERSION = "1.0.0"
+    VERSION = "2.0.0"
   end
 end

data/rubysl-resolv.gemspec

@@ -16,6 +16,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.required_ruby_version = "~> 2.0"
+
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "mspec", "~> 1.5"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubysl-resolv
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Brian Shirai
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-27 00:00:00.000000000 Z
+date: 2013-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -84,9 +84,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ~>
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='