]>
git.ipfire.org Git - people/ms/ddns.git/blob - src/ddns/providers.py
2 ###############################################################################
4 # ddns - A dynamic DNS client for IPFire #
5 # Copyright (C) 2012 IPFire development team #
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. #
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. #
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/>. #
20 ###############################################################################
24 import xml
.dom
.minidom
28 # Import all possible exception types.
31 logger
= logging
.getLogger("ddns.providers")
34 class DDNSProvider(object):
35 # A short string that uniquely identifies
39 # The full name of the provider.
42 # A weburl to the homepage of the provider.
43 # (Where to register a new account?)
46 # A list of supported protocols.
47 protocols
= ("ipv6", "ipv4")
51 def __init__(self
, core
, **settings
):
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
)
60 return "<DDNS Provider %s (%s)>" % (self
.name
, self
.handle
)
62 def __cmp__(self
, other
):
63 return cmp(self
.hostname
, other
.hostname
)
65 def get(self
, key
, default
=None):
67 Get a setting from the settings dictionary.
69 return self
.settings
.get(key
, default
)
74 Fast access to the hostname.
76 return self
.get("hostname")
81 Fast access to the username.
83 return self
.get("username")
88 Fast access to the password.
90 return self
.get("password")
95 Fast access to the token.
97 return self
.get("token")
99 def __call__(self
, force
=False):
101 logger
.debug(_("Updating %s forced") % self
.hostname
)
103 # Check if we actually need to update this host.
104 elif self
.is_uptodate(self
.protocols
):
105 logger
.debug(_("%s is already up to date") % self
.hostname
)
108 # Execute the update.
112 raise NotImplementedError
114 def is_uptodate(self
, protos
):
116 Returns True if this host is already up to date
117 and does not need to change the IP address on the
121 addresses
= self
.core
.system
.resolve(self
.hostname
, proto
)
123 current_address
= self
.get_address(proto
)
125 # If no addresses for the given protocol exist, we
127 if current_address
is None and not addresses
:
130 if not current_address
in addresses
:
135 def send_request(self
, *args
, **kwargs
):
137 Proxy connection to the send request
140 return self
.core
.system
.send_request(*args
, **kwargs
)
142 def get_address(self
, proto
, default
=None):
144 Proxy method to get the current IP address.
146 return self
.core
.system
.get_address(proto
) or default
149 class DDNSProviderAllInkl(DDNSProvider
):
150 handle
= "all-inkl.com"
151 name
= "All-inkl.com"
152 website
= "http://all-inkl.com/"
153 protocols
= ("ipv4",)
155 # There are only information provided by the vendor how to
156 # perform an update on a FRITZ Box. Grab requried informations
158 # http://all-inkl.goetze.it/v01/ddns-mit-einfachen-mitteln/
160 url
= "http://dyndns.kasserver.com"
163 # There is no additional data required so we directly can
165 response
= self
.send_request(self
.url
, username
=self
.username
, password
=self
.password
)
167 # Get the full response message.
168 output
= response
.read()
170 # Handle success messages.
171 if output
.startswith("good") or output
.startswith("nochg"):
174 # If we got here, some other update error happened.
175 raise DDNSUpdateError
178 class DDNSProviderDHS(DDNSProvider
):
180 name
= "DHS International"
181 website
= "http://dhs.org/"
182 protocols
= ("ipv4",)
184 # No information about the used update api provided on webpage,
185 # grabed from source code of ez-ipudate.
186 url
= "http://members.dhs.org/nic/hosts"
190 "domain" : self
.hostname
,
191 "ip" : self
.get_address("ipv4"),
193 "hostcmdstage" : "2",
197 # Send update to the server.
198 response
= self
.send_request(self
.url
, username
=self
.username
, password
=self
.password
,
201 # Handle success messages.
202 if response
.code
== 200:
205 # If we got here, some other update error happened.
206 raise DDNSUpdateError
209 class DDNSProviderDNSpark(DDNSProvider
):
210 handle
= "dnspark.com"
212 website
= "http://dnspark.com/"
213 protocols
= ("ipv4",)
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"
221 "domain" : self
.hostname
,
222 "ip" : self
.get_address("ipv4"),
225 # Send update to the server.
226 response
= self
.send_request(self
.url
, username
=self
.username
, password
=self
.password
,
229 # Get the full response message.
230 output
= response
.read()
232 # Handle success messages.
233 if output
.startswith("ok") or output
.startswith("nochange"):
236 # Handle error codes.
237 if output
== "unauth":
238 raise DDNSAuthenticationError
239 elif output
== "abuse":
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."))
252 # If we got here, some other update error happened.
253 raise DDNSUpdateError
256 class DDNSProviderDtDNS(DDNSProvider
):
259 website
= "http://dtdns.com/"
260 protocols
= ("ipv4",)
262 # Information about the format of the HTTPS request is to be found
263 # http://www.dtdns.com/dtsite/updatespec
264 url
= "https://www.dtdns.com/api/autodns.cfm"
268 "ip" : self
.get_address("ipv4"),
269 "id" : self
.hostname
,
273 # Send update to the server.
274 response
= self
.send_request(self
.url
, data
=data
)
276 # Get the full response message.
277 output
= response
.read()
279 # Remove all leading and trailing whitespace.
280 output
= output
.strip()
282 # Handle success messages.
283 if "now points to" in output
:
286 # Handle error codes.
287 if output
== "No hostname to update was supplied.":
288 raise DDNSRequestError(_("No hostname specified."))
290 elif output
== "The hostname you supplied is not valid.":
291 raise DDNSRequestError(_("Invalid hostname specified."))
293 elif output
== "The password you supplied is not valid.":
294 raise DDNSAuthenticationError
296 elif output
== "Administration has disabled this account.":
297 raise DDNSRequestError(_("Account has been disabled."))
299 elif output
== "Illegal character in IP.":
300 raise DDNSRequestError(_("Invalid IP address has been sent."))
302 elif output
== "Too many failed requests.":
303 raise DDNSRequestError(_("Too many failed requests."))
305 # If we got here, some other update error happened.
306 raise DDNSUpdateError
309 class DDNSProviderDynDNS(DDNSProvider
):
310 handle
= "dyndns.org"
312 website
= "http://dyn.com/dns/"
313 protocols
= ("ipv4",)
315 # Information about the format of the request is to be found
316 # http://http://dyn.com/support/developers/api/perform-update/
317 # http://dyn.com/support/developers/api/return-codes/
318 url
= "https://members.dyndns.org/nic/update"
320 def _prepare_request_data(self
):
322 "hostname" : self
.hostname
,
323 "myip" : self
.get_address("ipv4"),
329 data
= self
._prepare
_request
_data
()
331 # Send update to the server.
332 response
= self
.send_request(self
.url
, data
=data
,
333 username
=self
.username
, password
=self
.password
)
335 # Get the full response message.
336 output
= response
.read()
338 # Handle success messages.
339 if output
.startswith("good") or output
.startswith("nochg"):
342 # Handle error codes.
343 if output
== "badauth":
344 raise DDNSAuthenticationError
345 elif output
== "aduse":
347 elif output
== "notfqdn":
348 raise DDNSRequestError(_("No valid FQDN was given."))
349 elif output
== "nohost":
350 raise DDNSRequestError(_("Specified host does not exist."))
351 elif output
== "911":
352 raise DDNSInternalServerError
353 elif output
== "dnserr":
354 raise DDNSInternalServerError(_("DNS error encountered."))
356 # If we got here, some other update error happened.
357 raise DDNSUpdateError(_("Server response: %s") % output
)
360 class DDNSProviderDynU(DDNSProviderDynDNS
):
363 website
= "http://dynu.com/"
364 protocols
= ("ipv6", "ipv4",)
366 # Detailed information about the request and response codes
367 # are available on the providers webpage.
368 # http://dynu.com/Default.aspx?page=dnsapi
370 url
= "https://api.dynu.com/nic/update"
372 def _prepare_request_data(self
):
373 data
= DDNSProviderDynDNS
._prepare
_request
_data
(self
)
375 # This one supports IPv6
377 "myipv6" : self
.get_address("ipv6"),
383 class DDNSProviderEasyDNS(DDNSProviderDynDNS
):
384 handle
= "easydns.com"
386 website
= "http://www.easydns.com/"
388 # There is only some basic documentation provided by the vendor,
389 # also searching the web gain very poor results.
390 # http://mediawiki.easydns.com/index.php/Dynamic_DNS
392 url
= "http://api.cp.easydns.com/dyn/tomato.php"
395 class DDNSProviderFreeDNSAfraidOrg(DDNSProvider
):
396 handle
= "freedns.afraid.org"
397 name
= "freedns.afraid.org"
398 website
= "http://freedns.afraid.org/"
400 # No information about the request or response could be found on the vendor
401 # page. All used values have been collected by testing.
402 url
= "https://freedns.afraid.org/dynamic/update.php"
406 return self
.get("proto")
409 address
= self
.get_address(self
.proto
)
415 # Add auth token to the update url.
416 url
= "%s?%s" % (self
.url
, self
.token
)
418 # Send update to the server.
419 response
= self
.send_request(url
, data
=data
)
421 if output
.startswith("Updated") or "has not changed" in output
:
424 # Handle error codes.
425 if output
== "ERROR: Unable to locate this record":
426 raise DDNSAuthenticationError
427 elif "is an invalid IP address" in output
:
428 raise DDNSRequestError(_("Invalid IP address has been sent."))
430 # If we got here, some other update error happened.
431 raise DDNSUpdateError
434 class DDNSProviderLightningWireLabs(DDNSProvider
):
435 handle
= "dns.lightningwirelabs.com"
436 name
= "Lightning Wire Labs DNS Service"
437 website
= "http://dns.lightningwirelabs.com/"
439 # Information about the format of the HTTPS request is to be found
440 # https://dns.lightningwirelabs.com/knowledge-base/api/ddns
441 url
= "https://dns.lightningwirelabs.com/update"
445 "hostname" : self
.hostname
,
446 "address6" : self
.get_address("ipv6", "-"),
447 "address4" : self
.get_address("ipv4", "-"),
450 # Check if a token has been set.
452 data
["token"] = self
.token
454 # Check for username and password.
455 elif self
.username
and self
.password
:
457 "username" : self
.username
,
458 "password" : self
.password
,
461 # Raise an error if no auth details are given.
463 raise DDNSConfigurationError
465 # Send update to the server.
466 response
= self
.send_request(self
.url
, data
=data
)
468 # Handle success messages.
469 if response
.code
== 200:
472 # If we got here, some other update error happened.
473 raise DDNSUpdateError
476 class DDNSProviderNamecheap(DDNSProvider
):
477 handle
= "namecheap.com"
479 website
= "http://namecheap.com"
480 protocols
= ("ipv4",)
482 # Information about the format of the HTTP request is to be found
483 # https://www.namecheap.com/support/knowledgebase/article.aspx/9249/0/nc-dynamic-dns-to-dyndns-adapter
484 # https://community.namecheap.com/forums/viewtopic.php?f=6&t=6772
486 url
= "https://dynamicdns.park-your-domain.com/update"
488 def parse_xml(self
, document
, content
):
489 # Send input to the parser.
490 xmldoc
= xml
.dom
.minidom
.parseString(document
)
492 # Get XML elements by the given content.
493 element
= xmldoc
.getElementsByTagName(content
)
495 # If no element has been found, we directly can return None.
499 # Only get the first child from an element, even there are more than one.
500 firstchild
= element
[0].firstChild
502 # Get the value of the child.
503 value
= firstchild
.nodeValue
509 # Namecheap requires the hostname splitted into a host and domain part.
510 host
, domain
= self
.hostname
.split(".", 1)
513 "ip" : self
.get_address("ipv4"),
514 "password" : self
.password
,
519 # Send update to the server.
520 response
= self
.send_request(self
.url
, data
=data
)
522 # Get the full response message.
523 output
= response
.read()
525 # Handle success messages.
526 if self
.parse_xml(output
, "IP") == self
.get_address("ipv4"):
529 # Handle error codes.
530 errorcode
= self
.parse_xml(output
, "ResponseNumber")
532 if errorcode
== "304156":
533 raise DDNSAuthenticationError
534 elif errorcode
== "316153":
535 raise DDNSRequestError(_("Domain not found."))
536 elif errorcode
== "316154":
537 raise DDNSRequestError(_("Domain not active."))
538 elif errorcode
in ("380098", "380099"):
539 raise DDNSInternalServerError
541 # If we got here, some other update error happened.
542 raise DDNSUpdateError
545 class DDNSProviderNOIP(DDNSProviderDynDNS
):
548 website
= "http://www.no-ip.com/"
550 # Information about the format of the HTTP request is to be found
551 # here: http://www.no-ip.com/integrate/request and
552 # here: http://www.no-ip.com/integrate/response
554 url
= "http://dynupdate.no-ip.com/nic/update"
556 def _prepare_request_data(self
):
558 "hostname" : self
.hostname
,
559 "address" : self
.get_address("ipv4"),
565 class DDNSProviderOVH(DDNSProviderDynDNS
):
568 website
= "http://www.ovh.com/"
570 # OVH only provides very limited information about how to
571 # update a DynDNS host. They only provide the update url
572 # on the their german subpage.
574 # http://hilfe.ovh.de/DomainDynHost
576 url
= "https://www.ovh.com/nic/update"
578 def _prepare_request_data(self
):
579 data
= DDNSProviderDynDNS
._prepare
_request
_data
(self
)
587 class DDNSProviderRegfish(DDNSProvider
):
588 handle
= "regfish.com"
589 name
= "Regfish GmbH"
590 website
= "http://www.regfish.com/"
592 # A full documentation to the providers api can be found here
593 # but is only available in german.
594 # https://www.regfish.de/domains/dyndns/dokumentation
596 url
= "https://dyndns.regfish.de/"
600 "fqdn" : self
.hostname
,
603 # Check if we update an IPv6 address.
604 address6
= self
.get_address("ipv6")
606 data
["ipv6"] = address6
608 # Check if we update an IPv4 address.
609 address4
= self
.get_address("ipv4")
611 data
["ipv4"] = address4
613 # Raise an error if none address is given.
614 if not data
.has_key("ipv6") and not data
.has_key("ipv4"):
615 raise DDNSConfigurationError
617 # Check if a token has been set.
619 data
["token"] = self
.token
621 # Raise an error if no token and no useranem and password
623 elif not self
.username
and not self
.password
:
624 raise DDNSConfigurationError(_("No Auth details specified."))
626 # HTTP Basic Auth is only allowed if no token is used.
628 # Send update to the server.
629 response
= self
.send_request(self
.url
, data
=data
)
631 # Send update to the server.
632 response
= self
.send_request(self
.url
, username
=self
.username
, password
=self
.password
,
635 # Get the full response message.
636 output
= response
.read()
638 # Handle success messages.
639 if "100" in output
or "101" in output
:
642 # Handle error codes.
643 if "401" or "402" in output
:
644 raise DDNSAuthenticationError
645 elif "408" in output
:
646 raise DDNSRequestError(_("Invalid IPv4 address has been sent."))
647 elif "409" in output
:
648 raise DDNSRequestError(_("Invalid IPv6 address has been sent."))
649 elif "412" in output
:
650 raise DDNSRequestError(_("No valid FQDN was given."))
651 elif "414" in output
:
652 raise DDNSInternalServerError
654 # If we got here, some other update error happened.
655 raise DDNSUpdateError
658 class DDNSProviderSelfhost(DDNSProviderDynDNS
):
659 handle
= "selfhost.de"
661 website
= "http://www.selfhost.de/"
663 url
= "https://carol.selfhost.de/nic/update"
665 def _prepare_request_data(self
):
666 data
= DDNSProviderDynDNS
._prepare
_request
_data
(self
)
674 class DDNSProviderSPDNS(DDNSProviderDynDNS
):
677 website
= "http://spdns.org/"
679 # Detailed information about request and response codes are provided
680 # by the vendor. They are using almost the same mechanism and status
681 # codes as dyndns.org so we can inherit all those stuff.
683 # http://wiki.securepoint.de/index.php/SPDNS_FAQ
684 # http://wiki.securepoint.de/index.php/SPDNS_Update-Tokens
686 url
= "https://update.spdns.de/nic/update"
689 class DDNSProviderStrato(DDNSProviderDynDNS
):
690 handle
= "strato.com"
692 website
= "http:/www.strato.com/"
694 # Information about the request and response can be obtained here:
695 # http://www.strato-faq.de/article/671/So-einfach-richten-Sie-DynDNS-f%C3%BCr-Ihre-Domains-ein.html
697 url
= "https://dyndns.strato.com/nic/update"
700 class DDNSProviderTwoDNS(DDNSProviderDynDNS
):
703 website
= "http://www.twodns.de"
705 # Detailed information about the request can be found here
706 # http://twodns.de/en/faqs
707 # http://twodns.de/en/api
709 url
= "https://update.twodns.de/update"
711 def _prepare_request_data(self
):
713 "ip" : self
.get_address("ipv4"),
714 "hostname" : self
.hostname
720 class DDNSProviderUdmedia(DDNSProviderDynDNS
):
721 handle
= "udmedia.de"
722 name
= "Udmedia GmbH"
723 website
= "http://www.udmedia.de"
725 # Information about the request can be found here
726 # http://www.udmedia.de/faq/content/47/288/de/wie-lege-ich-einen-dyndns_eintrag-an.html
728 url
= "https://www.udmedia.de/nic/update"
731 class DDNSProviderVariomedia(DDNSProviderDynDNS
):
732 handle
= "variomedia.de"
734 website
= "http://www.variomedia.de/"
735 protocols
= ("ipv6", "ipv4",)
737 # Detailed information about the request can be found here
738 # https://dyndns.variomedia.de/
740 url
= "https://dyndns.variomedia.de/nic/update"
744 return self
.get("proto")
746 def _prepare_request_data(self
):
748 "hostname" : self
.hostname
,
749 "myip" : self
.get_address(self
.proto
)
755 class DDNSProviderZoneedit(DDNSProvider
):
756 handle
= "zoneedit.com"
758 website
= "http://www.zoneedit.com"
760 # Detailed information about the request and the response codes can be
762 # http://www.zoneedit.com/doc/api/other.html
763 # http://www.zoneedit.com/faq.html
765 url
= "https://dynamic.zoneedit.com/auth/dynamic.html"
769 return self
.get("proto")
773 "dnsto" : self
.get_address(self
.proto
),
774 "host" : self
.hostname
777 # Send update to the server.
778 response
= self
.send_request(self
.url
, username
=self
.username
, password
=self
.password
,
781 # Get the full response message.
782 output
= response
.read()
784 # Handle success messages.
785 if output
.startswith("<SUCCESS"):
788 # Handle error codes.
789 if output
.startswith("invalid login"):
790 raise DDNSAuthenticationError
791 elif output
.startswith("<ERROR CODE=\"704\""):
792 raise DDNSRequestError(_("No valid FQDN was given."))
793 elif output
.startswith("<ERROR CODE=\"702\""):
794 raise DDNSInternalServerError
796 # If we got here, some other update error happened.
797 raise DDNSUpdateError