[ddns.git] / src / ddns / providers.py

#!/usr/bin/python
###############################################################################
#                                                                             #
# ddns - A dynamic DNS client for IPFire                                      #
# Copyright (C) 2012 IPFire development team                                  #
#                                                                             #
# This program is free software: you can redistribute it and/or modify        #
# it under the terms of the GNU General Public License as published by        #
# the Free Software Foundation, either version 3 of the License, or           #
# (at your option) any later version.                                         #
#                                                                             #
# This program is distributed in the hope that it will be useful,             #
# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               #
# GNU General Public License for more details.                                #
#                                                                             #
# You should have received a copy of the GNU General Public License           #
# along with this program.  If not, see <http://www.gnu.org/licenses/>.       #
#                                                                             #
###############################################################################

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
		# this provider.
		"handle"    : 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 list of supported protocols.
		"protocols" : ["ipv6", "ipv4"],
	}

	DEFAULT_SETTINGS = {}

	def __init__(self, core, **settings):
		self.core = core

		# Copy a set of default settings and
		# update them by those from the configuration file.
		self.settings = self.DEFAULT_SETTINGS.copy()
		self.settings.update(settings)

	def __repr__(self):
		return "<DDNS Provider %s (%s)>" % (self.name, self.handle)

	def __cmp__(self, other):
		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 get(self, key, default=None):
		"""
			Get a setting from the settings dictionary.
		"""
		return self.settings.get(key, default)

	@property
	def hostname(self):
		"""
			Fast access to the hostname.
		"""
		return self.get("hostname")

	@property
	def username(self):
		"""
			Fast access to the username.
		"""
		return self.get("username")

	@property
	def password(self):
		"""
			Fast access to the password.
		"""
		return self.get("password")

	@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
			method.
		"""
		return self.core.system.send_request(*args, **kwargs)

	def get_address(self, proto):
		"""
			Proxy method to get the current IP address.
		"""
		return self.core.system.get_address(proto)


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,
			"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 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 = {
			"hostname" : self.hostname,
			"myip"     : self.get_address("ipv4"),
			"system"   : "dyndns",
		}


class DDNSProviderSelfhost(DDNSProvider):
	INFO = {
		"handle"    : "selfhost.de",
		"name"      : "Selfhost.de",
		"website"   : "http://www.selfhost.de/",
		"protocols" : ["ipv4",],
	}

	url = "https://carol.selfhost.de/update"

	def update(self):
		data = {
			"username" : self.username,
			"password" : self.password,
			"textmodi" : "1",
		}

		response = self.send_request(self.url, data=data)

		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)
		}
Commit	Line	Data
f22ab085	1	#!/usr/bin/python
3fdcb9d1 MT	2	###############################################################################
	3	# #
	4	# ddns - A dynamic DNS client for IPFire #
	5	# Copyright (C) 2012 IPFire development team #
	6	# #
	7	# This program is free software: you can redistribute it and/or modify #
	8	# it under the terms of the GNU General Public License as published by #
	9	# the Free Software Foundation, either version 3 of the License, or #
	10	# (at your option) any later version. #
	11	# #
	12	# This program is distributed in the hope that it will be useful, #
	13	# but WITHOUT ANY WARRANTY; without even the implied warranty of #
	14	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
	15	# GNU General Public License for more details. #
	16	# #
	17	# You should have received a copy of the GNU General Public License #
	18	# along with this program. If not, see <http://www.gnu.org/licenses/>. #
	19	# #
	20	###############################################################################
f22ab085	21
7399fc5b MT	22	import logging
	23
	24	from i18n import _
	25
f22ab085 MT	26	# Import all possible exception types.
	27	from .errors import *
	28
7399fc5b MT	29	logger = logging.getLogger("ddns.providers")
	30	logger.propagate = 1
	31
f22ab085 MT	32	class DDNSProvider(object):
	33	INFO = {
	34	# A short string that uniquely identifies
	35	# this provider.
	36	"handle" : None,
	37
	38	# The full name of the provider.
	39	"name" : None,
	40
	41	# A weburl to the homepage of the provider.
	42	# (Where to register a new account?)
	43	"website" : None,
	44
	45	# A list of supported protocols.
	46	"protocols" : ["ipv6", "ipv4"],
	47	}
	48
	49	DEFAULT_SETTINGS = {}
	50
	51	def __init__(self, core, **settings):
	52	self.core = core
	53
	54	# Copy a set of default settings and
	55	# update them by those from the configuration file.
	56	self.settings = self.DEFAULT_SETTINGS.copy()
	57	self.settings.update(settings)
	58
	59	def __repr__(self):
	60	return "<DDNS Provider %s (%s)>" % (self.name, self.handle)
	61
	62	def __cmp__(self, other):
	63	return cmp(self.hostname, other.hostname)
	64
	65	@property
	66	def name(self):
	67	"""
	68	Returns the name of the provider.
	69	"""
	70	return self.INFO.get("name")
	71
	72	@property
	73	def website(self):
	74	"""
	75	Returns the website URL of the provider
	76	or None if that is not available.
	77	"""
	78	return self.INFO.get("website", None)
	79
	80	@property
	81	def handle(self):
	82	"""
	83	Returns the handle of this provider.
	84	"""
	85	return self.INFO.get("handle")
	86
	87	def get(self, key, default=None):
	88	"""
	89	Get a setting from the settings dictionary.
	90	"""
	91	return self.settings.get(key, default)
	92
	93	@property
	94	def hostname(self):
	95	"""
