X-Git-Url: http://git.ipfire.org/?p=oddments%2Fddns.git;a=blobdiff_plain;f=src%2Fddns%2Fproviders.py;h=59ccd728cd1f7e26f30a4054e6d13c6abff33895;hp=41c3fa17181f9fc9f90280f942d4d04b7cf98a6a;hb=12b3818bd9a9097931dd547e3f85e535ebba1e1b;hpb=5d4bec40e099aad32905cd870ce4ce9faf82e31c

diff --git a/src/ddns/providers.py b/src/ddns/providers.py
index 41c3fa1..59ccd72 100644
--- a/src/ddns/providers.py
+++ b/src/ddns/providers.py
@@ -20,6 +20,7 @@
 ###############################################################################
 
 import logging
+import subprocess
 import urllib2
 import xml.dom.minidom
 
@@ -31,6 +32,14 @@ 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):
 	# A short string that uniquely identifies
 	# this provider.
@@ -48,6 +57,24 @@ class DDNSProvider(object):
 
 	DEFAULT_SETTINGS = {}
 
+	# 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
+
 	def __init__(self, core, **settings):
 		self.core = core
 
@@ -102,12 +129,16 @@ class DDNSProvider(object):
 
 		# Check if we actually need to update this host.
 		elif self.is_uptodate(self.protocols):
-			logger.debug(_("%s is already up to date") % self.hostname)
+			logger.info(_("The dynamic host %(hostname)s (%(provider)s) is already up to date") % \
+				{ "hostname" : self.hostname, "provider" : self.name })
 			return
 
 		# Execute the update.
 		self.update()
 
+		logger.info(_("Dynamic DNS update for %(hostname)s (%(provider)s) successful") % \
+			{ "hostname" : self.hostname, "provider" : self.name })
+
 	def update(self):
 		raise NotImplementedError
 
@@ -155,7 +186,7 @@ class DDNSProtocolDynDNS2(object):
 	"""
 
 	# 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/perform-update/
 	# http://dyn.com/support/developers/api/return-codes/
 
 	def _prepare_request_data(self):
@@ -198,6 +229,35 @@ class DDNSProtocolDynDNS2(object):
 		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):
 	handle    = "all-inkl.com"
 	name      = "All-inkl.com"
@@ -227,6 +287,72 @@ class DDNSProviderAllInkl(DDNSProvider):
 		raise DDNSUpdateError
 
 
+class DDNSProviderBindNsupdate(DDNSProvider):
+	handle  = "nsupdate"
+	name    = "BIND nsupdate utility"
+	website = "http://en.wikipedia.org/wiki/Nsupdate"
+
+	DEFAULT_TTL = 60
+
+	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)
+
+		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 DDNSProviderDHS(DDNSProvider):
 	handle    = "dhs.org"
 	name      = "DHS International"
@@ -410,6 +536,88 @@ class DDNSProviderEasyDNS(DDNSProtocolDynDNS2, DDNSProvider):
 	url = "http://api.cp.easydns.com/dyn/tomato.php"
 
 
+class DDNSProviderEnomCom(DDNSResponseParserXML, DDNSProvider):
+	handle    = "enom.com"
+	name      = "eNom Inc."
+	website   = "http://www.enom.com/"
+
+	# There are very detailed information about how to send an update request and
+	# the respone codes.
+	# http://www.enom.com/APICommandCatalog/
+
+	url = "https://dynamic.name-services.com/interface.asp"
+
+	def update(self):
+		data = {
+			"command"        : "setdnshost",
+			"responsetype"   : "xml",
+			"address"        : self.get_address("ipv4"),
+			"domainpassword" : self.password,
+			"zone"           : self.hostname
+		}
+
+		# 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 self.get_xml_tag_value(output, "ErrCount") == "0":
+			return
+
+		# Handle error codes.
+		errorcode = self.get_xml_tag_value(output, "ResponseNumber")
+
+		if errorcode == "304155":
+			raise DDNSAuthenticationError
+		elif errorcode == "304153":
+			raise DDNSRequestError(_("Domain not found."))
+
+		# If we got here, some other update error happened.
+		raise DDNSUpdateError
+
+
+class DDNSProviderEntryDNS(DDNSProvider):
+	handle    = "entrydns.net"
+	name      = "EntryDNS"
+	website   = "http://entrydns.net/"
+	protocols = ("ipv4",)
+
+	# Some very tiny details about their so called "Simple API" can be found
+	# here: https://entrydns.net/help
+	url = "https://entrydns.net/records/modify"
+
+	def update(self):
+		data = {
+			"ip" : self.get_address("ipv4")
+		}
+
+		# Add auth token to the update url.
+		url = "%s/%s" % (self.url, self.token)
+
+		# Send update to the server.
+		try:
+			response = self.send_request(url, method="PUT", data=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"))
+
+			raise
+
+		# Handle success messages.
+		if response.code == 200:
+			return
+
+		# If we got here, some other update error happened.
+		raise DDNSUpdateError
+
+
 class DDNSProviderFreeDNSAfraidOrg(DDNSProvider):
 	handle    = "freedns.afraid.org"
 	name      = "freedns.afraid.org"
@@ -436,6 +644,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
 
@@ -492,7 +704,7 @@ class DDNSProviderLightningWireLabs(DDNSProvider):
 		raise DDNSUpdateError
 
 
-class DDNSProviderNamecheap(DDNSProvider):
+class DDNSProviderNamecheap(DDNSResponseParserXML, DDNSProvider):
 	handle    = "namecheap.com"
 	name      = "Namecheap"
 	website   = "http://namecheap.com"
@@ -504,26 +716,6 @@ class DDNSProviderNamecheap(DDNSProvider):
 
 	url = "https://dynamicdns.park-your-domain.com/update"
 
-	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)
-
-		# 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
-		
 	def update(self):
 		# Namecheap requires the hostname splitted into a host and domain part.
 		host, domain = self.hostname.split(".", 1)
@@ -542,11 +734,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") == self.get_address("ipv4"):
 			return
 
 		# Handle error codes.
-		errorcode = self.parse_xml(output, "ResponseNumber")
+		errorcode = self.get_xml_tag_value(output, "ResponseNumber")
 
 		if errorcode == "304156":
 			raise DDNSAuthenticationError
@@ -582,6 +774,72 @@ class DDNSProviderNOIP(DDNSProtocolDynDNS2, DDNSProvider):
 		return data
 
 
+class DDNSProviderNsupdateINFO(DDNSProtocolDynDNS2, DDNSProvider):
+	handle    = "nsupdate.info"
+	name      = "nsupdate.info"
+	website   = "http://www.nsupdate.info/"
+	protocols = ("ipv6", "ipv4",)
+
+	# Information about the format of the HTTP request can be found
+	# after login on the provider user intrface and here:
+	# http://nsupdateinfo.readthedocs.org/en/latest/user.html
+
+	# 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.get("secret")
+
+	@property
+	def proto(self):
+		return self.get("proto")
+
+	@property
+	def url(self):
+		# The update URL is different by the used protocol.
+		if self.proto == "ipv4":
+			return "https://ipv4.nsupdate.info/nic/update"
+		elif self.proto == "ipv6":
+			return "https://ipv6.nsupdate.info/nic/update"
+		else:
+			raise DDNSUpdateError(_("Invalid protocol has been given"))
+
+	def _prepare_request_data(self):
+		data = {
+			"myip" : self.get_address(self.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"
+
+	@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
+
+
 class DDNSProviderOVH(DDNSProtocolDynDNS2, DDNSProvider):
 	handle    = "ovh.com"
 	name      = "OVH"