namecheap: Fix undeclared variable.
[ddns.git] / src / ddns / providers.py
index ece4b37..6ac5564 100644 (file)
 #                                                                             #
 ###############################################################################
 
+import datetime
 import logging
+import os
+import subprocess
 import urllib2
 import xml.dom.minidom
 
@@ -31,25 +34,69 @@ from .errors import *
 logger = logging.getLogger("ddns.providers")
 logger.propagate = 1
 
+_providers = {}
+
+def get():
+       """
+               Returns a dict with all automatically registered providers.
+       """
+       return _providers.copy()
+
 class DDNSProvider(object):
-       INFO = {
-               # A short string that uniquely identifies
-               # this provider.
-               "handle"    : None,
+       # A short string that uniquely identifies
+       # this provider.
+       handle = None
 
-               # The full name of the provider.
-               "name"      : None,
+       # The full name of the provider.
+       name = None
 
-               # A weburl to the homepage of the provider.
-               # (Where to register a new account?)
-               "website"   : None,
+       # A weburl to the homepage of the provider.
+       # (Where to register a new account?)
+       website = None
 
-               # A list of supported protocols.
-               "protocols" : ["ipv6", "ipv4"],
-       }
+       # A list of supported protocols.
+       protocols = ("ipv6", "ipv4")
 
        DEFAULT_SETTINGS = {}
 
+       # holdoff time - Number of days no update is performed unless
+       # the IP address has changed.
+       holdoff_days = 30
+
+       # holdoff time for update failures - Number of days no update
+       # is tried after the last one has failed.
+       holdoff_failure_days = 0.5
+
+       # True if the provider is able to remove records, too.
+       # Required to remove AAAA records if IPv6 is absent again.
+       can_remove_records = True
+
+       # Automatically register all providers.
+       class __metaclass__(type):
+               def __init__(provider, name, bases, dict):
+                       type.__init__(provider, name, bases, dict)
+
+                       # The main class from which is inherited is not registered
+                       # as a provider.
+                       if name == "DDNSProvider":
+                               return
+
+                       if not all((provider.handle, provider.name, provider.website)):
+                               raise DDNSError(_("Provider is not properly configured"))
+
+                       assert not _providers.has_key(provider.handle), \
+                               "Provider '%s' has already been registered" % provider.handle
+
+                       _providers[provider.handle] = provider
+
+       @staticmethod
+       def supported():
+               """
+                       Should be overwritten to check if the system the code is running
+                       on has all the required tools to support this provider.
+               """
+               return True
+
        def __init__(self, core, **settings):
                self.core = core
 
@@ -65,26 +112,8 @@ class DDNSProvider(object):
                return cmp(self.hostname, other.hostname)
 
        @property
-       def name(self):
-               """
-                       Returns the name of the provider.
-               """
-               return self.INFO.get("name")
-
-       @property
-       def website(self):
-               """
-                       Returns the website URL of the provider
-                       or None if that is not available.
-               """
-               return self.INFO.get("website", None)
-
-       @property
-       def handle(self):
-               """
-                       Returns the handle of this provider.
-               """
-               return self.INFO.get("handle")
+       def db(self):
+               return self.core.db
 
        def get(self, key, default=None):
                """
@@ -113,10 +142,6 @@ class DDNSProvider(object):
                """
                return self.get("password")
 
-       @property
-       def protocols(self):
-               return self.INFO.get("protocols")
-
        @property
        def token(self):
                """
@@ -126,20 +151,119 @@ class DDNSProvider(object):
 
        def __call__(self, force=False):
                if force:
-                       logger.info(_("Updating %s forced") % self.hostname)
+                       logger.debug(_("Updating %s forced") % self.hostname)
 
-               # Check if we actually need to update this host.
-               elif self.is_uptodate(self.protocols):
-                       logger.info(_("%s is already up to date") % self.hostname)
+               # Do nothing if the last update has failed or no update is required
+               elif self.has_failure or not self.requires_update:
                        return
 
                # Execute the update.
-               self.update()
+               try:
+                       self.update()
+
+               # 1) Catch network errors early, because we do not want to log
+               # them to the database. They are usually temporary and caused
+               # by the client side, so that we will retry quickly.
+               # 2) If there is an internet server error (HTTP code 500) on the
+               # provider's site, we will not log a failure and try again
+               # shortly.
+               except (DDNSNetworkError, DDNSInternalServerError):
+                       raise
+
+               # In case of any errors, log the failed request and
+               # raise the exception.
+               except DDNSError as e:
+                       self.core.db.log_failure(self.hostname, e)
+                       raise
+
+               logger.info(_("Dynamic DNS update for %(hostname)s (%(provider)s) successful") % \
+                       { "hostname" : self.hostname, "provider" : self.name })
+               self.core.db.log_success(self.hostname)
 
        def update(self):
+               for protocol in self.protocols:
+                       if self.have_address(protocol):
+                               self.update_protocol(protocol)
+                       elif self.can_remove_records:
+                               self.remove_protocol(protocol)
+
+       def update_protocol(self, proto):
                raise NotImplementedError
 
-       def is_uptodate(self, protos):
+       def remove_protocol(self, proto):
+               if not self.can_remove_records:
+                       raise RuntimeError, "can_remove_records is enabled, but remove_protocol() not implemented"
+
+               raise NotImplementedError
+
+       @property
+       def requires_update(self):
+               # If the IP addresses have changed, an update is required
+               if self.ip_address_changed(self.protocols):
+                       logger.debug(_("An update for %(hostname)s (%(provider)s)"
+                               " is performed because of an IP address change") % \
+                               { "hostname" : self.hostname, "provider" : self.name })
+
+                       return True
+
+               # If the holdoff time has expired, an update is required, too
+               if self.holdoff_time_expired():
+                       logger.debug(_("An update for %(hostname)s (%(provider)s)"
+                               " is performed because the holdoff time has expired") % \
+                               { "hostname" : self.hostname, "provider" : self.name })
+
+                       return True
+
+               # Otherwise, we don't need to perform an update
+               logger.debug(_("No update required for %(hostname)s (%(provider)s)") % \
+                       { "hostname" : self.hostname, "provider" : self.name })
+
+               return False
+
+       @property
+       def has_failure(self):
+               """
+                       Returns True when the last update has failed and no retry
+                       should be performed, yet.
+               """
+               last_status = self.db.last_update_status(self.hostname)
+
+               # Return False if the last update has not failed.
+               if not last_status == "failure":
+                       return False
+
+               # If there is no holdoff time, we won't update ever again.
+               if self.holdoff_failure_days is None:
+                       logger.warning(_("An update has not been performed because earlier updates failed for %s") \
+                               % self.hostname)
+                       logger.warning(_("There will be no retries"))
+
+                       return True
+
+               # Determine when the holdoff time ends
+               last_update = self.db.last_update(self.hostname, status=last_status)
+               holdoff_end = last_update + datetime.timedelta(days=self.holdoff_failure_days)
+
+               now = datetime.datetime.utcnow()
+               if now < holdoff_end:
+                       failure_message = self.db.last_update_failure_message(self.hostname)
+
+                       logger.warning(_("An update has not been performed because earlier updates failed for %s") \
+                               % self.hostname)
+
+                       if failure_message:
+                               logger.warning(_("Last failure message:"))
+
+                               for line in failure_message.splitlines():
+                                       logger.warning("  %s" % line)
+
+                       logger.warning(_("Further updates will be withheld until %s") % holdoff_end)
+
+                       return True
+
+               return False
+
+       def ip_address_changed(self, protos):
                """
                        Returns True if this host is already up to date
                        and does not need to change the IP address on the
