Remove some code duplication for guessing IP addresses.
[oddments/ddns.git] / src / ddns / system.py
index 8fa5c42..08df265 100644 (file)
 
 import base64
 import re
+import socket
 import urllib
 import urllib2
 
 from __version__ import CLIENT_VERSION
+from .errors import *
 from i18n import _
 
 # Initialize the logger.
@@ -55,12 +57,17 @@ class DDNSSystem(object):
 
                return proxy
 
-       def guess_external_ipv6_address(self):
+       def _guess_external_ip_address(self, url, timeout=10):
                """
                        Sends a request to an external web server
                        to determine the current default IP address.
                """
-               response = self.send_request("http://checkip6.dns.lightningwirelabs.com")
+               try:
+                       response = self.send_request(url, timeout=timeout)
+
+               # If the server could not be reached, we will return nothing.
+               except DDNSNetworkError:
+                       return
 
                if not response.code == 200:
                        return
@@ -71,21 +78,19 @@ class DDNSSystem(object):
 
                return match.group(1)
 
-       def guess_external_ipv4_address(self):
+       def guess_external_ipv6_address(self):
                """
                        Sends a request to the internet to determine
-                       the public IP address.
-
-                       XXX does not work for IPv6.
+                       the public IPv6 address.
                """
-               response = self.send_request("http://checkip4.dns.lightningwirelabs.com")
-
-               if response.code == 200:
-                       match = re.search(r"Your IP address is: (\d+.\d+.\d+.\d+)", response.read())
-                       if match is None:
-                               return
+               return self._guess_external_ip_address("http://checkip6.dns.lightningwirelabs.com")
 
-                       return match.group(1)
+       def guess_external_ipv4_address(self):
+               """
+                       Sends a request to the internet to determine
+                       the public IPv4 address.
+               """
+               return self._guess_external_ip_address("http://checkip4.dns.lightningwirelabs.com")
 
        def send_request(self, url, method="GET", data=None, username=None, password=None, timeout=30):
                assert method in ("GET", "POST")
@@ -128,7 +133,7 @@ class DDNSSystem(object):
                        logger.debug("  %s: %s" % (k, v))
 
                try:
-                       resp = urllib2.urlopen(req)
+                       resp = urllib2.urlopen(req, timeout=timeout)
 
                        # Log response header.
                        logger.debug(_("Response header:"))
@@ -138,9 +143,30 @@ class DDNSSystem(object):
                        # Return the entire response object.
                        return resp
 
+               except urllib2.HTTPError, e:
+                       # 503 - Service Unavailable
+                       if e.code == 503:
+                               raise DDNSServiceUnavailableError
+
+                       # Raise all other unhandled exceptions.
+                       raise
+
                except urllib2.URLError, e:
+                       if e.reason:
+                               # Network Unreachable (e.g. no IPv6 access)
+                               if e.reason.errno == 101:
+                                       raise DDNSNetworkUnreachableError
+                               elif e.reason.errno == 111:
+                                       raise DDNSConnectionRefusedError
+
+                       # Raise all other unhandled exceptions.
                        raise
 
+               except socket.timeout, e:
+                       logger.debug(_("Connection timeout"))
+
+                       raise DDNSConnectionTimeoutError
+
        def _format_query_args(self, data):
                args = []
 
@@ -179,3 +205,49 @@ class DDNSSystem(object):
 
                # XXX TODO
                assert False
+
+       def resolve(self, hostname, proto=None):
+               addresses = []
+
+               if proto is None:
+                       family = 0
+               elif proto == "ipv6":
+                       family = socket.AF_INET6
+               elif proto == "ipv4":
+                       family = socket.AF_INET
+               else:
+                       raise ValueError("Protocol not supported: %s" % proto)
+
+               # Resolve the host address.
+               try:
+                       response = socket.getaddrinfo(hostname, None, family)
+               except socket.gaierror, e:
+                       # Name or service not known
+                       if e.errno == -2:
+                               return []
+
+                       raise
+
+               # Handle responses.
+               for family, socktype, proto, canonname, sockaddr in response:
+                       # IPv6
+                       if family == socket.AF_INET6:
+                               address, port, flow_info, scope_id = sockaddr
+
+                               # Only use the global scope.
+                               if not scope_id == 0:
+                                       continue
+
+                       # IPv4
+                       elif family == socket.AF_INET:
+                               address, port = sockaddr
+
+                       # Ignore everything else...
+                       else:
+                               continue
+
+                       # Add to repsonse list if not already in there.
+                       if not address in addresses:
+                               addresses.append(address)
+
+               return addresses