96	Fast access to the hostname.
97	"""
98	return self.get("hostname")
99
100	@property
101	def username(self):
102	"""
103	Fast access to the username.
104	"""
105	return self.get("username")
106
107	@property
108	def password(self):
109	"""
110	Fast access to the password.
111	"""
112	return self.get("password")
113
7399fc5b MT	114	@property
	115	def protocols(self):
	116	return self.INFO.get("protocols")
	117
46687828 SS	118	@property
	119	def token(self):
	120	"""
	121	Fast access to the token.
	122	"""
	123	return self.get("token")
	124
9da3e685 MT	125	def __call__(self, force=False):
	126	if force:
	127	logger.info(_("Updating %s forced") % self.hostname)
	128
7399fc5b	129	# Check if we actually need to update this host.
9da3e685	130	elif self.is_uptodate(self.protocols):
7399fc5b MT	131	logger.info(_("%s is already up to date") % self.hostname)
	132	return
	133
	134	# Execute the update.
5f402f36 MT	135	self.update()
	136
	137	def update(self):
f22ab085 MT	138	raise NotImplementedError
f22ab085 MT	139
7399fc5b MT	140	def is_uptodate(self, protos):
	141	"""
	142	Returns True if this host is already up to date
	143	and does not need to change the IP address on the
	144	name server.
	145	"""
	146	for proto in protos:
	147	addresses = self.core.system.resolve(self.hostname, proto)
	148
	149	current_address = self.get_address(proto)
	150
	151	if not current_address in addresses:
	152	return False
	153
	154	return True
	155
f22ab085 MT	156	def send_request(self, args, *kwargs):
	157	"""
	158	Proxy connection to the send request
	159	method.
	160	"""
	161	return self.core.system.send_request(args, *kwargs)
	162
	163	def get_address(self, proto):
	164	"""
	165	Proxy method to get the current IP address.
	166	"""
	167	return self.core.system.get_address(proto)
	168
	169
f3cf1f70 SS	170	class DDNSProviderDHS(DDNSProvider):
	171	INFO = {
	172	"handle" : "dhs.org",
	173	"name" : "DHS International",
	174	"website" : "http://dhs.org/",
	175	"protocols" : ["ipv4",]
	176	}
	177
	178	# No information about the used update api provided on webpage,
	179	# grabed from source code of ez-ipudate.
	180	url = "http://members.dhs.org/nic/hosts"
	181
5f402f36	182	def update(self):
f3cf1f70 SS	183	data = {
	184	"domain" : self.hostname,
	185	"ip" : self.get_address("ipv4"),
	186	"hostcmd" : "edit",
	187	"hostcmdstage" : "2",
	188	"type" : "4",
	189	}
	190
	191	# Send update to the server.
175c9b80	192	response = self.send_request(self.url, username=self.username, password=self.password,
f3cf1f70 SS	193	data=data)
	194
	195	# Handle success messages.
	196	if response.code == 200:
	197	return
	198
	199	# Handle error codes.
4caed6ed	200	elif response.code == 401:
f3cf1f70 SS	201	raise DDNSAuthenticationError
	202
	203	# If we got here, some other update error happened.
	204	raise DDNSUpdateError
	205
	206
39301272 SS	207	class DDNSProviderDNSpark(DDNSProvider):
	208	INFO = {
	209	"handle" : "dnspark.com",
	210	"name" : "DNS Park",
	211	"website" : "http://dnspark.com/",
	212	"protocols" : ["ipv4",]
	213	}
	214
	215	# Informations to the used api can be found here:
	216	# https://dnspark.zendesk.com/entries/31229348-Dynamic-DNS-API-Documentation
	217	url = "https://control.dnspark.com/api/dynamic/update.php"
	218
5f402f36	219	def update(self):
39301272 SS	220	data = {
	221	"domain" : self.hostname,
	222	"ip" : self.get_address("ipv4"),
	223	}
	224
	225	# Send update to the server.
175c9b80	226	response = self.send_request(self.url, username=self.username, password=self.password,
39301272 SS	227	data=data)
	228
	229	# Get the full response message.
	230	output = response.read()
	231
	232	# Handle success messages.
	233	if output.startswith("ok") or output.startswith("nochange"):
	234	return
	235
	236	# Handle error codes.
	237	if output == "unauth":
	238	raise DDNSAuthenticationError
	239	elif output == "abuse":
	240	raise DDNSAbuseError
	241	elif output == "blocked":
	242	raise DDNSBlockedError
	243	elif output == "nofqdn":
	244	raise DDNSRequestError(_("No valid FQDN was given."))
	245	elif output == "nohost":
	246	raise DDNSRequestError(_("Invalid hostname specified."))
	247	elif output == "notdyn":
	248	raise DDNSRequestError(_("Hostname not marked as a dynamic host."))
	249	elif output == "invalid":
	250	raise DDNSRequestError(_("Invalid IP address has been sent."))
	251
	252	# If we got here, some other update error happened.
	253	raise DDNSUpdateError
	254
43b2cd59 SS	255
	256	class DDNSProviderDtDNS(DDNSProvider):
	257	INFO = {
	258	"handle" : "dtdns.com",
	259	"name" : "DtDNS",
	260	"website" : "http://dtdns.com/",
	261	"protocols" : ["ipv4",]
	262	}
	263
	264	# Information about the format of the HTTPS request is to be found
	265	# http://www.dtdns.com/dtsite/updatespec
	266	url = "https://www.dtdns.com/api/autodns.cfm"
	267
43b2cd59 SS	268	def update(self):
	269	data = {
	270	"ip" : self.get_address("ipv4"),
	271	"id" : self.hostname,
	272	"pw" : self.password
	273	}
	274
	275	# Send update to the server.
	276	response = self.send_request(self.url, data=data)
	277
	278	# Get the full response message.
	279	output = response.read()
	280
	281	# Remove all leading and trailing whitespace.
	282	output = output.strip()
	283
	284	# Handle success messages.
	285	if "now points to" in output:
	286	return
	287
	288	# Handle error codes.
	289	if output == "No hostname to update was supplied.":
	290	raise DDNSRequestError(_("No hostname specified."))
	291
	292	elif output == "The hostname you supplied is not valid.":
	293	raise DDNSRequestError(_("Invalid hostname specified."))
	294
	295	elif output == "The password you supplied is not valid.":
	296	raise DDNSAuthenticationError
	297
	298	elif output == "Administration has disabled this account.":
	299	raise DDNSRequestError(_("Account has been disabled."))
	300
	301	elif output == "Illegal character in IP.":
	302	raise DDNSRequestError(_("Invalid IP address has been sent."))
	303
	304	elif output == "Too many failed requests.":
	305	raise DDNSRequestError(_("Too many failed requests."))
	306
	307	# If we got here, some other update error happened.
	308	raise DDNSUpdateError
	309
	310
bfed6701 SS	311	class DDNSProviderDynDNS(DDNSProvider):
	312	INFO = {
	313	"handle" : "dyndns.org",
	314	"name" : "Dyn",
	315	"website" : "http://dyn.com/dns/",
	316	"protocols" : ["ipv4",]
	317	}
	318
	319	# Information about the format of the request is to be found
	320	# http://http://dyn.com/support/developers/api/perform-update/
	321	# http://dyn.com/support/developers/api/return-codes/
	322	url = "https://members.dyndns.org/nic/update"
	323
88f39629	324	def _prepare_request_data(self):
bfed6701 SS	325	data = {
	326	"hostname" : self.hostname,
	327	"myip" : self.get_address("ipv4"),
	328	}
	329
88f39629 SS	330	return data
	331
	332	def update(self):
	333	data = self._prepare_request_data()
	334
bfed6701	335	# Send update to the server.
88f39629 SS	336	response = self.send_request(self.url, data=data,
88f39629 SS	337	username=self.username, password=self.password)
bfed6701 SS	338
	339	# Get the full response message.
	340	output = response.read()
	341
	342	# Handle success messages.
	343	if output.startswith("good") or output.startswith("nochg"):
	344	return
	345
	346	# Handle error codes.
	347	if output == "badauth":
	348	raise DDNSAuthenticationError
	349	elif output == "aduse":
	350	raise DDNSAbuseError
	351	elif output == "notfqdn":
	352	raise DDNSRequestError(_("No valid FQDN was given."))
	353	elif output == "nohost":
	354	raise DDNSRequestError(_("Specified host does not exist."))
	355	elif output == "911":
	356	raise DDNSInternalServerError
	357	elif output == "dnserr":
	358	raise DDNSInternalServerError(_("DNS error encountered."))
	359
	360	# If we got here, some other update error happened.
	361	raise DDNSUpdateError
	362
	363
ee071271 SS	364	class DDNSProviderEasyDNS(DDNSProviderDynDNS):
	365	INFO = {
	366	"handle" : "easydns.com",
	367	"name" : "EasyDNS",
	368	"website" : "http://www.easydns.com/",
	369	"protocols" : ["ipv4",]
	370	}
	371
	372	# There is only some basic documentation provided by the vendor,
	373	# also searching the web gain very poor results.
	374	# http://mediawiki.easydns.com/index.php/Dynamic_DNS
	375
	376	url = "http://api.cp.easydns.com/dyn/tomato.php"
	377
	378
aa21a4c6 SS	379	class DDNSProviderFreeDNSAfraidOrg(DDNSProvider):
	380	INFO = {
	381	"handle" : "freedns.afraid.org",
	382	"name" : "freedns.afraid.org",
	383	"website" : "http://freedns.afraid.org/",
	384	"protocols" : ["ipv6", "ipv4",]
	385	}
	386
	387	# No information about the request or response could be found on the vendor
	388	# page. All used values have been collected by testing.
	389	url = "https://freedns.afraid.org/dynamic/update.php"
	390
	391	@property
	392	def proto(self):
	393	return self.get("proto")
	394
	395	def update(self):
	396	address = self.get_address(self.proto)
	397
	398	data = {
	399	"address" : address,
	400	}
	401
	402	# Add auth token to the update url.
	403	url = "%s?%s" % (self.url, self.token)
	404
	405	# Send update to the server.
	406	response = self.send_request(url, data=data)
	407
aa21a4c6 SS	408	if output.startswith("Updated") or "has not changed" in output:
	409	return
	410
	411	# Handle error codes.
	412	if output == "ERROR: Unable to locate this record":
	413	raise DDNSAuthenticationError
	414	elif "is an invalid IP address" in output:
	415	raise DDNSRequestError(_("Invalid IP address has been sent."))
	416
aa21a4c6	417
a08c1b72 SS	418	class DDNSProviderLightningWireLabs(DDNSProvider):
	419	INFO = {
	420	"handle" : "dns.lightningwirelabs.com",
	421	"name" : "Lightning Wire Labs",
	422	"website" : "http://dns.lightningwirelabs.com/",
	423	"protocols" : ["ipv6", "ipv4",]
	424	}
	425
	426	# Information about the format of the HTTPS request is to be found
	427	# https://dns.lightningwirelabs.com/knowledge-base/api/ddns
	428	url = "https://dns.lightningwirelabs.com/update"
	429
5f402f36	430	def update(self):
a08c1b72 SS	431	data = {
	432	"hostname" : self.hostname,
	433	}
	434
	435	# Check if we update an IPv6 address.
	436	address6 = self.get_address("ipv6")
	437	if address6:
	438	data["address6"] = address6
	439
	440	# Check if we update an IPv4 address.
	441	address4 = self.get_address("ipv4")
	442	if address4:
	443	data["address4"] = address4
	444
	445	# Raise an error if none address is given.
	446	if not data.has_key("address6") and not data.has_key("address4"):
	447	raise DDNSConfigurationError
	448
	449	# Check if a token has been set.
	450	if self.token:
	451	data["token"] = self.token
	452
	453	# Check for username and password.
	454	elif self.username and self.password:
	455	data.update({
	456	"username" : self.username,
	457	"password" : self.password,
	458	})
	459
	460	# Raise an error if no auth details are given.
	461	else:
	462	raise DDNSConfigurationError
	463
	464	# Send update to the server.
cb455540	465	response = self.send_request(self.url, data=data)
a08c1b72 SS	466
	467	# Handle success messages.
	468	if response.code == 200:
	469	return
	470
	471	# Handle error codes.
2e5ad318	472	if response.code == 403:
a08c1b72	473	raise DDNSAuthenticationError
2e5ad318	474	elif response.code == 400:
a08c1b72 SS	475	raise DDNSRequestError
	476
	477	# If we got here, some other update error happened.
	478	raise DDNSUpdateError
	479
	480
88f39629	481	class DDNSProviderNOIP(DDNSProviderDynDNS):
f22ab085 MT	482	INFO = {
	483	"handle" : "no-ip.com",
	484	"name" : "No-IP",
	485	"website" : "http://www.no-ip.com/",
	486	"protocols" : ["ipv4",]
	487	}
	488
	489	# Information about the format of the HTTP request is to be found
	490	# here: http://www.no-ip.com/integrate/request and
	491	# here: http://www.no-ip.com/integrate/response
	492
88f39629	493	url = "http://dynupdate.no-ip.com/nic/update"
2de06f59	494
88f39629	495	def _prepare_request_data(self):
2de06f59 MT	496	data = {
2de06f59 MT	497	"hostname" : self.hostname,
f22ab085 MT	498	"address" : self.get_address("ipv4"),
	499	}
	500
88f39629	501	return data
f22ab085 MT	502
f22ab085 MT	503
a508bda6 SS	504	class DDNSProviderOVH(DDNSProviderDynDNS):
	505	INFO = {
	506	"handle" : "ovh.com",
	507	"name" : "OVH",
	508	"website" : "http://www.ovh.com/",
	509	"protocols" : ["ipv4",]
	510	}
	511
	512	# OVH only provides very limited information about how to
	513	# update a DynDNS host. They only provide the update url
	514	# on the their german subpage.
	515	#
	516	# http://hilfe.ovh.de/DomainDynHost
	517
	518	url = "https://www.ovh.com/nic/update"
	519
	520	def _prepare_request_data(self):
	521	data = {
	522	"hostname" : self.hostname,
	523	"myip" : self.get_address("ipv4"),
	524	"system" : "dyndns",
	525	}
	526
	527
f22ab085 MT	528	class DDNSProviderSelfhost(DDNSProvider):
	529	INFO = {
	530	"handle" : "selfhost.de",
	531	"name" : "Selfhost.de",
	532	"website" : "http://www.selfhost.de/",
	533	"protocols" : ["ipv4",],
	534	}
	535
2de06f59	536	url = "https://carol.selfhost.de/update"
f22ab085	537
5f402f36	538	def update(self):
2de06f59 MT	539	data = {
	540	"username" : self.username,
	541	"password" : self.password,
	542	"textmodi" : "1",
	543	}
f22ab085	544
2de06f59	545	response = self.send_request(self.url, data=data)
f22ab085 MT	546
	547	match = re.search("status=20(0\|4)", response.read())
	548	if not match:
	549	raise DDNSUpdateError
b09b1545 SS	550
	551
	552	class DDNSProviderSPDNS(DDNSProviderDynDNS):
	553	INFO = {
	554	"handle" : "spdns.org",
	555	"name" : "SPDNS",
	556	"website" : "http://spdns.org/",
	557	"protocols" : ["ipv4",]
	558	}
	559
	560	# Detailed information about request and response codes are provided
	561	# by the vendor. They are using almost the same mechanism and status
	562	# codes as dyndns.org so we can inherit all those stuff.
	563	#
	564	# http://wiki.securepoint.de/index.php/SPDNS_FAQ
	565	# http://wiki.securepoint.de/index.php/SPDNS_Update-Tokens
	566
	567	url = "https://update.spdns.de/nic/update"
4ec90b93 MT	568
4ec90b93 MT	569
c8c7ca8f SS	570	class DDNSProviderVariomedia(DDNSProviderDynDNS):
	571	INFO = {
	572	"handle" : "variomedia.de",
	573	"name" : "Variomedia",
	574	"website" : "http://www.variomedia.de/",
	575	"protocols" : ["ipv6", "ipv4",]
	576	}
	577
	578	# Detailed information about the request can be found here
	579	# https://dyndns.variomedia.de/
	580
	581	url = "https://dyndns.variomedia.de/nic/update"
	582
	583	@property
	584	def proto(self):
	585	return self.get("proto")
	586
	587	def _prepare_request_data(self):
	588	data = {
	589	"hostname" : self.hostname,
	590	"myip" : self.get_address(self.proto)
	591	}