@@ -147,18 +271,53 @@ class DDNSProvider(object):
                """
                for proto in protos:
                        addresses = self.core.system.resolve(self.hostname, proto)
-
                        current_address = self.get_address(proto)
 
-                       # If no addresses for the given protocol exist, we
-                       # are fine...
-                       if current_address is None and not addresses:
+                       # Handle if the system has not got any IP address from a protocol
+                       # (i.e. had full dual-stack connectivity which it has not any more)
+                       if current_address is None:
+                               # If addresses still exists in the DNS system and if this provider
+                               # is able to remove records, we will do that.
+                               if addresses and self.can_remove_records:
+                                       return True
+
+                               # Otherwise, we cannot go on...
                                continue
 
                        if not current_address in addresses:
-                               return False
+                               return True
 
-               return True
+               return False
+
+       def holdoff_time_expired(self):
+               """
+                       Returns true if the holdoff time has expired
+                       and the host requires an update
+               """
+               # If no holdoff days is defined, we cannot go on
+               if not self.holdoff_days:
+                       return False
+
+               # Get the timestamp of the last successfull update
+               last_update = self.db.last_update(self.hostname, status="success")
+
+               # If no timestamp has been recorded, no update has been
+               # performed. An update should be performed now.
+               if not last_update:
+                       return True
+
+               # Determine when the holdoff time ends
+               holdoff_end = last_update + datetime.timedelta(days=self.holdoff_days)
+
+               now = datetime.datetime.utcnow()
+
+               if now >= holdoff_end:
+                       logger.debug("The holdoff time has expired for %s" % self.hostname)
+                       return True
+               else:
+                       logger.debug("Updates for %s are held off until %s" % \
+                               (self.hostname, holdoff_end))
+                       return False
 
        def send_request(self, *args, **kwargs):
                """
