X-Git-Url: http://git.ipfire.org/?p=ddns.git;a=blobdiff_plain;f=src%2Fddns%2Fproviders.py;h=fdc86c69d53778f561d7a303e430f7b6915db7be;hp=124cf2f8280e7618759725d733b0d3573492025a;hb=a6183090496610c5eeccdc5a783bb85c435c9e16;hpb=dc11f1ea84d1f1200ea2442cb3010254841ca115

diff --git a/src/ddns/providers.py b/src/ddns/providers.py
index 124cf2f..fdc86c6 100644
--- a/src/ddns/providers.py
+++ b/src/ddns/providers.py
@@ -19,9 +19,16 @@
 #                                                                             #
 ###############################################################################
 
+import logging
+
+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
@@ -104,9 +111,48 @@ class DDNSProvider(object):
 		"""
 		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
@@ -121,33 +167,174 @@ class DDNSProvider(object):
 		return self.core.system.get_address(proto)
 
 
-class DDNSProviderNOIP(DDNSProvider):
+class DDNSProviderDHS(DDNSProvider):
 	INFO = {
-		"handle"    : "no-ip.com",
-		"name"      : "No-IP",
-		"website"   : "http://www.no-ip.com/",
+		"handle"    : "dhs.org",
+		"name"      : "DHS International",
+		"website"   : "http://dhs.org/",
 		"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
+	# No information about the used update api provided on webpage,
+	# grabed from source code of ez-ipudate.
+	url = "http://members.dhs.org/nic/hosts"
 
-	url = "http://%(username)s:%(password)s@dynupdate.no-ip.com/nic/update"
+	def update(self):
+		data = {
+			"domain"       : self.hostname,
+			"ip"           : self.get_address("ipv4"),
+			"hostcmd"      : "edit",
+			"hostcmdstage" : "2",
+			"type"         : "4",
+		}
 
-	def __call__(self):
-		url = self.url % {
-			"username" : self.username,
-			"password" : self.password,
+		# 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()
@@ -161,8 +348,279 @@ class DDNSProviderNOIP(DDNSProvider):
 			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
@@ -178,7 +636,7 @@ class DDNSProviderSelfhost(DDNSProvider):
 
 	url = "https://carol.selfhost.de/update"
 
-	def __call__(self):
+	def update(self):
 		data = {
 			"username" : self.username,
 			"password" : self.password,
@@ -190,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