[oddments/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 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
aa21a4c6 SS	364	class DDNSProviderFreeDNSAfraidOrg(DDNSProvider):
	365	INFO = {
	366	"handle" : "freedns.afraid.org",
	367	"name" : "freedns.afraid.org",
	368	"website" : "http://freedns.afraid.org/",
	369	"protocols" : ["ipv6", "ipv4",]
	370	}
	371
	372	# No information about the request or response could be found on the vendor
	373	# page. All used values have been collected by testing.
	374	url = "https://freedns.afraid.org/dynamic/update.php"
	375
	376	@property
	377	def proto(self):
	378	return self.get("proto")
	379
	380	def update(self):
	381	address = self.get_address(self.proto)
	382
	383	data = {
	384	"address" : address,
	385	}
	386
	387	# Add auth token to the update url.
	388	url = "%s?%s" % (self.url, self.token)
	389
	390	# Send update to the server.
	391	response = self.send_request(url, data=data)
	392
aa21a4c6 SS	393	if output.startswith("Updated") or "has not changed" in output:
	394	return
	395
	396	# Handle error codes.
	397	if output == "ERROR: Unable to locate this record":
	398	raise DDNSAuthenticationError
	399	elif "is an invalid IP address" in output:
	400	raise DDNSRequestError(_("Invalid IP address has been sent."))
	401
aa21a4c6	402
a08c1b72 SS	403	class DDNSProviderLightningWireLabs(DDNSProvider):
	404	INFO = {
	405	"handle" : "dns.lightningwirelabs.com",
	406	"name" : "Lightning Wire Labs",
	407	"website" : "http://dns.lightningwirelabs.com/",
	408	"protocols" : ["ipv6", "ipv4",]
	409	}
	410
	411	# Information about the format of the HTTPS request is to be found
	412	# https://dns.lightningwirelabs.com/knowledge-base/api/ddns
	413	url = "https://dns.lightningwirelabs.com/update"
	414
5f402f36	415	def update(self):
a08c1b72 SS	416	data = {
	417	"hostname" : self.hostname,
	418	}
	419
	420	# Check if we update an IPv6 address.
	421	address6 = self.get_address("ipv6")
	422	if address6:
	423	data["address6"] = address6
	424
	425	# Check if we update an IPv4 address.
	426	address4 = self.get_address("ipv4")
	427	if address4:
	428	data["address4"] = address4
	429
	430	# Raise an error if none address is given.
	431	if not data.has_key("address6") and not data.has_key("address4"):
	432	raise DDNSConfigurationError
	433
	434	# Check if a token has been set.
	435	if self.token:
	436	data["token"] = self.token
	437
	438	# Check for username and password.
	439	elif self.username and self.password:
	440	data.update({
	441	"username" : self.username,
	442	"password" : self.password,
	443	})
	444
	445	# Raise an error if no auth details are given.
	446	else:
	447	raise DDNSConfigurationError
	448
	449	# Send update to the server.
cb455540	450	response = self.send_request(self.url, data=data)
a08c1b72 SS	451
	452	# Handle success messages.
	453	if response.code == 200:
	454	return
	455
	456	# Handle error codes.
2e5ad318	457	if response.code == 403:
a08c1b72	458	raise DDNSAuthenticationError
2e5ad318	459	elif response.code == 400:
a08c1b72 SS	460	raise DDNSRequestError
	461
	462	# If we got here, some other update error happened.
	463	raise DDNSUpdateError
	464
	465
88f39629	466	class DDNSProviderNOIP(DDNSProviderDynDNS):
f22ab085 MT	467	INFO = {
	468	"handle" : "no-ip.com",
	469	"name" : "No-IP",
	470	"website" : "http://www.no-ip.com/",
	471	"protocols" : ["ipv4",]
	472	}
	473
	474	# Information about the format of the HTTP request is to be found
	475	# here: http://www.no-ip.com/integrate/request and
	476	# here: http://www.no-ip.com/integrate/response
	477
88f39629	478	url = "http://dynupdate.no-ip.com/nic/update"
2de06f59	479
88f39629	480	def _prepare_request_data(self):
2de06f59 MT	481	data = {
2de06f59 MT	482	"hostname" : self.hostname,
f22ab085 MT	483	"address" : self.get_address("ipv4"),
	484	}
	485
88f39629	486	return data
f22ab085 MT	487
f22ab085 MT	488
a508bda6 SS	489	class DDNSProviderOVH(DDNSProviderDynDNS):
	490	INFO = {
	491	"handle" : "ovh.com",
	492	"name" : "OVH",
	493	"website" : "http://www.ovh.com/",
	494	"protocols" : ["ipv4",]
	495	}
	496
	497	# OVH only provides very limited information about how to
	498	# update a DynDNS host. They only provide the update url
	499	# on the their german subpage.
	500	#
	501	# http://hilfe.ovh.de/DomainDynHost
	502
	503	url = "https://www.ovh.com/nic/update"
	504
	505	def _prepare_request_data(self):
	506	data = {
	507	"hostname" : self.hostname,
	508	"myip" : self.get_address("ipv4"),
	509	"system" : "dyndns",
	510	}
	511
	512
f22ab085 MT	513	class DDNSProviderSelfhost(DDNSProvider):
	514	INFO = {
	515	"handle" : "selfhost.de",
	516	"name" : "Selfhost.de",
	517	"website" : "http://www.selfhost.de/",
	518	"protocols" : ["ipv4",],
	519	}
	520
2de06f59	521	url = "https://carol.selfhost.de/update"
f22ab085	522
5f402f36	523	def update(self):
2de06f59 MT	524	data = {
	525	"username" : self.username,
	526	"password" : self.password,
	527	"textmodi" : "1",
	528	}
f22ab085	529
2de06f59	530	response = self.send_request(self.url, data=data)
f22ab085 MT	531
	532	match = re.search("status=20(0\|4)", response.read())
	533	if not match:
	534	raise DDNSUpdateError
b09b1545 SS	535
	536
	537	class DDNSProviderSPDNS(DDNSProviderDynDNS):
	538	INFO = {
	539	"handle" : "spdns.org",
	540	"name" : "SPDNS",
	541	"website" : "http://spdns.org/",
	542	"protocols" : ["ipv4",]
	543	}
	544
	545	# Detailed information about request and response codes are provided
	546	# by the vendor. They are using almost the same mechanism and status
	547	# codes as dyndns.org so we can inherit all those stuff.
	548	#
	549	# http://wiki.securepoint.de/index.php/SPDNS_FAQ
	550	# http://wiki.securepoint.de/index.php/SPDNS_Update-Tokens
	551
	552	url = "https://update.spdns.de/nic/update"
4ec90b93 MT	553
4ec90b93 MT	554
c8c7ca8f SS	555	class DDNSProviderVariomedia(DDNSProviderDynDNS):
	556	INFO = {
	557	"handle" : "variomedia.de",
	558	"name" : "Variomedia",
	559	"website" : "http://www.variomedia.de/",
	560	"protocols" : ["ipv6", "ipv4",]
	561	}
	562
	563	# Detailed information about the request can be found here
	564	# https://dyndns.variomedia.de/
	565
	566	url = "https://dyndns.variomedia.de/nic/update"
	567
	568	@property
	569	def proto(self):
	570	return self.get("proto")
	571
	572	def _prepare_request_data(self):
	573	data = {
	574	"hostname" : self.hostname,
	575	"myip" : self.get_address(self.proto)
	576	}