[people/ms/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 update(self):
		data = {
			"hostname" : self.hostname,
			"myip"     : 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("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 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(DDNSProvider):
	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://%(username)s:%(password)s@dynupdate.no-ip.com/nic/update"

	def update(self):
		url = self.url % {
			"username" : self.username,
			"password" : self.password,
		}

		data = {
			"hostname" : self.hostname,
			"address"  : self.get_address("ipv4"),
		}

		# 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("good") or output.startswith("nochg"):
			return

		# Handle error codes.
		if output == "badauth":
			raise DDNSAuthenticationError
		elif output == "aduse":
			raise DDNSAbuseError
		elif output == "911":
			raise DDNSInternalServerError

		# If we got here, some other update error happened.
		raise DDNSUpdateError


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"
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
	324	def update(self):
	325	data = {
	326	"hostname" : self.hostname,
	327	"myip" : self.get_address("ipv4"),
	328	}
	329
	330	# Send update to the server.
	331	response = self.send_request(self.url, username=self.username, password=self.password,
	332	data=data)
	333
	334	# Get the full response message.
	335	output = response.read()
	336
	337	# Handle success messages.
	338	if output.startswith("good") or output.startswith("nochg"):
	339	return
	340
	341	# Handle error codes.
	342	if output == "badauth":
	343	raise DDNSAuthenticationError
	344	elif output == "aduse":
	345	raise DDNSAbuseError
	346	elif output == "notfqdn":
	347	raise DDNSRequestError(_("No valid FQDN was given."))
	348	elif output == "nohost":
	349	raise DDNSRequestError(_("Specified host does not exist."))
	350	elif output == "911":
	351	raise DDNSInternalServerError
	352	elif output == "dnserr":
	353	raise DDNSInternalServerError(_("DNS error encountered."))
	354
	355	# If we got here, some other update error happened.
	356	raise DDNSUpdateError
	357
	358
aa21a4c6 SS	359	class DDNSProviderFreeDNSAfraidOrg(DDNSProvider):
	360	INFO = {
	361	"handle" : "freedns.afraid.org",
	362	"name" : "freedns.afraid.org",
	363	"website" : "http://freedns.afraid.org/",
	364	"protocols" : ["ipv6", "ipv4",]
	365	}
	366
	367	# No information about the request or response could be found on the vendor
	368	# page. All used values have been collected by testing.
	369	url = "https://freedns.afraid.org/dynamic/update.php"
	370
	371	@property
	372	def proto(self):
	373	return self.get("proto")
	374
	375	def update(self):
	376	address = self.get_address(self.proto)
	377
	378	data = {
	379	"address" : address,
	380	}
	381
	382	# Add auth token to the update url.
	383	url = "%s?%s" % (self.url, self.token)
	384
	385	# Send update to the server.
	386	response = self.send_request(url, data=data)
	387
aa21a4c6 SS	388	if output.startswith("Updated") or "has not changed" in output:
	389	return
	390
	391	# Handle error codes.
	392	if output == "ERROR: Unable to locate this record":
	393	raise DDNSAuthenticationError
	394	elif "is an invalid IP address" in output:
	395	raise DDNSRequestError(_("Invalid IP address has been sent."))
	396
aa21a4c6	397
a08c1b72 SS	398	class DDNSProviderLightningWireLabs(DDNSProvider):
	399	INFO = {
	400	"handle" : "dns.lightningwirelabs.com",
	401	"name" : "Lightning Wire Labs",
	402	"website" : "http://dns.lightningwirelabs.com/",
	403	"protocols" : ["ipv6", "ipv4",]
	404	}
	405
	406	# Information about the format of the HTTPS request is to be found
	407	# https://dns.lightningwirelabs.com/knowledge-base/api/ddns
	408	url = "https://dns.lightningwirelabs.com/update"
	409
5f402f36	410	def update(self):
a08c1b72 SS	411	data = {
	412	"hostname" : self.hostname,
	413	}
	414
	415	# Check if we update an IPv6 address.
	416	address6 = self.get_address("ipv6")
	417	if address6:
	418	data["address6"] = address6
	419
	420	# Check if we update an IPv4 address.
	421	address4 = self.get_address("ipv4")
	422	if address4:
	423	data["address4"] = address4
	424
	425	# Raise an error if none address is given.
	426	if not data.has_key("address6") and not data.has_key("address4"):
	427	raise DDNSConfigurationError
	428
	429	# Check if a token has been set.
	430	if self.token:
	431	data["token"] = self.token
	432
	433	# Check for username and password.
	434	elif self.username and self.password:
	435	data.update({
	436	"username" : self.username,
	437	"password" : self.password,
	438	})
	439
	440	# Raise an error if no auth details are given.
	441	else:
	442	raise DDNSConfigurationError
	443
	444	# Send update to the server.
cb455540	445	response = self.send_request(self.url, data=data)
a08c1b72 SS	446
	447	# Handle success messages.
	448	if response.code == 200:
	449	return
	450
	451	# Handle error codes.
2e5ad318	452	if response.code == 403:
a08c1b72	453	raise DDNSAuthenticationError
2e5ad318	454	elif response.code == 400:
a08c1b72 SS	455	raise DDNSRequestError
	456
	457	# If we got here, some other update error happened.
	458	raise DDNSUpdateError
	459
	460
f22ab085 MT	461	class DDNSProviderNOIP(DDNSProvider):
	462	INFO = {
	463	"handle" : "no-ip.com",
	464	"name" : "No-IP",
	465	"website" : "http://www.no-ip.com/",
	466	"protocols" : ["ipv4",]
	467	}
	468
	469	# Information about the format of the HTTP request is to be found
	470	# here: http://www.no-ip.com/integrate/request and
	471	# here: http://www.no-ip.com/integrate/response
	472
2de06f59	473	url = "http://%(username)s:%(password)s@dynupdate.no-ip.com/nic/update"
f22ab085	474
5f402f36	475	def update(self):
f22ab085	476	url = self.url % {
f22ab085 MT	477	"username" : self.username,
f22ab085 MT	478	"password" : self.password,
2de06f59 MT	479	}
	480
	481	data = {
	482	"hostname" : self.hostname,
f22ab085 MT	483	"address" : self.get_address("ipv4"),
	484	}
	485
	486	# Send update to the server.
2de06f59	487	response = self.send_request(url, data=data)
f22ab085 MT	488
	489	# Get the full response message.
	490	output = response.read()
	491
	492	# Handle success messages.
	493	if output.startswith("good") or output.startswith("nochg"):
	494	return
	495
	496	# Handle error codes.
	497	if output == "badauth":
	498	raise DDNSAuthenticationError
	499	elif output == "aduse":
	500	raise DDNSAbuseError
	501	elif output == "911":
	502	raise DDNSInternalServerError
	503
	504	# If we got here, some other update error happened.
	505	raise DDNSUpdateError
	506
	507
	508	class DDNSProviderSelfhost(DDNSProvider):
	509	INFO = {
	510	"handle" : "selfhost.de",
	511	"name" : "Selfhost.de",
	512	"website" : "http://www.selfhost.de/",
	513	"protocols" : ["ipv4",],
	514	}
	515
2de06f59	516	url = "https://carol.selfhost.de/update"
f22ab085	517
5f402f36	518	def update(self):
2de06f59 MT	519	data = {
	520	"username" : self.username,
	521	"password" : self.password,
	522	"textmodi" : "1",
	523	}
f22ab085	524
2de06f59	525	response = self.send_request(self.url, data=data)
f22ab085 MT	526
	527	match = re.search("status=20(0\|4)", response.read())
	528	if not match:
	529	raise DDNSUpdateError
b09b1545 SS	530
	531
	532	class DDNSProviderSPDNS(DDNSProviderDynDNS):
	533	INFO = {
	534	"handle" : "spdns.org",
	535	"name" : "SPDNS",
	536	"website" : "http://spdns.org/",
	537	"protocols" : ["ipv4",]
	538	}
	539
	540	# Detailed information about request and response codes are provided
	541	# by the vendor. They are using almost the same mechanism and status
	542	# codes as dyndns.org so we can inherit all those stuff.
	543	#
	544	# http://wiki.securepoint.de/index.php/SPDNS_FAQ
	545	# http://wiki.securepoint.de/index.php/SPDNS_Update-Tokens
	546
	547	url = "https://update.spdns.de/nic/update"