Lookup public IP using HTTP

Both OpenDNS and Google DNS has problems looking up the public IP on
IPv6 connections. Lookup up using HTTP (TCP) seems more stable. The
lookup time is about 110ms longer with this mechanism.

checkip.amazonaws.com for now only resolvs to IPv4 addresses. If that
would change we would need to lookup the A address of the domain and
connect to that IP manually. It's like 2 more lines of code only, if
connect_timeout isn't needed, then it's a bit more involved.

Author: carlhoerberg

lib/sparoid.rb

@@ -149,9 +149,21 @@ def write_cache
     end
   end
 
-  def public_ip
-    Resolv::DNS.open(nameserver: ["208.67.222.222", "208.67.220.220"]) do |dns|
-      dns.getresource("myip.opendns.com", Resolv::DNS::Resource::IN::A).address
+  def public_ip(host = "checkip.amazonaws.com", port = 80) # rubocop:disable Metrics/MethodLength
+    Socket.tcp(host, port, connect_timeout: 3) do |sock|
+      sock.sync = true
+      sock.print "GET / HTTP/1.1\r\nHost: #{host}\r\nConnection: close\r\n\r\n"
+      status = sock.readline(chomp: true)
+      raise(ResolvError, "#{host}:#{port} response: #{status}") unless status.start_with? "HTTP/1.1 200 "
+
+      content_length = 0
+      until (header = sock.readline(chomp: true)).empty?
+        if (m = header.match(/^Content-Length: (\d+)/))
+          content_length = m[1].to_i
+        end
+      end
+      ip = sock.read(content_length).chomp
+      Resolv::IPv4.create ip
     end
   end
 
@@ -172,9 +184,7 @@ class ResolvError < Error; end
   class Instance
     include Sparoid
 
-    private
-
-    def public_ip
+    def public_ip(*args)
       @public_ip ||= super
     end
 

test/sparoid_test.rb

@@ -61,26 +61,41 @@ def test_it_sends_message_with_empty_cache_file
     end
   end
 
-  def test_it_resolves_public_ip_only_once_per_instance
-    dns = Minitest::Mock.new
-    dns.expect :getresource, Resolv::IPv4.create("1.1.1.1"), ["myip.opendns.com", Resolv::DNS::Resource::IN::A]
-    Resolv::DNS.stub(:open, ->(_, &blk) { blk.call dns }) do
-      s = Sparoid::Instance.new
-      2.times do
-        s.send(:public_ip)
-      end
+  def test_it_resolves_public_ip_only_once_per_instance # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    server = TCPServer.new "127.0.0.1", 0
+    host = server.addr[3]
+    port = server.addr[1]
+    Thread.new do
+      client = server.accept
+      client_ip = client.addr[3]
+      assert_equal "GET / HTTP/1.1", client.readline(chomp: true)
+      assert_match "Host: ", client.readline(chomp: true)
+      assert_equal "Connection: close", client.readline(chomp: true)
+
+      client.print "HTTP/1.1 200 OK\r\n"
+      client.print "Content-Length: #{client_ip.bytesize}\r\n"
+      client.print "\r\n"
+      client.print client_ip
+      client.close
+      server.close
+    end
+
+    s = Sparoid::Instance.new
+    2.times do
+      ip = s.public_ip host, port
+      assert_equal Resolv::IPv4.create("127.0.0.1"), ip
     end
-    dns.verify
   end
 
   def test_it_raises_resolve_error_on_dns_socket_error
     key = "0000000000000000000000000000000000000000000000000000000000000000"
     hmac_key = "0000000000000000000000000000000000000000000000000000000000000000"
+    open_for_ip = Resolv::IPv4.create("1.1.1.1")
     error = ->(*_) { raise SocketError, "getaddrinfo: Name or service not known" }
 
     Addrinfo.stub(:getaddrinfo, error) do
       assert_raises(Sparoid::ResolvError) do
-        Sparoid::Instance.new.auth(key, hmac_key, "127.0.0.1", 1337)
+        Sparoid::Instance.new.auth(key, hmac_key, "127.0.0.1", 1337, open_for_ip: open_for_ip)
       end
     end
   end