@@ -167,20 +326,119 @@ class DDNSProvider(object):
                """
                return self.core.system.send_request(*args, **kwargs)
 
-       def get_address(self, proto):
+       def get_address(self, proto, default=None):
                """
                        Proxy method to get the current IP address.
                """
-               return self.core.system.get_address(proto)
+               return self.core.system.get_address(proto) or default
+
+       def have_address(self, proto):
+               """
+                       Returns True if an IP address for the given protocol
+                       is known and usable.
+               """
+               address = self.get_address(proto)
+
+               if address:
+                       return True
+
+               return False
+
+
+class DDNSProtocolDynDNS2(object):
+       """
+               This is an abstract class that implements the DynDNS updater
+               protocol version 2. As this is a popular way to update dynamic
+               DNS records, this class is supposed make the provider classes
+               shorter and simpler.
+       """
+
+       # Information about the format of the request is to be found
+       # http://dyn.com/support/developers/api/perform-update/
+       # http://dyn.com/support/developers/api/return-codes/
+
+       # The DynDNS protocol version 2 does not allow to remove records
+       can_remove_records = False
+
+       def prepare_request_data(self, proto):
+               data = {
+                       "hostname" : self.hostname,
+                       "myip"     : self.get_address(proto),
+               }
+
+               return data
+
+       def update_protocol(self, proto):
+               data = self.prepare_request_data(proto)
+
+               return self.send_request(data)
+
+       def send_request(self, data):
+               # Send update to the server.
+               response = DDNSProvider.send_request(self, self.url, data=data,
+                       username=self.username, password=self.password)
+
+               # Get the full response message.
+               output = response.read()
+
+               # Handle success messages.
+               if output.startswith("good") or output.startswith("nochg"):
+                       return
+
+               # Handle error codes.
+               if output == "badauth":
+                       raise DDNSAuthenticationError
+               elif output == "abuse":
+                       raise DDNSAbuseError
+               elif output == "notfqdn":
+                       raise DDNSRequestError(_("No valid FQDN was given."))
+               elif output == "nohost":
+                       raise DDNSRequestError(_("Specified host does not exist."))
+               elif output == "911":
+                       raise DDNSInternalServerError
+               elif output == "dnserr":
+                       raise DDNSInternalServerError(_("DNS error encountered."))
+               elif output == "badagent":
+                       raise DDNSBlockedError
+
+               # If we got here, some other update error happened.
+               raise DDNSUpdateError(_("Server response: %s") % output)
+
+
+class DDNSResponseParserXML(object):
+       """
+               This class provides a parser for XML responses which
+               will be sent by various providers. This class uses the python
+               shipped XML minidom module to walk through the XML tree and return
+               a requested element.
+        """
+
+       def get_xml_tag_value(self, document, content):
+               # Send input to the parser.
+               xmldoc = xml.dom.minidom.parseString(document)
+
+               # Get XML elements by the given content.
+               element = xmldoc.getElementsByTagName(content)
+
+               # If no element has been found, we directly can return None.
+               if not element:
+                       return None
+
+               # Only get the first child from an element, even there are more than one.
+               firstchild = element[0].firstChild
+
+               # Get the value of the child.
+               value = firstchild.nodeValue
+
+               # Return the value.
+               return value
 
 
 class DDNSProviderAllInkl(DDNSProvider):
-       INFO = {
-               "handle"    : "all-inkl.com",
-               "name"      : "All-inkl.com",
-               "website"   : "http://all-inkl.com/",
-               "protocols" : ["ipv4",]
-       }
+       handle    = "all-inkl.com"
+       name      = "All-inkl.com"
+       website   = "http://all-inkl.com/"
+       protocols = ("ipv4",)
 
        # There are only information provided by the vendor how to
        # perform an update on a FRITZ Box. Grab requried informations
@@ -188,49 +446,228 @@ class DDNSProviderAllInkl(DDNSProvider):
        # http://all-inkl.goetze.it/v01/ddns-mit-einfachen-mitteln/
 
        url = "http://dyndns.kasserver.com"
+       can_remove_records = False
 
        def update(self):
-
                # There is no additional data required so we directly can
                # send our request.
+               response = self.send_request(self.url, username=self.username, password=self.password)
+
+               # Get the full response message.
+               output = response.read()
+
+               # Handle success messages.
+               if output.startswith("good") or output.startswith("nochg"):
+                       return
+
+               # If we got here, some other update error happened.
+               raise DDNSUpdateError
+
+
+class DDNSProviderBindNsupdate(DDNSProvider):
+       handle  = "nsupdate"
+       name    = "BIND nsupdate utility"
+       website = "http://en.wikipedia.org/wiki/Nsupdate"
+
+       DEFAULT_TTL = 60
+
+       @staticmethod
+       def supported():
+               # Search if the nsupdate utility is available
+               paths = os.environ.get("PATH")
+
+               for path in paths.split(":"):
+                       executable = os.path.join(path, "nsupdate")
+
+                       if os.path.exists(executable):
+                               return True
+
+               return False
+
+       def update(self):
+               scriptlet = self.__make_scriptlet()
+
+               # -v enables TCP hence we transfer keys and other data that may
+               # exceed the size of one packet.
+               # -t sets the timeout
+               command = ["nsupdate", "-v", "-t", "60"]
+
+               p = subprocess.Popen(command, shell=True,
+                       stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+               )
+               stdout, stderr = p.communicate(scriptlet)
+
+               if p.returncode == 0:
+                       return
+
+               raise DDNSError("nsupdate terminated with error code: %s\n  %s" % (p.returncode, stderr))
+
+       def __make_scriptlet(self):
+               scriptlet = []
+
+               # Set a different server the update is sent to.
+               server = self.get("server", None)
+               if server:
+                       scriptlet.append("server %s" % server)
+
+               # Set the DNS zone the host should be added to.
+               zone = self.get("zone", None)
+               if zone:
+                       scriptlet.append("zone %s" % zone)
+
+               key = self.get("key", None)
+               if key:
+                       secret = self.get("secret")
+
+                       scriptlet.append("key %s %s" % (key, secret))
+
+               ttl = self.get("ttl", self.DEFAULT_TTL)
+
+               # Perform an update for each supported protocol.
+               for rrtype, proto in (("AAAA", "ipv6"), ("A", "ipv4")):
+                       address = self.get_address(proto)
+                       if not address:
+                               continue
+
+                       scriptlet.append("update delete %s. %s" % (self.hostname, rrtype))
+                       scriptlet.append("update add %s. %s %s %s" % \
+                               (self.hostname, ttl, rrtype, address))
+
+               # Send the actions to the server.
+               scriptlet.append("send")
+               scriptlet.append("quit")
+
+               logger.debug(_("Scriptlet:"))
+               for line in scriptlet:
+                       # Masquerade the line with the secret key.
+                       if line.startswith("key"):
+                               line = "key **** ****"
+
+                       logger.debug("  %s" % line)
+
+               return "\n".join(scriptlet)
+
+
+class DDNSProviderChangeIP(DDNSProvider):
+       handle    = "changeip.com"
+       name      = "ChangeIP.com"
+       website   = "https://changeip.com"
+       protocols = ("ipv4",)
+
+       # Detailed information about the update api can be found here.
+       # http://www.changeip.com/accounts/knowledgebase.php?action=displayarticle&id=34
+
+       url = "https://nic.changeip.com/nic/update"
+       can_remove_records = False
+
+       def update_protocol(self, proto):
+               data = {
+                       "hostname" : self.hostname,
+                       "myip"     : self.get_address(proto),
+               }
+
+               # Send update to the server.
                try:
-                       # Send request to the server.
-                       response = self.send_request(self.url, username=self.username, password=self.password)
+                       response = self.send_request(self.url, username=self.username, password=self.password,
+                               data=data)
 
-                       # Handle 401 HTTP Header (Authentication Error)
+               # Handle error codes.
                except urllib2.HTTPError, e:
-                       if e.code == 401:
-                               raise DDNSAuthenticationError
+                       if e.code == 422:
+                               raise DDNSRequestError(_("Domain not found."))
 
                        raise
 
-               # Get the full response message.
-               output = response.read()
+               # Handle success message.
+               if response.code == 200:
+                       return
+
+               # If we got here, some other update error happened.
+               raise DDNSUpdateError(_("Server response: %s") % output)
+
+
+class DDNSProviderDDNSS(DDNSProvider):
+       handle    = "ddnss.de"
+       name      = "DDNSS"
+       website   = "http://www.ddnss.de"
+       protocols = ("ipv4",)
+
+       # Detailed information about how to send the update request and possible response
+       # codes can be obtained from here.
+       # http://www.ddnss.de/info.php
+       # http://www.megacomputing.de/2014/08/dyndns-service-response-time/#more-919
+
+       url = "http://www.ddnss.de/upd.php"
+       can_remove_records = False
+
+       def update_protocol(self, proto):
+               data = {
+                       "ip"   : self.get_address(proto),
+                       "host" : self.hostname,
+               }
+
+               # Check if a token has been set.
+               if self.token:
+                       data["key"] = self.token
+
+               # Check if username and hostname are given.
+               elif self.username and self.password:
+                       data.update({
+                               "user" : self.username,
+                               "pwd"  : self.password,
+                       })
+
+               # Raise an error if no auth details are given.
+               else:
+                       raise DDNSConfigurationError
+
+               # Send update to the server.
+               response = self.send_request(self.url, data=data)
+
+               # This provider sends the response code as part of the header.
+               header = response.info()
+
+               # Get status information from the header.
+               output = header.getheader('ddnss-response')
 
                # Handle success messages.
-               if output.startswith("good") or output.startswith("nochg"):
+               if output == "good" or output == "nochg":
                        return
 
+               # Handle error codes.
+               if output == "badauth":
+                       raise DDNSAuthenticationError
+               elif output == "notfqdn":
+                       raise DDNSRequestError(_("No valid FQDN was given."))
+               elif output == "nohost":
+                       raise DDNSRequestError(_("Specified host does not exist."))
+               elif output == "911":
+                       raise DDNSInternalServerError
+               elif output == "dnserr":
+                       raise DDNSInternalServerError(_("DNS error encountered."))
+               elif output == "disabled":
+                       raise DDNSRequestError(_("Account disabled or locked."))
+
                # If we got here, some other update error happened.
                raise DDNSUpdateError
 
 
 class DDNSProviderDHS(DDNSProvider):
-       INFO = {
-               "handle"    : "dhs.org",
-               "name"      : "DHS International",
-               "website"   : "http://dhs.org/",
-               "protocols" : ["ipv4",]
-       }
+       handle    = "dhs.org"
+       name      = "DHS International"
+       website   = "http://dhs.org/"
+       protocols = ("ipv4",)
 
        # No information about the used update api provided on webpage,
        # grabed from source code of ez-ipudate.
+
        url = "http://members.dhs.org/nic/hosts"
+       can_remove_records = False
 
-       def update(self):
+       def update_protocol(self, proto):
                data = {
                        "domain"       : self.hostname,
-                       "ip"           : self.get_address("ipv4"),
+                       "ip"           : self.get_address(proto),
                        "hostcmd"      : "edit",
                        "hostcmdstage" : "2",
                        "type"         : "4",
@@ -244,30 +681,26 @@ class DDNSProviderDHS(DDNSProvider):
                if response.code == 200:
                        return
 
-               # Handle error codes.
-               elif response.code == 401:
-                       raise DDNSAuthenticationError
-
                # If we got here, some other update error happened.
                raise DDNSUpdateError
 
 
 class DDNSProviderDNSpark(DDNSProvider):
-       INFO = {
-               "handle"    : "dnspark.com",
-               "name"      : "DNS Park",
-               "website"   : "http://dnspark.com/",
-               "protocols" : ["ipv4",]
-       }
+       handle    = "dnspark.com"
+       name      = "DNS Park"
+       website   = "http://dnspark.com/"
+       protocols = ("ipv4",)
 
        # Informations to the used api can be found here:
        # https://dnspark.zendesk.com/entries/31229348-Dynamic-DNS-API-Documentation
+
        url = "https://control.dnspark.com/api/dynamic/update.php"
+       can_remove_records = False
 
-       def update(self):
+       def update_protocol(self, proto):
                data = {
                        "domain" : self.hostname,
-                       "ip"     : self.get_address("ipv4"),
+                       "ip"     : self.get_address(proto),
                }
 
                # Send update to the server.
@@ -301,23 +734,180 @@ class DDNSProviderDNSpark(DDNSProvider):
                raise DDNSUpdateError
 
 
-class DDNSProviderDtDNS(DDNSProvider):
-       INFO = {
-               "handle"    : "dtdns.com",
-               "name"      : "DtDNS",
-               "website"   : "http://dtdns.com/",
-               "protocols" : ["ipv4",]
-               }
+class DDNSProviderDtDNS(DDNSProvider):
+       handle    = "dtdns.com"
+       name      = "DtDNS"
+       website   = "http://dtdns.com/"
+       protocols = ("ipv4",)
+
+       # Information about the format of the HTTPS request is to be found
+       # http://www.dtdns.com/dtsite/updatespec
+
+       url = "https://www.dtdns.com/api/autodns.cfm"
+       can_remove_records = False
+
+       def update_protocol(self, proto):
+               data = {
+                       "ip" : self.get_address(proto),
+                       "id" : self.hostname,
+                       "pw" : self.password
+               }
+
+               # Send update to the server.
+               response = self.send_request(self.url, data=data)
+
+               # Get the full response message.
+               output = response.read()
+
+               # Remove all leading and trailing whitespace.
+               output = output.strip()
+
+               # Handle success messages.
+               if "now points to" in output:
+                       return
+
+               # Handle error codes.
+               if output == "No hostname to update was supplied.":
+                       raise DDNSRequestError(_("No hostname specified."))
+
+               elif output == "The hostname you supplied is not valid.":
+                       raise DDNSRequestError(_("Invalid hostname specified."))
+
+               elif output == "The password you supplied is not valid.":
+                       raise DDNSAuthenticationError
+
+               elif output == "Administration has disabled this account.":
+                       raise DDNSRequestError(_("Account has been disabled."))
+
+               elif output == "Illegal character in IP.":
+                       raise DDNSRequestError(_("Invalid IP address has been sent."))
+
+               elif output == "Too many failed requests.":
+                       raise DDNSRequestError(_("Too many failed requests."))
+
+               # If we got here, some other update error happened.
+               raise DDNSUpdateError
+
+
+class DDNSProviderDynDNS(DDNSProtocolDynDNS2, DDNSProvider):
+       handle    = "dyndns.org"
+       name      = "Dyn"
+       website   = "http://dyn.com/dns/"
+       protocols = ("ipv4",)
+
+       # Information about the format of the request is to be found
+       # http://http://dyn.com/support/developers/api/perform-update/
+       # http://dyn.com/support/developers/api/return-codes/
+
+       url = "https://members.dyndns.org/nic/update"
+
+
+class DDNSProviderDynU(DDNSProtocolDynDNS2, DDNSProvider):
+       handle    = "dynu.com"
+       name      = "Dynu"
+       website   = "http://dynu.com/"
+       protocols = ("ipv6", "ipv4",)
+
+       # Detailed information about the request and response codes
+       # are available on the providers webpage.
+       # http://dynu.com/Default.aspx?page=dnsapi
+
+       url = "https://api.dynu.com/nic/update"
+
+       # DynU sends the IPv6 and IPv4 address in one request
+
+       def update(self):
+               data = DDNSProtocolDynDNS2.prepare_request_data(self, "ipv4")
+
+               # This one supports IPv6
+               myipv6 = self.get_address("ipv6")
+
+               # Add update information if we have an IPv6 address.
+               if myipv6:
+                       data["myipv6"] = myipv6
+
+               self.send_request(data)
+
+
+class DDNSProviderEasyDNS(DDNSProvider):
+       handle    = "easydns.com"
+       name      = "EasyDNS"
+       website   = "http://www.easydns.com/"
+       protocols = ("ipv4",)
+
+       # Detailed information about the request and response codes
+       # (API 1.3) are available on the providers webpage.
+       # https://fusion.easydns.com/index.php?/Knowledgebase/Article/View/102/7/dynamic-dns
+
+       url = "http://api.cp.easydns.com/dyn/tomato.php"
+
+       def update_protocol(self, proto):
+               data = {
+                       "myip"     : self.get_address(proto, "-"),
+                       "hostname" : self.hostname,
+               }
+
+               # Send update to the server.
+               response = self.send_request(self.url, data=data,
+                       username=self.username, password=self.password)
+
+               # Get the full response message.
+               output = response.read()
+
+               # Remove all leading and trailing whitespace.
+               output = output.strip()
+
+               # Handle success messages.
+               if output.startswith("NOERROR"):
+                       return
+
+               # Handle error codes.
+               if output.startswith("NOACCESS"):
+                       raise DDNSAuthenticationError
+
+               elif output.startswith("NOSERVICE"):
+                       raise DDNSRequestError(_("Dynamic DNS is not turned on for this domain."))
+
+               elif output.startswith("ILLEGAL INPUT"):
+                       raise DDNSRequestError(_("Invalid data has been sent."))
+
+               elif output.startswith("TOOSOON"):
+                       raise DDNSRequestError(_("Too frequent update requests have been sent."))
+
+               # If we got here, some other update error happened.
+               raise DDNSUpdateError
+
+
+class DDNSProviderDomopoli(DDNSProtocolDynDNS2, DDNSProvider):
+       handle    = "domopoli.de"
+       name      = "domopoli.de"
+       website   = "http://domopoli.de/"
+       protocols = ("ipv4",)
 
-       # Information about the format of the HTTPS request is to be found
-       # http://www.dtdns.com/dtsite/updatespec
-       url = "https://www.dtdns.com/api/autodns.cfm"
+       # https://www.domopoli.de/?page=howto#DynDns_start
 
-       def update(self):
+       url = "http://dyndns.domopoli.de/nic/update"
+
+
+class DDNSProviderDynsNet(DDNSProvider):
+       handle    = "dyns.net"
+       name      = "DyNS"
+       website   = "http://www.dyns.net/"
+       protocols = ("ipv4",)
+       can_remove_records = False
+
+       # There is very detailed informatio about how to send the update request and
+       # the possible response codes. (Currently we are using the v1.1 proto)
+       # http://www.dyns.net/documentation/technical/protocol/
+
+       url = "http://www.dyns.net/postscript011.php"
+
+       def update_protocol(self, proto):
                data = {
-                       "ip" : self.get_address("ipv4"),
-                       "id" : self.hostname,
-                       "pw" : self.password
+                       "ip"       : self.get_address(proto),
+                       "host"     : self.hostname,
+                       "username" : self.username,
+                       "password" : self.password,
                }
 
                # Send update to the server.
@@ -326,151 +916,122 @@ class DDNSProviderDtDNS(DDNSProvider):
                # Get the full response message.
                output = response.read()
 
-               # Remove all leading and trailing whitespace.
-               output = output.strip()
-
                # Handle success messages.
-               if "now points to" in output:
+               if output.startswith("200"):
                        return
 
                # Handle error codes.
-               if output == "No hostname to update was supplied.":
-                       raise DDNSRequestError(_("No hostname specified."))
-
-               elif output == "The hostname you supplied is not valid.":
-                       raise DDNSRequestError(_("Invalid hostname specified."))
-
-               elif output == "The password you supplied is not valid.":
+               if output.startswith("400"):
+                       raise DDNSRequestError(_("Malformed request has been sent."))
+               elif output.startswith("401"):
                        raise DDNSAuthenticationError
-
-               elif output == "Administration has disabled this account.":
-                       raise DDNSRequestError(_("Account has been disabled."))
-
-               elif output == "Illegal character in IP.":
-                       raise DDNSRequestError(_("Invalid IP address has been sent."))
-
-               elif output == "Too many failed requests.":
-                       raise DDNSRequestError(_("Too many failed requests."))
+               elif output.startswith("402"):
+                       raise DDNSRequestError(_("Too frequent update requests have been sent."))
+               elif output.startswith("403"):
+                       raise DDNSInternalServerError
 
                # If we got here, some other update error happened.
-               raise DDNSUpdateError
+               raise DDNSUpdateError(_("Server response: %s") % output) 
 
 
-class DDNSProviderDynDNS(DDNSProvider):
-       INFO = {
-               "handle"    : "dyndns.org",
-               "name"      : "Dyn",
-               "website"   : "http://dyn.com/dns/",
-               "protocols" : ["ipv4",]
-       }
+class DDNSProviderEnomCom(DDNSResponseParserXML, DDNSProvider):
+       handle    = "enom.com"
+       name      = "eNom Inc."
+       website   = "http://www.enom.com/"
+       protocols = ("ipv4",)
 
-       # Information about the format of the request is to be found
-       # http://http://dyn.com/support/developers/api/perform-update/
-       # http://dyn.com/support/developers/api/return-codes/
-       url = "https://members.dyndns.org/nic/update"
+       # There are very detailed information about how to send an update request and
+       # the respone codes.
+       # http://www.enom.com/APICommandCatalog/
 
-       def _prepare_request_data(self):
+       url = "https://dynamic.name-services.com/interface.asp"
+       can_remove_records = False
+
+       def update_protocol(self, proto):
                data = {
-                       "hostname" : self.hostname,
-                       "myip"     : self.get_address("ipv4"),
+                       "command"        : "setdnshost",
+                       "responsetype"   : "xml",
+                       "address"        : self.get_address(proto),
+                       "domainpassword" : self.password,
+                       "zone"           : self.hostname
                }
 
-               return data
-
-       def update(self):
-               data = self._prepare_request_data()
-
                # Send update to the server.
-               response = self.send_request(self.url, data=data,
-                       username=self.username, password=self.password)
+               response = self.send_request(self.url, data=data)
 
                # Get the full response message.
                output = response.read()
 
                # Handle success messages.
-               if output.startswith("good") or output.startswith("nochg"):
+               if self.get_xml_tag_value(output, "ErrCount") == "0":
                        return
 
                # Handle error codes.
-               if output == "badauth":
+               errorcode = self.get_xml_tag_value(output, "ResponseNumber")
+
+               if errorcode == "304155":
                        raise DDNSAuthenticationError
-               elif output == "aduse":
-                       raise DDNSAbuseError
-               elif output == "notfqdn":
-                       raise DDNSRequestError(_("No valid FQDN was given."))
-               elif output == "nohost":
-                       raise DDNSRequestError(_("Specified host does not exist."))
-               elif output == "911":
-                       raise DDNSInternalServerError
-               elif output == "dnserr":
-                       raise DDNSInternalServerError(_("DNS error encountered."))
+               elif errorcode == "304153":
+                       raise DDNSRequestError(_("Domain not found."))
 
                # If we got here, some other update error happened.
-               raise DDNSUpdateError(_("Server response: %s") % output)
-
+               raise DDNSUpdateError
 
-class DDNSProviderDynU(DDNSProviderDynDNS):
-       INFO = {
-               "handle"    : "dynu.com",
-               "name"      : "Dynu",
-               "website"   : "http://dynu.com/",
-               "protocols" : ["ipv6", "ipv4",]
-       }
 
+class DDNSProviderEntryDNS(DDNSProvider):
+       handle    = "entrydns.net"
+       name      = "EntryDNS"
+       website   = "http://entrydns.net/"
+       protocols = ("ipv4",)
 
-       # Detailed information about the request and response codes
-       # are available on the providers webpage.
-       # http://dynu.com/Default.aspx?page=dnsapi
+       # Some very tiny details about their so called "Simple API" can be found
+       # here: https://entrydns.net/help
+       url = "https://entrydns.net/records/modify"
+       can_remove_records = False
 
-       url = "https://api.dynu.com/nic/update"
+       def update_protocol(self, proto):
+               data = {
+                       "ip" : self.get_address(proto),
+               }
 
-       def _prepare_request_data(self):
-               data = DDNSProviderDynDNS._prepare_request_data(self)
+               # Add auth token to the update url.
+               url = "%s/%s" % (self.url, self.token)
 
-               # This one supports IPv6
-               data.update({
-                       "myipv6"   : self.get_address("ipv6"),
-               })
+               # Send update to the server.
+               try:
+                       response = self.send_request(url, data=data)
 
-               return data
+               # Handle error codes
+               except urllib2.HTTPError, e:
+                       if e.code == 404:
+                               raise DDNSAuthenticationError
 
+                       elif e.code == 422:
+                               raise DDNSRequestError(_("An invalid IP address was submitted"))
 
-class DDNSProviderEasyDNS(DDNSProviderDynDNS):
-       INFO = {
-               "handle"    : "easydns.com",
-               "name"      : "EasyDNS",
-               "website"   : "http://www.easydns.com/",
-               "protocols" : ["ipv4",]
-       }
+                       raise
 
-       # There is only some basic documentation provided by the vendor,
-       # also searching the web gain very poor results.
-       # http://mediawiki.easydns.com/index.php/Dynamic_DNS
+               # Handle success messages.
+               if response.code == 200:
+                       return
 
-       url = "http://api.cp.easydns.com/dyn/tomato.php"
+               # If we got here, some other update error happened.
+               raise DDNSUpdateError
 
 
 class DDNSProviderFreeDNSAfraidOrg(DDNSProvider):
-       INFO = {
-               "handle"    : "freedns.afraid.org",
-               "name"      : "freedns.afraid.org",
-               "website"   : "http://freedns.afraid.org/",
-               "protocols" : ["ipv6", "ipv4",]
-               }
+       handle    = "freedns.afraid.org"
+       name      = "freedns.afraid.org"
+       website   = "http://freedns.afraid.org/"
 
        # No information about the request or response could be found on the vendor
        # page. All used values have been collected by testing.
        url = "https://freedns.afraid.org/dynamic/update.php"
+       can_remove_records = False
 
-       @property
-       def proto(self):
-               return self.get("proto")
-
-       def update(self):
-               address = self.get_address(self.proto)
-
+       def update_protocol(self, proto):
                data = {
-                       "address" : address,
+                       "address" : self.get_address(proto),
                }
 
                # Add auth token to the update url.
@@ -479,6 +1040,10 @@ class DDNSProviderFreeDNSAfraidOrg(DDNSProvider):
                # Send update to the server.
                response = self.send_request(url, data=data)
 
+               # Get the full response message.
+               output = response.read()
+
+               # Handle success messages.
                if output.startswith("Updated") or "has not changed" in output:
                        return
 
@@ -488,38 +1053,52 @@ class DDNSProviderFreeDNSAfraidOrg(DDNSProvider):
                elif "is an invalid IP address" in output:
                        raise DDNSRequestError(_("Invalid IP address has been sent."))
 
+               # If we got here, some other update error happened.
+               raise DDNSUpdateError
+
+
+class DDNSProviderJoker(DDNSProtocolDynDNS2, DDNSProvider):
+               handle  = "joker.com"
+               name    = "Joker.com Dynamic DNS"
+               website = "https://joker.com/"
+               protocols = ("ipv4",)
+
+               # Information about the request can be found here:
+               # https://joker.com/faq/content/11/427/en/what-is-dynamic-dns-dyndns.html
+               # Using DynDNS V2 protocol over HTTPS here
+
+               url = "https://svc.joker.com/nic/update"
+
+
+class DDNSProviderGoogle(DDNSProtocolDynDNS2, DDNSProvider):
+        handle    = "domains.google.com"
+        name      = "Google Domains"
+        website   = "https://domains.google.com/"
+        protocols = ("ipv4",)
+
+        # Information about the format of the HTTP request is to be found
+        # here: https://support.google.com/domains/answer/6147083?hl=en
+
+        url = "https://domains.google.com/nic/update"
+
 
 class DDNSProviderLightningWireLabs(DDNSProvider):
-       INFO = {
-               "handle"    : "dns.lightningwirelabs.com",
-               "name"      : "Lightning Wire Labs",
-               "website"   : "http://dns.lightningwirelabs.com/",
-               "protocols" : ["ipv6", "ipv4",]
-       }
+       handle    = "dns.lightningwirelabs.com"
+       name      = "Lightning Wire Labs DNS Service"
+       website   = "http://dns.lightningwirelabs.com/"
 
        # Information about the format of the HTTPS request is to be found
        # https://dns.lightningwirelabs.com/knowledge-base/api/ddns
+
        url = "https://dns.lightningwirelabs.com/update"
 
        def update(self):
                data =  {
                        "hostname" : self.hostname,
+                       "address6" : self.get_address("ipv6", "-"),
+                       "address4" : self.get_address("ipv4", "-"),
                }
 
-               # Check if we update an IPv6 address.
-               address6 = self.get_address("ipv6")
-               if address6:
-                       data["address6"] = address6
-
-               # Check if we update an IPv4 address.
-               address4 = self.get_address("ipv4")
-               if address4:
-                       data["address4"] = address4
-
-               # Raise an error if none address is given.
-               if not data.has_key("address6") and not data.has_key("address4"):
-                       raise DDNSConfigurationError
-
                # Check if a token has been set.
                if self.token:
                        data["token"] = self.token
@@ -542,56 +1121,63 @@ class DDNSProviderLightningWireLabs(DDNSProvider):
                if response.code == 200:
                        return
 
-               # Handle error codes.
-               if response.code == 403:
-                       raise DDNSAuthenticationError
-               elif response.code == 400:
-                       raise DDNSRequestError
-
                # If we got here, some other update error happened.
                raise DDNSUpdateError
 
 
-class DDNSProviderNamecheap(DDNSProvider):
-       INFO = {
-               "handle"    : "namecheap.com",
-               "name"      : "Namecheap",
-               "website"   : "http://namecheap.com",
-               "protocols" : ["ipv4",]
-       }
+class DDNSProviderLoopia(DDNSProtocolDynDNS2, DDNSProvider):
+       handle    = "loopia.se"
+       name      = "Loopia AB"
+       website   = "https://www.loopia.com"
+       protocols = ("ipv4",)
 
        # Information about the format of the HTTP request is to be found
-       # https://www.namecheap.com/support/knowledgebase/article.aspx/9249/0/nc-dynamic-dns-to-dyndns-adapter
-       # https://community.namecheap.com/forums/viewtopic.php?f=6&t=6772
+       # here: https://support.loopia.com/wiki/About_the_DynDNS_support
 
-       url = "https://dynamicdns.park-your-domain.com/update"
+       url = "https://dns.loopia.se/XDynDNSServer/XDynDNS.php"
 
-       def parse_xml(self, document, content):
-               # Send input to the parser.
-               xmldoc = xml.dom.minidom.parseString(document)
 
-               # Get XML elements by the given content.
-               element = xmldoc.getElementsByTagName(content)
+class DDNSProviderMyOnlinePortal(DDNSProtocolDynDNS2, DDNSProvider):
+       handle    = "myonlineportal.net"
+       name      = "myonlineportal.net"
+       website   = "https:/myonlineportal.net/"
 
-               # If no element has been found, we directly can return None.
-               if not element:
-                       return None
+       # Information about the request and response can be obtained here:
+       # https://myonlineportal.net/howto_dyndns
 
-               # Only get the first child from an element, even there are more than one.
-               firstchild = element[0].firstChild
+       url = "https://myonlineportal.net/updateddns"
 
-               # Get the value of the child.
-               value = firstchild.nodeValue
+       def prepare_request_data(self, proto):
+               data = {
+                       "hostname" : self.hostname,
+                       "ip"     : self.get_address(proto),
+               }
 
-               # Return the value.
-               return value
-               
-       def update(self):
+               return data
+
+
+class DDNSProviderNamecheap(DDNSResponseParserXML, DDNSProvider):
+       handle    = "namecheap.com"
+       name      = "Namecheap"
+       website   = "http://namecheap.com"
+       protocols = ("ipv4",)
+
+       # Information about the format of the HTTP request is to be found
+       # https://www.namecheap.com/support/knowledgebase/article.aspx/9249/0/nc-dynamic-dns-to-dyndns-adapter
+       # https://community.namecheap.com/forums/viewtopic.php?f=6&t=6772
+
+       url = "https://dynamicdns.park-your-domain.com/update"
+       can_remove_records = False
+
+       def update_protocol(self, proto):
                # Namecheap requires the hostname splitted into a host and domain part.
                host, domain = self.hostname.split(".", 1)
 
+               # Get and store curent IP address.
+               address = self.get_address(proto)
+
                data = {
-                       "ip"       : self.get_address("ipv4"),
+                       "ip"       : address,
                        "password" : self.password,
                        "host"     : host,
                        "domain"   : domain
@@ -604,11 +1190,11 @@ class DDNSProviderNamecheap(DDNSProvider):
                output = response.read()
 
                # Handle success messages.
-               if self.parse_xml(output, "IP") == self.get_address("ipv4"):
+               if self.get_xml_tag_value(output, "IP") == address:
                        return
 
                # Handle error codes.
-               errorcode = self.parse_xml(output, "ResponseNumber")
+               errorcode = self.get_xml_tag_value(output, "ResponseNumber")
 
                if errorcode == "304156":
                        raise DDNSAuthenticationError
@@ -623,13 +1209,11 @@ class DDNSProviderNamecheap(DDNSProvider):
                raise DDNSUpdateError
 
 
-class DDNSProviderNOIP(DDNSProviderDynDNS):
-       INFO = {
-               "handle"    : "no-ip.com",
-               "name"      : "No-IP",
-               "website"   : "http://www.no-ip.com/",
-               "protocols" : ["ipv4",]
-       }
+class DDNSProviderNOIP(DDNSProtocolDynDNS2, DDNSProvider):
+       handle    = "no-ip.com"
+       name      = "No-IP"
+       website   = "http://www.no-ip.com/"
+       protocols = ("ipv4",)
 
        # Information about the format of the HTTP request is to be found
        # here: http://www.no-ip.com/integrate/request and
@@ -637,22 +1221,80 @@ class DDNSProviderNOIP(DDNSProviderDynDNS):
 
        url = "http://dynupdate.no-ip.com/nic/update"
 
-       def _prepare_request_data(self):
+       def prepare_request_data(self, proto):
+               assert proto == "ipv4"
+
+               data = {
+                       "hostname" : self.hostname,
+                       "address"  : self.get_address(proto),
+               }
+
+               return data
+
+
+class DDNSProviderNsupdateINFO(DDNSProtocolDynDNS2, DDNSProvider):
+       handle    = "nsupdate.info"
+       name      = "nsupdate.info"
+       website   = "http://nsupdate.info/"
+       protocols = ("ipv6", "ipv4",)
+
+       # Information about the format of the HTTP request can be found
+       # after login on the provider user interface and here:
+       # http://nsupdateinfo.readthedocs.org/en/latest/user.html
+
+       url = "https://nsupdate.info/nic/update"
+
+       # TODO nsupdate.info can actually do this, but the functionality
+       # has not been implemented here, yet.
+       can_remove_records = False
+
+       # After a failed update, there will be no retries
+       # https://bugzilla.ipfire.org/show_bug.cgi?id=10603
+       holdoff_failure_days = None
+
+       # Nsupdate.info uses the hostname as user part for the HTTP basic auth,
+       # and for the password a so called secret.
+       @property
+       def username(self):
+               return self.get("hostname")
+
+       @property
+       def password(self):
+               return self.token or self.get("secret")
+
+       def prepare_request_data(self, proto):
+               data = {
+                       "myip" : self.get_address(proto),
+               }
+
+               return data
+
+
+class DDNSProviderOpenDNS(DDNSProtocolDynDNS2, DDNSProvider):
+       handle    = "opendns.com"
+       name      = "OpenDNS"
+       website   = "http://www.opendns.com"
+
+       # Detailed information about the update request and possible
+       # response codes can be obtained from here:
+       # https://support.opendns.com/entries/23891440
+
+       url = "https://updates.opendns.com/nic/update"
+
+       def prepare_request_data(self, proto):
                data = {
                        "hostname" : self.hostname,
-                       "address"  : self.get_address("ipv4"),
+                       "myip"     : self.get_address(proto),
                }
 
                return data
 
 
-class DDNSProviderOVH(DDNSProviderDynDNS):
-       INFO = {
-               "handle"    : "ovh.com",
-               "name"      : "OVH",
-               "website"   : "http://www.ovh.com/",
-               "protocols" : ["ipv4",]
-       }
+class DDNSProviderOVH(DDNSProtocolDynDNS2, DDNSProvider):
+       handle    = "ovh.com"
+       name      = "OVH"
+       website   = "http://www.ovh.com/"
+       protocols = ("ipv4",)
 
        # OVH only provides very limited information about how to
        # update a DynDNS host. They only provide the update url
@@ -662,8 +1304,8 @@ class DDNSProviderOVH(DDNSProviderDynDNS):
 
        url = "https://www.ovh.com/nic/update"
 
-       def _prepare_request_data(self):
-               data = DDNSProviderDynDNS._prepare_request_data(self)
+       def prepare_request_data(self, proto):
+               data = DDNSProtocolDynDNS2.prepare_request_data(self, proto)
                data.update({
                        "system" : "dyndns",
                })
@@ -672,18 +1314,16 @@ class DDNSProviderOVH(DDNSProviderDynDNS):
 
 
 class DDNSProviderRegfish(DDNSProvider):
-       INFO = {
-               "handle"    : "regfish.com",
-               "name"      : "Regfish GmbH",
-               "website"   : "http://www.regfish.com/",
-               "protocols" : ["ipv6", "ipv4",]
-       }
+       handle  = "regfish.com"
+       name    = "Regfish GmbH"
+       website = "http://www.regfish.com/"
 
        # A full documentation to the providers api can be found here
        # but is only available in german.
        # https://www.regfish.de/domains/dyndns/dokumentation
 
        url = "https://dyndns.regfish.de/"
+       can_remove_records = False
 
        def update(self):
                data = {
@@ -745,18 +1385,16 @@ class DDNSProviderRegfish(DDNSProvider):
                raise DDNSUpdateError
 
 
-class DDNSProviderSelfhost(DDNSProviderDynDNS):
-       INFO = {
-               "handle"    : "selfhost.de",
-               "name"      : "Selfhost.de",
-               "website"   : "http://www.selfhost.de/",
-               "protocols" : ["ipv4",],
-       }
+class DDNSProviderSelfhost(DDNSProtocolDynDNS2, DDNSProvider):
+       handle    = "selfhost.de"
+       name      = "Selfhost.de"
+       website   = "http://www.selfhost.de/"
+       protocols = ("ipv4",)
 
        url = "https://carol.selfhost.de/nic/update"
 
-       def _prepare_request_data(self):
-               data = DDNSProviderDynDNS._prepare_request_data(self)
+       def prepare_request_data(self, proto):
+               data = DDNSProtocolDynDNS2.prepare_request_data(self, proto)
                data.update({
                        "hostname" : "1",
                })
@@ -764,13 +1402,10 @@ class DDNSProviderSelfhost(DDNSProviderDynDNS):
                return data
 
 
-class DDNSProviderSPDNS(DDNSProviderDynDNS):
-       INFO = {
-               "handle"    : "spdns.org",
-               "name"      : "SPDNS",
-               "website"   : "http://spdns.org/",
-               "protocols" : ["ipv4",]
-       }
+class DDNSProviderSPDNS(DDNSProtocolDynDNS2, DDNSProvider):
+       handle    = "spdns.org"
+       name      = "SPDNS"
+       website   = "http://spdns.org/"
 
        # Detailed information about request and response codes are provided
        # by the vendor. They are using almost the same mechanism and status
@@ -781,28 +1416,41 @@ class DDNSProviderSPDNS(DDNSProviderDynDNS):
 
        url = "https://update.spdns.de/nic/update"
 
+       @property
+       def username(self):
+               return self.get("username") or self.hostname
+
+       @property
+       def password(self):
+               return self.get("password") or self.token
+
 
-class DDNSProviderStrato(DDNSProviderDynDNS):
-       INFO = {
-               "handle"    : "strato.com",
-               "name"      : "Strato AG",
-               "website"   : "http:/www.strato.com/",
-               "protocols" : ["ipv4",]
-       }
+class DDNSProviderStrato(DDNSProtocolDynDNS2, DDNSProvider):
+       handle    = "strato.com"
+       name      = "Strato AG"
+       website   = "http:/www.strato.com/"
+       protocols = ("ipv4",)
 
        # Information about the request and response can be obtained here:
        # http://www.strato-faq.de/article/671/So-einfach-richten-Sie-DynDNS-f%C3%BCr-Ihre-Domains-ein.html
 
        url = "https://dyndns.strato.com/nic/update"
 
+       def prepare_request_data(self, proto):
+               data = DDNSProtocolDynDNS2.prepare_request_data(self, proto)
+               data.update({
+                       "mx" : "NOCHG",
+                       "backupmx" : "NOCHG"
+               })
+
+               return data
+
 
-class DDNSProviderTwoDNS(DDNSProviderDynDNS):
-       INFO = {
-               "handle"    : "twodns.de",
-               "name"      : "TwoDNS",
-               "website"   : "http://www.twodns.de",
-               "protocols" : ["ipv4",]
-       }
+class DDNSProviderTwoDNS(DDNSProtocolDynDNS2, DDNSProvider):
+       handle    = "twodns.de"
+       name      = "TwoDNS"
+       website   = "http://www.twodns.de"
+       protocols = ("ipv4",)
 
        # Detailed information about the request can be found here
        # http://twodns.de/en/faqs
@@ -810,22 +1458,22 @@ class DDNSProviderTwoDNS(DDNSProviderDynDNS):
 
        url = "https://update.twodns.de/update"
 
-       def _prepare_request_data(self):
+       def prepare_request_data(self, proto):
+               assert proto == "ipv4"
+
                data = {
-                       "ip" : self.get_address("ipv4"),
+                       "ip"       : self.get_address(proto),
                        "hostname" : self.hostname
                }
 
                return data
 
 
-class DDNSProviderUdmedia(DDNSProviderDynDNS):
-       INFO = {
-               "handle"    : "udmedia.de",
-               "name"      : "Udmedia GmbH",
-               "website"   : "http://www.udmedia.de",
-               "protocols" : ["ipv4",]
-       }
+class DDNSProviderUdmedia(DDNSProtocolDynDNS2, DDNSProvider):
+       handle    = "udmedia.de"
+       name      = "Udmedia GmbH"
+       website   = "http://www.udmedia.de"
+       protocols = ("ipv4",)
 
        # Information about the request can be found here
        # http://www.udmedia.de/faq/content/47/288/de/wie-lege-ich-einen-dyndns_eintrag-an.html
@@ -833,39 +1481,43 @@ class DDNSProviderUdmedia(DDNSProviderDynDNS):
        url = "https://www.udmedia.de/nic/update"
 
 
-class DDNSProviderVariomedia(DDNSProviderDynDNS):
-       INFO = {
-               "handle"   : "variomedia.de",
-               "name"     : "Variomedia",
-               "website"  : "http://www.variomedia.de/",
-               "protocols" : ["ipv6", "ipv4",]
-       }
+class DDNSProviderVariomedia(DDNSProtocolDynDNS2, DDNSProvider):
+       handle    = "variomedia.de"
+       name      = "Variomedia"
+       website   = "http://www.variomedia.de/"
+       protocols = ("ipv6", "ipv4",)
 
        # Detailed information about the request can be found here
        # https://dyndns.variomedia.de/
 
        url = "https://dyndns.variomedia.de/nic/update"
 
-       @property
-       def proto(self):
-               return self.get("proto")
-
-       def _prepare_request_data(self):
+       def prepare_request_data(self, proto):
                data = {
                        "hostname" : self.hostname,
-                       "myip"     : self.get_address(self.proto)
+                       "myip"     : self.get_address(proto),
                }
 
                return data
 
 
+class DDNSProviderXLhost(DDNSProtocolDynDNS2, DDNSProvider):
+        handle    = "xlhost.de"
+        name     = "XLhost"
+        website   = "http://xlhost.de/"
+        protocols = ("ipv4",)
+
+        # Information about the format of the HTTP request is to be found
+        # here: https://xlhost.de/faq/index_html?topicId=CQA2ELIPO4SQ
+
+        url = "https://nsupdate.xlhost.de/"
+
+
 class DDNSProviderZoneedit(DDNSProvider):
-       INFO = {
-               "handle"    : "zoneedit.com",
-               "name"      : "Zoneedit",
-               "website"   : "http://www.zoneedit.com",
-               "protocols" : ["ipv6", "ipv4",]
-       }
+       handle    = "zoneedit.com"
+       name      = "Zoneedit"
+       website   = "http://www.zoneedit.com"
+       protocols = ("ipv4",)
 
        # Detailed information about the request and the response codes can be
        # obtained here:
@@ -874,13 +1526,9 @@ class DDNSProviderZoneedit(DDNSProvider):
 
        url = "https://dynamic.zoneedit.com/auth/dynamic.html"
 
-       @property
-       def proto(self):
-               return self.get("proto")
-
-       def update(self):
+       def update_protocol(self, proto):
                data = {
-                       "dnsto" : self.get_address(self.proto),
+                       "dnsto" : self.get_address(proto),
                        "host"  : self.hostname
                }
 
@@ -905,3 +1553,98 @@ class DDNSProviderZoneedit(DDNSProvider):
 
                # If we got here, some other update error happened.
                raise DDNSUpdateError
+
+
+class DDNSProviderDNSmadeEasy(DDNSProvider):
+       handle    = "dnsmadeeasy.com"
+       name      = "DNSmadeEasy.com"
+       website   = "http://www.dnsmadeeasy.com/"
+       protocols = ("ipv4",)
+
+       # DNS Made Easy Nameserver Provider also offering Dynamic DNS
+       # Documentation can be found here:
+       # http://www.dnsmadeeasy.com/dynamic-dns/
+
+       url = "https://cp.dnsmadeeasy.com/servlet/updateip?"
+       can_remove_records = False
+
+       def update_protocol(self, proto):
+               data = {
+                       "ip" : self.get_address(proto),
+                       "id" : self.hostname,
+                       "username" : self.username,
+                       "password" : self.password,
+               }
+
+               # Send update to the server.
+               response = self.send_request(self.url, data=data)
+
+               # Get the full response message.
+               output = response.read()
+
+               # Handle success messages.
+               if output.startswith("success") or output.startswith("error-record-ip-same"):
+                       return
+
+               # Handle error codes.
+               if output.startswith("error-auth-suspend"):
+                       raise DDNSRequestError(_("Account has been suspended."))
+
+               elif output.startswith("error-auth-voided"):
+                       raise DDNSRequestError(_("Account has been revoked."))
+
+               elif output.startswith("error-record-invalid"):
+                       raise DDNSRequestError(_("Specified host does not exist."))
+
+               elif output.startswith("error-auth"):
+                       raise DDNSAuthenticationError
+
+               # If we got here, some other update error happened.
+               raise DDNSUpdateError(_("Server response: %s") % output)
+
+
+class DDNSProviderZZZZ(DDNSProvider):
+       handle    = "zzzz.io"
+       name      = "zzzz"
+       website   = "https://zzzz.io"
+       protocols = ("ipv6", "ipv4",)
+
+       # Detailed information about the update request can be found here:
+       # https://zzzz.io/faq/
+
+       # Details about the possible response codes have been provided in the bugtracker:
+       # https://bugzilla.ipfire.org/show_bug.cgi?id=10584#c2
+
+       url = "https://zzzz.io/api/v1/update"
+       can_remove_records = False
+
+       def update_protocol(self, proto):
+               data = {
+                       "ip"    : self.get_address(proto),
+                       "token" : self.token,
+               }
+
+               if proto == "ipv6":
+                       data["type"] = "aaaa"
+
+               # zzzz uses the host from the full hostname as part
+               # of the update url.
+               host, domain = self.hostname.split(".", 1)
+
+               # Add host value to the update url.
+               url = "%s/%s" % (self.url, host)
+
+               # Send update to the server.
+               try:
+                       response = self.send_request(url, data=data)
+
+               # Handle error codes.
+               except DDNSNotFound:
+                       raise DDNSRequestError(_("Invalid hostname specified"))
+
+               # Handle success messages.
+               if response.code == 200:
+                       return
+
+               # If we got here, some other update error happened.
+               raise DDNSUpdateError