X-Git-Url: http://git.ipfire.org/?p=ddns.git;a=blobdiff_plain;f=src%2Fddns%2Fproviders.py;h=fdc86c69d53778f561d7a303e430f7b6915db7be;hp=8576c9bccae0838c991478c83b406d079adc56d3;hb=a6183090496610c5eeccdc5a783bb85c435c9e16;hpb=4caed6ed57ba0c86e11c81f218b10efc9bf6a301 diff --git a/src/ddns/providers.py b/src/ddns/providers.py index 8576c9b..fdc86c6 100644 --- a/src/ddns/providers.py +++ b/src/ddns/providers.py @@ -115,6 +115,13 @@ class DDNSProvider(object): def protocols(self): return self.INFO.get("protocols") + @property + def token(self): + """ + Fast access to the token. + """ + return self.get("token") + def __call__(self, force=False): if force: logger.info(_("Updating %s forced") % self.hostname) @@ -173,11 +180,6 @@ class DDNSProviderDHS(DDNSProvider): url = "http://members.dhs.org/nic/hosts" def update(self): - url = self.url % { - "username" : self.username, - "password" : self.password, - } - data = { "domain" : self.hostname, "ip" : self.get_address("ipv4"), @@ -187,7 +189,7 @@ class DDNSProviderDHS(DDNSProvider): } # Send update to the server. - response = self.send_request(url, username=self.username, password=self.password, + response = self.send_request(self.url, username=self.username, password=self.password, data=data) # Handle success messages. @@ -215,18 +217,13 @@ class DDNSProviderDNSpark(DDNSProvider): url = "https://control.dnspark.com/api/dynamic/update.php" def update(self): - url = self.url % { - "username" : self.username, - "password" : self.password, - } - data = { "domain" : self.hostname, "ip" : self.get_address("ipv4"), } # Send update to the server. - response = self.send_request(url, username=self.username, password=self.password, + response = self.send_request(self.url, username=self.username, password=self.password, data=data) # Get the full response message. @@ -255,7 +252,195 @@ class DDNSProviderDNSpark(DDNSProvider): # If we got here, some other update error happened. raise DDNSUpdateError - + +class DDNSProviderDtDNS(DDNSProvider): + INFO = { + "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" + + def update(self): + data = { + "ip" : self.get_address("ipv4"), + "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(DDNSProvider): + INFO = { + "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" + + def _prepare_request_data(self): + data = { + "hostname" : self.hostname, + "myip" : self.get_address("ipv4"), + } + + 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) + + # 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 == "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.")) + + # If we got here, some other update error happened. + raise DDNSUpdateError + + +class DDNSProviderDynU(DDNSProviderDynDNS): + INFO = { + "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" + + def _prepare_request_data(self): + data = DDNSProviderDynDNS._prepare_request_data(self) + + # This one supports IPv6 + data.update({ + "myipv6" : self.get_address("ipv6"), + }) + + return data + + +class DDNSProviderEasyDNS(DDNSProviderDynDNS): + INFO = { + "handle" : "easydns.com", + "name" : "EasyDNS", + "website" : "http://www.easydns.com/", + "protocols" : ["ipv4",] + } + + # 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 + + url = "http://api.cp.easydns.com/dyn/tomato.php" + + +class DDNSProviderFreeDNSAfraidOrg(DDNSProvider): + INFO = { + "handle" : "freedns.afraid.org", + "name" : "freedns.afraid.org", + "website" : "http://freedns.afraid.org/", + "protocols" : ["ipv6", "ipv4",] + } + + # 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" + + @property + def proto(self): + return self.get("proto") + + def update(self): + address = self.get_address(self.proto) + + data = { + "address" : address, + } + + # Add auth token to the update url. + url = "%s?%s" % (self.url, self.token) + + # Send update to the server. + response = self.send_request(url, data=data) + + if output.startswith("Updated") or "has not changed" in output: + return + + # Handle error codes. + if output == "ERROR: Unable to locate this record": + raise DDNSAuthenticationError + elif "is an invalid IP address" in output: + raise DDNSRequestError(_("Invalid IP address has been sent.")) + + class DDNSProviderLightningWireLabs(DDNSProvider): INFO = { "handle" : "dns.lightningwirelabs.com", @@ -268,13 +453,6 @@ class DDNSProviderLightningWireLabs(DDNSProvider): # https://dns.lightningwirelabs.com/knowledge-base/api/ddns url = "https://dns.lightningwirelabs.com/update" - @property - def token(self): - """ - Fast access to the token. - """ - return self.get("token") - def update(self): data = { "hostname" : self.hostname, @@ -326,7 +504,7 @@ class DDNSProviderLightningWireLabs(DDNSProvider): raise DDNSUpdateError -class DDNSProviderNOIP(DDNSProvider): +class DDNSProviderNOIP(DDNSProviderDynDNS): INFO = { "handle" : "no-ip.com", "name" : "No-IP", @@ -338,35 +516,110 @@ class DDNSProviderNOIP(DDNSProvider): # here: http://www.no-ip.com/integrate/request and # here: http://www.no-ip.com/integrate/response - url = "http://%(username)s:%(password)s@dynupdate.no-ip.com/nic/update" - - def update(self): - url = self.url % { - "username" : self.username, - "password" : self.password, - } + url = "http://dynupdate.no-ip.com/nic/update" + def _prepare_request_data(self): data = { "hostname" : self.hostname, "address" : self.get_address("ipv4"), } - # Send update to the server. - response = self.send_request(url, data=data) + return data + + +class DDNSProviderOVH(DDNSProviderDynDNS): + INFO = { + "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 + # on the their german subpage. + # + # http://hilfe.ovh.de/DomainDynHost + + url = "https://www.ovh.com/nic/update" + + def _prepare_request_data(self): + data = DDNSProviderDynDNS._prepare_request_data(self) + data.update({ + "system" : "dyndns", + }) + + return data + + +class DDNSProviderRegfish(DDNSProvider): + INFO = { + "handle" : "regfish.com", + "name" : "Regfish GmbH", + "website" : "http://www.regfish.com/", + "protocols" : ["ipv6", "ipv4",] + } + + # 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/" + + def update(self): + data = { + "fqdn" : self.hostname, + } + + # Check if we update an IPv6 address. + address6 = self.get_address("ipv6") + if address6: + data["ipv6"] = address6 + + # Check if we update an IPv4 address. + address4 = self.get_address("ipv4") + if address4: + data["ipv4"] = address4 + + # Raise an error if none address is given. + if not data.has_key("ipv6") and not data.has_key("ipv4"): + raise DDNSConfigurationError + + # Check if a token has been set. + if self.token: + data["token"] = self.token + + # Raise an error if no token and no useranem and password + # are given. + elif not self.username and not self.password: + raise DDNSConfigurationError(_("No Auth details specified.")) + + # HTTP Basic Auth is only allowed if no token is used. + if self.token: + # Send update to the server. + response = self.send_request(self.url, data=data) + else: + # Send update to the server. + response = self.send_request(self.url, username=self.username, password=self.password, + data=data) # Get the full response message. output = response.read() # Handle success messages. - if output.startswith("good") or output.startswith("nochg"): + if "100" in output or "101" in output: return # Handle error codes. - if output == "badauth": + if "401" or "402" in output: raise DDNSAuthenticationError - elif output == "aduse": - raise DDNSAbuseError - elif output == "911": + elif "408" in output: + raise DDNSRequestError(_("Invalid IPv4 address has been sent.")) + elif "409" in output: + raise DDNSRequestError(_("Invalid IPv6 address has been sent.")) + elif "412" in output: + raise DDNSRequestError(_("No valid FQDN was given.")) + elif "414" in output: raise DDNSInternalServerError # If we got here, some other update error happened. @@ -395,3 +648,70 @@ class DDNSProviderSelfhost(DDNSProvider): match = re.search("status=20(0|4)", response.read()) if not match: raise DDNSUpdateError + + +class DDNSProviderSPDNS(DDNSProviderDynDNS): + INFO = { + "handle" : "spdns.org", + "name" : "SPDNS", + "website" : "http://spdns.org/", + "protocols" : ["ipv4",] + } + + # Detailed information about request and response codes are provided + # by the vendor. They are using almost the same mechanism and status + # codes as dyndns.org so we can inherit all those stuff. + # + # http://wiki.securepoint.de/index.php/SPDNS_FAQ + # http://wiki.securepoint.de/index.php/SPDNS_Update-Tokens + + url = "https://update.spdns.de/nic/update" + + +class DDNSProviderTwoDNS(DDNSProviderDynDNS): + INFO = { + "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 + # http://twodns.de/en/api + + url = "https://update.twodns.de/update" + + def _prepare_request_data(self): + data = { + "ip" : self.get_address("ipv4"), + "hostname" : self.hostname + } + + return data + + +class DDNSProviderVariomedia(DDNSProviderDynDNS): + INFO = { + "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): + data = { + "hostname" : self.hostname, + "myip" : self.get_address(self.proto) + } + + return data