# #
###############################################################################
+import logging
+import urllib2
+
+from i18n import _
+
# Import all possible exception types.
from .errors import *
+logger = logging.getLogger("ddns.providers")
+logger.propagate = 1
+
class DDNSProvider(object):
INFO = {
# A short string that uniquely identifies
"""
return self.get("password")
- def __call__(self):
+ @property
+ 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)
+
+ # 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)
+ return
+
+ # Execute the update.
+ self.update()
+
+ def update(self):
raise NotImplementedError
+ def is_uptodate(self, protos):
+ """
+ Returns True if this host is already up to date
+ and does not need to change the IP address on the
+ name server.
+ """
+ for proto in protos:
+ addresses = self.core.system.resolve(self.hostname, proto)
+
+ current_address = self.get_address(proto)
+
+ if not current_address in addresses:
+ return False
+
+ return True
+
def send_request(self, *args, **kwargs):
"""
Proxy connection to the send request
return self.core.system.get_address(proto)
-class DDNSProviderNOIP(DDNSProvider):
+class DDNSProviderAllInkl(DDNSProvider):
INFO = {
- "handle" : "no-ip.com",
- "name" : "No-IP",
- "website" : "http://www.no-ip.com/",
+ "handle" : "all-inkl.com",
+ "name" : "All-inkl.com",
+ "website" : "http://all-inkl.com/",
"protocols" : ["ipv4",]
}
- # Information about the format of the HTTP request is to be found
- # here: http://www.no-ip.com/integrate/request and
- # here: http://www.no-ip.com/integrate/response
+ # There are only information provided by the vendor how to
+ # perform an update on a FRITZ Box. Grab requried informations
+ # from the net.
+ # http://all-inkl.goetze.it/v01/ddns-mit-einfachen-mitteln/
- url = "http://%(username)s:%(password)s@dynupdate.no-ip.com/nic/update"
+ url = "http://dyndns.kasserver.com"
- def __call__(self):
- url = self.url % {
- "username" : self.username,
- "password" : self.password,
+ def update(self):
+
+ # There is no additional data required so we directly can
+ # send our request.
+ try:
+ # Send request to the server.
+ response = self.send_request(self.url, username=self.username, password=self.password)
+
+ # Handle 401 HTTP Header (Authentication Error)
+ except urllib2.HTTPError, e:
+ if e.code == 401:
+ raise DDNSAuthenticationError
+
+ raise
+
+ # 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 DDNSProviderDHS(DDNSProvider):
+ INFO = {
+ "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"
+
+ def update(self):
+ data = {
+ "domain" : self.hostname,
+ "ip" : self.get_address("ipv4"),
+ "hostcmd" : "edit",
+ "hostcmdstage" : "2",
+ "type" : "4",
}
+ # Send update to the server.
+ response = self.send_request(self.url, username=self.username, password=self.password,
+ data=data)
+
+ # Handle success messages.
+ 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",]
+ }
+
+ # 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"
+
+ def update(self):
+ data = {
+ "domain" : self.hostname,
+ "ip" : self.get_address("ipv4"),
+ }
+
+ # 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("ok") or output.startswith("nochange"):
+ return
+
+ # Handle error codes.
+ if output == "unauth":
+ raise DDNSAuthenticationError
+ elif output == "abuse":
+ raise DDNSAbuseError
+ elif output == "blocked":
+ raise DDNSBlockedError
+ elif output == "nofqdn":
+ raise DDNSRequestError(_("No valid FQDN was given."))
+ elif output == "nohost":
+ raise DDNSRequestError(_("Invalid hostname specified."))
+ elif output == "notdyn":
+ raise DDNSRequestError(_("Hostname not marked as a dynamic host."))
+ elif output == "invalid":
+ raise DDNSRequestError(_("Invalid IP address has been sent."))
+
+ # 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,
- "address" : self.get_address("ipv4"),
+ "myip" : self.get_address("ipv4"),
}
+ return data
+
+ def update(self):
+ data = self._prepare_request_data()
+
# Send update to the server.
- response = self.send_request(url, data=data)
+ response = self.send_request(self.url, data=data,
+ username=self.username, password=self.password)
# Get the full response message.
output = response.read()
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",
+ "name" : "Lightning Wire Labs",
+ "website" : "http://dns.lightningwirelabs.com/",
+ "protocols" : ["ipv6", "ipv4",]
+ }
+
+ # 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,
+ }
+
+ # 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
+
+ # Check for username and password.
+ elif self.username and self.password:
+ data.update({
+ "username" : self.username,
+ "password" : 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)
+
+ # Handle success messages.
+ 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 DDNSProviderNOIP(DDNSProviderDynDNS):
+ INFO = {
+ "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
+ # here: http://www.no-ip.com/integrate/response
+
+ url = "http://dynupdate.no-ip.com/nic/update"
+
+ def _prepare_request_data(self):
+ data = {
+ "hostname" : self.hostname,
+ "address" : self.get_address("ipv4"),
+ }
+
+ 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 "100" in output or "101" in output:
+ return
+
+ # Handle error codes.
+ if "401" or "402" in output:
+ raise DDNSAuthenticationError
+ 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.
raise DDNSUpdateError
url = "https://carol.selfhost.de/update"
- def __call__(self):
+ def update(self):
data = {
"username" : self.username,
"password" : self.password,
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 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
projects / oddments / ddns.git / blobdiff