]>
git.ipfire.org Git - oddments/ddns.git/blob - src/ddns/providers.py
47891074e035315d259790e2c99fdb3a5ad7f573
2 ###############################################################################
4 # ddns - A dynamic DNS client for IPFire #
5 # Copyright (C) 2012-2017 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 ###############################################################################
27 import xml
.dom
.minidom
31 # Import all possible exception types.
34 logger
= logging
.getLogger("ddns.providers")
41 Returns a dict with all automatically registered providers.
43 return _providers
.copy()
45 class DDNSProvider(object):
46 # A short string that uniquely identifies
50 # The full name of the provider.
53 # A weburl to the homepage of the provider.
54 # (Where to register a new account?)
57 # A list of supported protocols.
58 protocols
= ("ipv6", "ipv4")
62 # holdoff time - Number of days no update is performed unless
63 # the IP address has changed.
66 # holdoff time for update failures - Number of days no update
67 # is tried after the last one has failed.
68 holdoff_failure_days
= 0.5
70 # True if the provider is able to remove records, too.
71 # Required to remove AAAA records if IPv6 is absent again.
72 can_remove_records
= True
74 # Automatically register all providers.
75 class __metaclass__(type):
76 def __init__(provider
, name
, bases
, dict):
77 type.__init
__(provider
, name
, bases
, dict)
79 # The main class from which is inherited is not registered
81 if name
== "DDNSProvider":
84 if not all((provider
.handle
, provider
.name
, provider
.website
)):
85 raise DDNSError(_("Provider is not properly configured"))
87 assert not _providers
.has_key(provider
.handle
), \
88 "Provider '%s' has already been registered" % provider
.handle
90 _providers
[provider
.handle
] = provider
95 Should be overwritten to check if the system the code is running
96 on has all the required tools to support this provider.
100 def __init__(self
, core
, **settings
):
103 # Copy a set of default settings and
104 # update them by those from the configuration file.
105 self
.settings
= self
.DEFAULT_SETTINGS
.copy()
106 self
.settings
.update(settings
)
109 return "<DDNS Provider %s (%s)>" % (self
.name
, self
.handle
)
111 def __cmp__(self
, other
):
112 return cmp(self
.hostname
, other
.hostname
)
118 def get(self
, key
, default
=None):
120 Get a setting from the settings dictionary.
122 return self
.settings
.get(key
, default
)
127 Fast access to the hostname.
129 return self
.get("hostname")
134 Fast access to the username.
136 return self
.get("username")
141 Fast access to the password.
143 return self
.get("password")
148 Fast access to the token.
150 return self
.get("token")
152 def __call__(self
, force
=False):
154 logger
.debug(_("Updating %s forced") % self
.hostname
)
156 # Do nothing if the last update has failed or no update is required
157 elif self
.has_failure
or not self
.requires_update
:
160 # Execute the update.
164 # 1) Catch network errors early, because we do not want to log
165 # them to the database. They are usually temporary and caused
166 # by the client side, so that we will retry quickly.
167 # 2) If there is an internet server error (HTTP code 500) on the
168 # provider's site, we will not log a failure and try again
170 except (DDNSNetworkError
, DDNSInternalServerError
):
173 # In case of any errors, log the failed request and
174 # raise the exception.
175 except DDNSError
as e
:
176 self
.core
.db
.log_failure(self
.hostname
, e
)
179 logger
.info(_("Dynamic DNS update for %(hostname)s (%(provider)s) successful") % \
180 { "hostname" : self
.hostname
, "provider" : self
.name
})
181 self
.core
.db
.log_success(self
.hostname
)
184 for protocol
in self
.protocols
:
185 if self
.have_address(protocol
):
186 self
.update_protocol(protocol
)
187 elif self
.can_remove_records
:
188 self
.remove_protocol(protocol
)
190 def update_protocol(self
, proto
):
191 raise NotImplementedError
193 def remove_protocol(self
, proto
):
194 if not self
.can_remove_records
:
195 raise RuntimeError, "can_remove_records is enabled, but remove_protocol() not implemented"
197 raise NotImplementedError
200 def requires_update(self
):
201 # If the IP addresses have changed, an update is required
202 if self
.ip_address_changed(self
.protocols
):
203 logger
.debug(_("An update for %(hostname)s (%(provider)s)"
204 " is performed because of an IP address change") % \
205 { "hostname" : self
.hostname
, "provider" : self
.name
})
209 # If the holdoff time has expired, an update is required, too
210 if self
.holdoff_time_expired():
211 logger
.debug(_("An update for %(hostname)s (%(provider)s)"
212 " is performed because the holdoff time has expired") % \
213 { "hostname" : self
.hostname
, "provider" : self
.name
})
217 # Otherwise, we don't need to perform an update
218 logger
.debug(_("No update required for %(hostname)s (%(provider)s)") % \
219 { "hostname" : self
.hostname
, "provider" : self
.name
})
224 def has_failure(self
):
226 Returns True when the last update has failed and no retry
227 should be performed, yet.
229 last_status
= self
.db
.last_update_status(self
.hostname
)
231 # Return False if the last update has not failed.
232 if not last_status
== "failure":
235 # If there is no holdoff time, we won't update ever again.
236 if self
.holdoff_failure_days
is None:
237 logger
.warning(_("An update has not been performed because earlier updates failed for %s") \
239 logger
.warning(_("There will be no retries"))
243 # Determine when the holdoff time ends
244 last_update
= self
.db
.last_update(self
.hostname
, status
=last_status
)
245 holdoff_end
= last_update
+ datetime
.timedelta(days
=self
.holdoff_failure_days
)
247 now
= datetime
.datetime
.utcnow()
248 if now
< holdoff_end
:
249 failure_message
= self
.db
.last_update_failure_message(self
.hostname
)
251 logger
.warning(_("An update has not been performed because earlier updates failed for %s") \
255 logger
.warning(_("Last failure message:"))
257 for line
in failure_message
.splitlines():
258 logger
.warning(" %s" % line
)
260 logger
.warning(_("Further updates will be withheld until %s") % holdoff_end
)
266 def ip_address_changed(self
, protos
):
268 Returns True if this host is already up to date
269 and does not need to change the IP address on the
273 addresses
= self
.core
.system
.resolve(self
.hostname
, proto
)
274 current_address
= self
.get_address(proto
)
276 # Handle if the system has not got any IP address from a protocol
277 # (i.e. had full dual-stack connectivity which it has not any more)
278 if current_address
is None:
279 # If addresses still exists in the DNS system and if this provider
280 # is able to remove records, we will do that.
281 if addresses
and self
.can_remove_records
:
284 # Otherwise, we cannot go on...
287 if not current_address
in addresses
:
292 def holdoff_time_expired(self
):
294 Returns true if the holdoff time has expired
295 and the host requires an update
297 # If no holdoff days is defined, we cannot go on
298 if not self
.holdoff_days
:
301 # Get the timestamp of the last successfull update
302 last_update
= self
.db
.last_update(self
.hostname
, status
="success")
304 # If no timestamp has been recorded, no update has been
305 # performed. An update should be performed now.
309 # Determine when the holdoff time ends
310 holdoff_end
= last_update
+ datetime
.timedelta(days
=self
.holdoff_days
)
312 now
= datetime
.datetime
.utcnow()
314 if now
>= holdoff_end
:
315 logger
.debug("The holdoff time has expired for %s" % self
.hostname
)
318 logger
.debug("Updates for %s are held off until %s" % \
319 (self
.hostname
, holdoff_end
))
322 def send_request(self
, *args
, **kwargs
):
324 Proxy connection to the send request
327 return self
.core
.system
.send_request(*args
, **kwargs
)
329 def get_address(self
, proto
, default
=None):
331 Proxy method to get the current IP address.
333 return self
.core
.system
.get_address(proto
) or default
335 def have_address(self
, proto
):
337 Returns True if an IP address for the given protocol
340 address
= self
.get_address(proto
)
348 class DDNSProtocolDynDNS2(object):
350 This is an abstract class that implements the DynDNS updater
351 protocol version 2. As this is a popular way to update dynamic
352 DNS records, this class is supposed make the provider classes
356 # Information about the format of the request is to be found
357 # http://dyn.com/support/developers/api/perform-update/
358 # http://dyn.com/support/developers/api/return-codes/
360 # The DynDNS protocol version 2 does not allow to remove records
361 can_remove_records
= False
363 def prepare_request_data(self
, proto
):
365 "hostname" : self
.hostname
,
366 "myip" : self
.get_address(proto
),
371 def update_protocol(self
, proto
):
372 data
= self
.prepare_request_data(proto
)
374 return self
.send_request(data
)
376 def send_request(self
, data
):
377 # Send update to the server.
378 response
= DDNSProvider
.send_request(self
, self
.url
, data
=data
,
379 username
=self
.username
, password
=self
.password
)
381 # Get the full response message.
382 output
= response
.read()
384 # Handle success messages.
385 if output
.startswith("good") or output
.startswith("nochg"):
388 # Handle error codes.
389 if output
== "badauth":
390 raise DDNSAuthenticationError
391 elif output
== "abuse":
393 elif output
== "notfqdn":
394 raise DDNSRequestError(_("No valid FQDN was given"))
395 elif output
== "nohost":
396 raise DDNSRequestError(_("Specified host does not exist"))
397 elif output
== "911":
398 raise DDNSInternalServerError
399 elif output
== "dnserr":
400 raise DDNSInternalServerError(_("DNS error encountered"))
401 elif output
== "badagent":
402 raise DDNSBlockedError
403 elif output
== "badip":
404 raise DDNSBlockedError
406 # If we got here, some other update error happened.
407 raise DDNSUpdateError(_("Server response: %s") % output
)
410 class DDNSResponseParserXML(object):
412 This class provides a parser for XML responses which
413 will be sent by various providers. This class uses the python
414 shipped XML minidom module to walk through the XML tree and return
418 def get_xml_tag_value(self
, document
, content
):
419 # Send input to the parser.
420 xmldoc
= xml
.dom
.minidom
.parseString(document
)
422 # Get XML elements by the given content.
423 element
= xmldoc
.getElementsByTagName(content
)
425 # If no element has been found, we directly can return None.
429 # Only get the first child from an element, even there are more than one.
430 firstchild
= element
[0].firstChild
432 # Get the value of the child.
433 value
= firstchild
.nodeValue
439 class DDNSProviderAllInkl(DDNSProvider
):
440 handle
= "all-inkl.com"
441 name
= "All-inkl.com"
442 website
= "http://all-inkl.com/"
443 protocols
= ("ipv4",)
445 # There are only information provided by the vendor how to
446 # perform an update on a FRITZ Box. Grab requried informations
448 # http://all-inkl.goetze.it/v01/ddns-mit-einfachen-mitteln/
450 url
= "http://dyndns.kasserver.com"
451 can_remove_records
= False
454 # There is no additional data required so we directly can
456 response
= self
.send_request(self
.url
, username
=self
.username
, password
=self
.password
)
458 # Get the full response message.
459 output
= response
.read()
461 # Handle success messages.
462 if output
.startswith("good") or output
.startswith("nochg"):
465 # If we got here, some other update error happened.
466 raise DDNSUpdateError
469 class DDNSProviderBindNsupdate(DDNSProvider
):
471 name
= "BIND nsupdate utility"
472 website
= "http://en.wikipedia.org/wiki/Nsupdate"
478 # Search if the nsupdate utility is available
479 paths
= os
.environ
.get("PATH")
481 for path
in paths
.split(":"):
482 executable
= os
.path
.join(path
, "nsupdate")
484 if os
.path
.exists(executable
):
490 scriptlet
= self
.__make
_scriptlet
()
492 # -v enables TCP hence we transfer keys and other data that may
493 # exceed the size of one packet.
494 # -t sets the timeout
495 command
= ["nsupdate", "-v", "-t", "60"]
497 p
= subprocess
.Popen(command
, shell
=True,
498 stdin
=subprocess
.PIPE
, stdout
=subprocess
.PIPE
, stderr
=subprocess
.PIPE
,
500 stdout
, stderr
= p
.communicate(scriptlet
)
502 if p
.returncode
== 0:
505 raise DDNSError("nsupdate terminated with error code: %s\n %s" % (p
.returncode
, stderr
))
507 def __make_scriptlet(self
):
510 # Set a different server the update is sent to.
511 server
= self
.get("server", None)
513 scriptlet
.append("server %s" % server
)
515 # Set the DNS zone the host should be added to.
516 zone
= self
.get("zone", None)
518 scriptlet
.append("zone %s" % zone
)
520 key
= self
.get("key", None)
522 secret
= self
.get("secret")
524 scriptlet
.append("key %s %s" % (key
, secret
))
526 ttl
= self
.get("ttl", self
.DEFAULT_TTL
)
528 # Perform an update for each supported protocol.
529 for rrtype
, proto
in (("AAAA", "ipv6"), ("A", "ipv4")):
530 address
= self
.get_address(proto
)
534 scriptlet
.append("update delete %s. %s" % (self
.hostname
, rrtype
))
535 scriptlet
.append("update add %s. %s %s %s" % \
536 (self
.hostname
, ttl
, rrtype
, address
))
538 # Send the actions to the server.
539 scriptlet
.append("send")
540 scriptlet
.append("quit")
542 logger
.debug(_("Scriptlet:"))
543 for line
in scriptlet
:
544 # Masquerade the line with the secret key.
545 if line
.startswith("key"):
546 line
= "key **** ****"
548 logger
.debug(" %s" % line
)
550 return "\n".join(scriptlet
)
553 class DDNSProviderChangeIP(DDNSProvider
):
554 handle
= "changeip.com"
555 name
= "ChangeIP.com"
556 website
= "https://changeip.com"
557 protocols
= ("ipv4",)
559 # Detailed information about the update api can be found here.
560 # http://www.changeip.com/accounts/knowledgebase.php?action=displayarticle&id=34
562 url
= "https://nic.changeip.com/nic/update"
563 can_remove_records
= False
565 def update_protocol(self
, proto
):
567 "hostname" : self
.hostname
,
568 "myip" : self
.get_address(proto
),
571 # Send update to the server.
573 response
= self
.send_request(self
.url
, username
=self
.username
, password
=self
.password
,
576 # Handle error codes.
577 except urllib2
.HTTPError
, e
:
579 raise DDNSRequestError(_("Domain not found."))
583 # Handle success message.
584 if response
.code
== 200:
587 # If we got here, some other update error happened.
588 raise DDNSUpdateError(_("Server response: %s") % output
)
591 class DDNSProviderDesecIO(DDNSProtocolDynDNS2
, DDNSProvider
):
594 website
= "https://www.desec.io"
595 protocols
= ("ipv6", "ipv4",)
597 # ipv4 / ipv6 records are automatically removed when the update
598 # request originates from the respectively other protocol and no
599 # address is explicitly provided for the unused protocol.
601 url
= "https://update.dedyn.io"
603 # desec.io sends the IPv6 and IPv4 address in one request
606 data
= DDNSProtocolDynDNS2
.prepare_request_data(self
, "ipv4")
608 # This one supports IPv6
609 myipv6
= self
.get_address("ipv6")
611 # Add update information if we have an IPv6 address.
613 data
["myipv6"] = myipv6
615 self
.send_request(data
)
618 class DDNSProviderDDNSS(DDNSProvider
):
621 website
= "http://www.ddnss.de"
622 protocols
= ("ipv4",)
624 # Detailed information about how to send the update request and possible response
625 # codes can be obtained from here.
626 # http://www.ddnss.de/info.php
627 # http://www.megacomputing.de/2014/08/dyndns-service-response-time/#more-919
629 url
= "http://www.ddnss.de/upd.php"
630 can_remove_records
= False
632 def update_protocol(self
, proto
):
634 "ip" : self
.get_address(proto
),
635 "host" : self
.hostname
,
638 # Check if a token has been set.
640 data
["key"] = self
.token
642 # Check if username and hostname are given.
643 elif self
.username
and self
.password
:
645 "user" : self
.username
,
646 "pwd" : self
.password
,
649 # Raise an error if no auth details are given.
651 raise DDNSConfigurationError
653 # Send update to the server.
654 response
= self
.send_request(self
.url
, data
=data
)
656 # This provider sends the response code as part of the header.
657 header
= response
.info()
659 # Get status information from the header.
660 output
= header
.getheader('ddnss-response')
662 # Handle success messages.
663 if output
== "good" or output
== "nochg":
666 # Handle error codes.
667 if output
== "badauth":
668 raise DDNSAuthenticationError
669 elif output
== "notfqdn":
670 raise DDNSRequestError(_("No valid FQDN was given"))
671 elif output
== "nohost":
672 raise DDNSRequestError(_("Specified host does not exist"))
673 elif output
== "911":
674 raise DDNSInternalServerError
675 elif output
== "dnserr":
676 raise DDNSInternalServerError(_("DNS error encountered"))
677 elif output
== "disabled":
678 raise DDNSRequestError(_("Account disabled or locked"))
680 # If we got here, some other update error happened.
681 raise DDNSUpdateError
684 class DDNSProviderDHS(DDNSProvider
):
686 name
= "DHS International"
687 website
= "http://dhs.org/"
688 protocols
= ("ipv4",)
690 # No information about the used update api provided on webpage,
691 # grabed from source code of ez-ipudate.
693 url
= "http://members.dhs.org/nic/hosts"
694 can_remove_records
= False
696 def update_protocol(self
, proto
):
698 "domain" : self
.hostname
,
699 "ip" : self
.get_address(proto
),
701 "hostcmdstage" : "2",
705 # Send update to the server.
706 response
= self
.send_request(self
.url
, username
=self
.username
, password
=self
.password
,
709 # Handle success messages.
710 if response
.code
== 200:
713 # If we got here, some other update error happened.
714 raise DDNSUpdateError
717 class DDNSProviderDNSpark(DDNSProvider
):
718 handle
= "dnspark.com"
720 website
= "http://dnspark.com/"
721 protocols
= ("ipv4",)
723 # Informations to the used api can be found here:
724 # https://dnspark.zendesk.com/entries/31229348-Dynamic-DNS-API-Documentation
726 url
= "https://control.dnspark.com/api/dynamic/update.php"
727 can_remove_records
= False
729 def update_protocol(self
, proto
):
731 "domain" : self
.hostname
,
732 "ip" : self
.get_address(proto
),
735 # Send update to the server.
736 response
= self
.send_request(self
.url
, username
=self
.username
, password
=self
.password
,
739 # Get the full response message.
740 output
= response
.read()
742 # Handle success messages.
743 if output
.startswith("ok") or output
.startswith("nochange"):
746 # Handle error codes.
747 if output
== "unauth":
748 raise DDNSAuthenticationError
749 elif output
== "abuse":
751 elif output
== "blocked":
752 raise DDNSBlockedError
753 elif output
== "nofqdn":
754 raise DDNSRequestError(_("No valid FQDN was given"))
755 elif output
== "nohost":
756 raise DDNSRequestError(_("Invalid hostname specified"))
757 elif output
== "notdyn":
758 raise DDNSRequestError(_("Hostname not marked as a dynamic host"))
759 elif output
== "invalid":
760 raise DDNSRequestError(_("Invalid IP address has been sent"))
762 # If we got here, some other update error happened.
763 raise DDNSUpdateError
766 class DDNSProviderDtDNS(DDNSProvider
):
769 website
= "http://dtdns.com/"
770 protocols
= ("ipv4",)
772 # Information about the format of the HTTPS request is to be found
773 # http://www.dtdns.com/dtsite/updatespec
775 url
= "https://www.dtdns.com/api/autodns.cfm"
776 can_remove_records
= False
778 def update_protocol(self
, proto
):
780 "ip" : self
.get_address(proto
),
781 "id" : self
.hostname
,
785 # Send update to the server.
786 response
= self
.send_request(self
.url
, data
=data
)
788 # Get the full response message.
789 output
= response
.read()
791 # Remove all leading and trailing whitespace.
792 output
= output
.strip()
794 # Handle success messages.
795 if "now points to" in output
:
798 # Handle error codes.
799 if output
== "No hostname to update was supplied.":
800 raise DDNSRequestError(_("No hostname specified"))
802 elif output
== "The hostname you supplied is not valid.":
803 raise DDNSRequestError(_("Invalid hostname specified"))
805 elif output
== "The password you supplied is not valid.":
806 raise DDNSAuthenticationError
808 elif output
== "Administration has disabled this account.":
809 raise DDNSRequestError(_("Account has been disabled"))
811 elif output
== "Illegal character in IP.":
812 raise DDNSRequestError(_("Invalid IP address has been sent"))
814 elif output
== "Too many failed requests.":
815 raise DDNSRequestError(_("Too many failed requests"))
817 # If we got here, some other update error happened.
818 raise DDNSUpdateError
821 class DDNSProviderDuckDNS(DDNSProtocolDynDNS2
, DDNSProvider
):
822 handle
= "duckdns.org"
824 website
= "http://www.duckdns.org/"
825 protocols
= ("ipv4",)
827 # Information about the format of the request is to be found
828 # https://www.duckdns.org/install.jsp
830 url
= "https://www.duckdns.org/nic/update"
833 class DDNSProviderDyFi(DDNSProtocolDynDNS2
, DDNSProvider
):
836 website
= "https://www.dy.fi/"
837 protocols
= ("ipv4",)
839 # Information about the format of the request is to be found
840 # https://www.dy.fi/page/clients?lang=en
841 # https://www.dy.fi/page/specification?lang=en
843 url
= "http://www.dy.fi/nic/update"
845 # Please only send automatic updates when your IP address changes,
846 # or once per 5 to 6 days to refresh the address mapping (they will
847 # expire if not refreshed within 7 days).
851 class DDNSProviderDynDNS(DDNSProtocolDynDNS2
, DDNSProvider
):
852 handle
= "dyndns.org"
854 website
= "http://dyn.com/dns/"
855 protocols
= ("ipv4",)
857 # Information about the format of the request is to be found
858 # http://http://dyn.com/support/developers/api/perform-update/
859 # http://dyn.com/support/developers/api/return-codes/
861 url
= "https://members.dyndns.org/nic/update"
864 class DDNSProviderDomainOffensive(DDNSProtocolDynDNS2
, DDNSProvider
):
866 name
= "Domain-Offensive"
867 website
= "https://www.do.de/"
868 protocols
= ("ipv6", "ipv4")
870 # Detailed information about the request and response codes
871 # are available on the providers webpage.
872 # https://www.do.de/wiki/FlexDNS_-_Entwickler
874 url
= "https://ddns.do.de/"
876 class DDNSProviderDynUp(DDNSProvider
):
879 website
= "http://dynup.de/"
880 protocols
= ("ipv4",)
882 # Information about the format of the HTTPS request is to be found
883 # https://dyndnsfree.de/user/hilfe.php
885 url
= "https://dynup.de/dyn.php"
886 can_remove_records
= False
888 def update_protocol(self
, proto
):
890 "username" : self
.username
,
891 "password" : self
.password
,
892 "hostname" : self
.hostname
,
896 # Send update to the server.
897 response
= self
.send_request(self
.url
, data
=data
)
899 # Get the full response message.
900 output
= response
.read()
902 # Remove all leading and trailing whitespace.
903 output
= output
.strip()
905 # Handle success messages.
906 if output
.startswith("I:OK") :
909 # If we got here, some other update error happened.
910 raise DDNSUpdateError
914 class DDNSProviderDynU(DDNSProtocolDynDNS2
, DDNSProvider
):
917 website
= "http://dynu.com/"
918 protocols
= ("ipv6", "ipv4",)
920 # Detailed information about the request and response codes
921 # are available on the providers webpage.
922 # http://dynu.com/Default.aspx?page=dnsapi
924 url
= "https://api.dynu.com/nic/update"
926 # DynU sends the IPv6 and IPv4 address in one request
929 data
= DDNSProtocolDynDNS2
.prepare_request_data(self
, "ipv4")
931 # This one supports IPv6
932 myipv6
= self
.get_address("ipv6")
934 # Add update information if we have an IPv6 address.
936 data
["myipv6"] = myipv6
938 self
.send_request(data
)
941 class DDNSProviderEasyDNS(DDNSProvider
):
942 handle
= "easydns.com"
944 website
= "http://www.easydns.com/"
945 protocols
= ("ipv4",)
947 # Detailed information about the request and response codes
948 # (API 1.3) are available on the providers webpage.
949 # https://fusion.easydns.com/index.php?/Knowledgebase/Article/View/102/7/dynamic-dns
951 url
= "http://api.cp.easydns.com/dyn/tomato.php"
953 def update_protocol(self
, proto
):
955 "myip" : self
.get_address(proto
, "-"),
956 "hostname" : self
.hostname
,
959 # Send update to the server.
960 response
= self
.send_request(self
.url
, data
=data
,
961 username
=self
.username
, password
=self
.password
)
963 # Get the full response message.
964 output
= response
.read()
966 # Remove all leading and trailing whitespace.
967 output
= output
.strip()
969 # Handle success messages.
970 if output
.startswith("NOERROR"):
973 # Handle error codes.
974 if output
.startswith("NOACCESS"):
975 raise DDNSAuthenticationError
977 elif output
.startswith("NOSERVICE"):
978 raise DDNSRequestError(_("Dynamic DNS is not turned on for this domain"))
980 elif output
.startswith("ILLEGAL INPUT"):
981 raise DDNSRequestError(_("Invalid data has been sent"))
983 elif output
.startswith("TOOSOON"):
984 raise DDNSRequestError(_("Too frequent update requests have been sent"))
986 # If we got here, some other update error happened.
987 raise DDNSUpdateError
990 class DDNSProviderDomopoli(DDNSProtocolDynDNS2
, DDNSProvider
):
991 handle
= "domopoli.de"
993 website
= "http://domopoli.de/"
994 protocols
= ("ipv4",)
996 # https://www.domopoli.de/?page=howto#DynDns_start
998 url
= "http://dyndns.domopoli.de/nic/update"
1001 class DDNSProviderDynsNet(DDNSProvider
):
1004 website
= "http://www.dyns.net/"
1005 protocols
= ("ipv4",)
1006 can_remove_records
= False
1008 # There is very detailed informatio about how to send the update request and
1009 # the possible response codes. (Currently we are using the v1.1 proto)
1010 # http://www.dyns.net/documentation/technical/protocol/
1012 url
= "http://www.dyns.net/postscript011.php"
1014 def update_protocol(self
, proto
):
1016 "ip" : self
.get_address(proto
),
1017 "host" : self
.hostname
,
1018 "username" : self
.username
,
1019 "password" : self
.password
,
1022 # Send update to the server.
1023 response
= self
.send_request(self
.url
, data
=data
)
1025 # Get the full response message.
1026 output
= response
.read()
1028 # Handle success messages.
1029 if output
.startswith("200"):
1032 # Handle error codes.
1033 if output
.startswith("400"):
1034 raise DDNSRequestError(_("Malformed request has been sent"))
1035 elif output
.startswith("401"):
1036 raise DDNSAuthenticationError
1037 elif output
.startswith("402"):
1038 raise DDNSRequestError(_("Too frequent update requests have been sent"))
1039 elif output
.startswith("403"):
1040 raise DDNSInternalServerError
1042 # If we got here, some other update error happened.
1043 raise DDNSUpdateError(_("Server response: %s") % output
)
1046 class DDNSProviderEnomCom(DDNSResponseParserXML
, DDNSProvider
):
1049 website
= "http://www.enom.com/"
1050 protocols
= ("ipv4",)
1052 # There are very detailed information about how to send an update request and
1053 # the respone codes.
1054 # http://www.enom.com/APICommandCatalog/
1056 url
= "https://dynamic.name-services.com/interface.asp"
1057 can_remove_records
= False
1059 def update_protocol(self
, proto
):
1061 "command" : "setdnshost",
1062 "responsetype" : "xml",
1063 "address" : self
.get_address(proto
),
1064 "domainpassword" : self
.password
,
1065 "zone" : self
.hostname
1068 # Send update to the server.
1069 response
= self
.send_request(self
.url
, data
=data
)
1071 # Get the full response message.
1072 output
= response
.read()
1074 # Handle success messages.
1075 if self
.get_xml_tag_value(output
, "ErrCount") == "0":
1078 # Handle error codes.
1079 errorcode
= self
.get_xml_tag_value(output
, "ResponseNumber")
1081 if errorcode
== "304155":
1082 raise DDNSAuthenticationError
1083 elif errorcode
== "304153":
1084 raise DDNSRequestError(_("Domain not found"))
1086 # If we got here, some other update error happened.
1087 raise DDNSUpdateError
1090 class DDNSProviderEntryDNS(DDNSProvider
):
1091 handle
= "entrydns.net"
1093 website
= "http://entrydns.net/"
1094 protocols
= ("ipv4",)
1096 # Some very tiny details about their so called "Simple API" can be found
1097 # here: https://entrydns.net/help
1098 url
= "https://entrydns.net/records/modify"
1099 can_remove_records
= False
1101 def update_protocol(self
, proto
):
1103 "ip" : self
.get_address(proto
),
1106 # Add auth token to the update url.
1107 url
= "%s/%s" % (self
.url
, self
.token
)
1109 # Send update to the server.
1111 response
= self
.send_request(url
, data
=data
)
1113 # Handle error codes
1114 except urllib2
.HTTPError
, e
:
1116 raise DDNSAuthenticationError
1119 raise DDNSRequestError(_("An invalid IP address was submitted"))
1123 # Handle success messages.
1124 if response
.code
== 200:
1127 # If we got here, some other update error happened.
1128 raise DDNSUpdateError
1131 class DDNSProviderFreeDNSAfraidOrg(DDNSProvider
):
1132 handle
= "freedns.afraid.org"
1133 name
= "freedns.afraid.org"
1134 website
= "http://freedns.afraid.org/"
1136 # No information about the request or response could be found on the vendor
1137 # page. All used values have been collected by testing.
1138 url
= "https://freedns.afraid.org/dynamic/update.php"
1139 can_remove_records
= False
1141 def update_protocol(self
, proto
):
1143 "address" : self
.get_address(proto
),
1146 # Add auth token to the update url.
1147 url
= "%s?%s" % (self
.url
, self
.token
)
1149 # Send update to the server.
1150 response
= self
.send_request(url
, data
=data
)
1152 # Get the full response message.
1153 output
= response
.read()
1155 # Handle success messages.
1156 if output
.startswith("Updated") or "has not changed" in output
:
1159 # Handle error codes.
1160 if output
== "ERROR: Unable to locate this record":
1161 raise DDNSAuthenticationError
1162 elif "is an invalid IP address" in output
:
1163 raise DDNSRequestError(_("Invalid IP address has been sent"))
1165 # If we got here, some other update error happened.
1166 raise DDNSUpdateError
1169 class DDNSProviderItsdns(DDNSProtocolDynDNS2
, DDNSProvider
):
1172 website
= "https://www.inwx.com"
1173 protocols
= ("ipv6", "ipv4")
1175 # Information about the format of the HTTP request is to be found
1176 # here: https://www.inwx.com/en/nameserver2/dyndns (requires login)
1177 # Notice: The URL is the same for: inwx.com|de|at|ch|es
1179 url
= "https://dyndns.inwx.com/nic/update"
1182 class DDNSProviderItsdns(DDNSProtocolDynDNS2
, DDNSProvider
):
1183 handle
= "itsdns.de"
1185 website
= "http://www.itsdns.de/"
1186 protocols
= ("ipv6", "ipv4")
1188 # Information about the format of the HTTP request is to be found
1189 # here: https://www.itsdns.de/dynupdatehelp.htm
1191 url
= "https://www.itsdns.de/update.php"
1194 class DDNSProviderJoker(DDNSProtocolDynDNS2
, DDNSProvider
):
1195 handle
= "joker.com"
1196 name
= "Joker.com Dynamic DNS"
1197 website
= "https://joker.com/"
1198 protocols
= ("ipv4",)
1200 # Information about the request can be found here:
1201 # https://joker.com/faq/content/11/427/en/what-is-dynamic-dns-dyndns.html
1202 # Using DynDNS V2 protocol over HTTPS here
1204 url
= "https://svc.joker.com/nic/update"
1207 class DDNSProviderGoogle(DDNSProtocolDynDNS2
, DDNSProvider
):
1208 handle
= "domains.google.com"
1209 name
= "Google Domains"
1210 website
= "https://domains.google.com/"
1211 protocols
= ("ipv4",)
1213 # Information about the format of the HTTP request is to be found
1214 # here: https://support.google.com/domains/answer/6147083?hl=en
1216 url
= "https://domains.google.com/nic/update"
1219 class DDNSProviderLightningWireLabs(DDNSProvider
):
1220 handle
= "dns.lightningwirelabs.com"
1221 name
= "Lightning Wire Labs DNS Service"
1222 website
= "http://dns.lightningwirelabs.com/"
1224 # Information about the format of the HTTPS request is to be found
1225 # https://dns.lightningwirelabs.com/knowledge-base/api/ddns
1227 url
= "https://dns.lightningwirelabs.com/update"
1231 "hostname" : self
.hostname
,
1232 "address6" : self
.get_address("ipv6", "-"),
1233 "address4" : self
.get_address("ipv4", "-"),
1236 # Check if a token has been set.
1238 data
["token"] = self
.token
1240 # Check for username and password.
1241 elif self
.username
and self
.password
:
1243 "username" : self
.username
,
1244 "password" : self
.password
,
1247 # Raise an error if no auth details are given.
1249 raise DDNSConfigurationError
1251 # Send update to the server.
1252 response
= self
.send_request(self
.url
, data
=data
)
1254 # Handle success messages.
1255 if response
.code
== 200:
1258 # If we got here, some other update error happened.
1259 raise DDNSUpdateError
1262 class DDNSProviderLoopia(DDNSProtocolDynDNS2
, DDNSProvider
):
1263 handle
= "loopia.se"
1265 website
= "https://www.loopia.com"
1266 protocols
= ("ipv4",)
1268 # Information about the format of the HTTP request is to be found
1269 # here: https://support.loopia.com/wiki/About_the_DynDNS_support
1271 url
= "https://dns.loopia.se/XDynDNSServer/XDynDNS.php"
1274 class DDNSProviderMyOnlinePortal(DDNSProtocolDynDNS2
, DDNSProvider
):
1275 handle
= "myonlineportal.net"
1276 name
= "myonlineportal.net"
1277 website
= "https:/myonlineportal.net/"
1279 # Information about the request and response can be obtained here:
1280 # https://myonlineportal.net/howto_dyndns
1282 url
= "https://myonlineportal.net/updateddns"
1284 def prepare_request_data(self
, proto
):
1286 "hostname" : self
.hostname
,
1287 "ip" : self
.get_address(proto
),
1293 class DDNSProviderNamecheap(DDNSResponseParserXML
, DDNSProvider
):
1294 handle
= "namecheap.com"
1296 website
= "http://namecheap.com"
1297 protocols
= ("ipv4",)
1299 # Information about the format of the HTTP request is to be found
1300 # https://www.namecheap.com/support/knowledgebase/article.aspx/9249/0/nc-dynamic-dns-to-dyndns-adapter
1301 # https://community.namecheap.com/forums/viewtopic.php?f=6&t=6772
1303 url
= "https://dynamicdns.park-your-domain.com/update"
1304 can_remove_records
= False
1306 def update_protocol(self
, proto
):
1307 # Namecheap requires the hostname splitted into a host and domain part.
1308 host
, domain
= self
.hostname
.split(".", 1)
1310 # Get and store curent IP address.
1311 address
= self
.get_address(proto
)
1315 "password" : self
.password
,
1320 # Send update to the server.
1321 response
= self
.send_request(self
.url
, data
=data
)
1323 # Get the full response message.
1324 output
= response
.read()
1326 # Handle success messages.
1327 if self
.get_xml_tag_value(output
, "IP") == address
:
1330 # Handle error codes.
1331 errorcode
= self
.get_xml_tag_value(output
, "ResponseNumber")
1333 if errorcode
== "304156":
1334 raise DDNSAuthenticationError
1335 elif errorcode
== "316153":
1336 raise DDNSRequestError(_("Domain not found"))
1337 elif errorcode
== "316154":
1338 raise DDNSRequestError(_("Domain not active"))
1339 elif errorcode
in ("380098", "380099"):
1340 raise DDNSInternalServerError
1342 # If we got here, some other update error happened.
1343 raise DDNSUpdateError
1346 class DDNSProviderNOIP(DDNSProtocolDynDNS2
, DDNSProvider
):
1349 website
= "http://www.noip.com/"
1350 protocols
= ("ipv4",)
1352 # Information about the format of the HTTP request is to be found
1353 # here: http://www.noip.com/integrate/request and
1354 # here: http://www.noip.com/integrate/response
1356 url
= "http://dynupdate.noip.com/nic/update"
1358 def prepare_request_data(self
, proto
):
1359 assert proto
== "ipv4"
1362 "hostname" : self
.hostname
,
1363 "address" : self
.get_address(proto
),
1369 class DDNSProviderNowDNS(DDNSProtocolDynDNS2
, DDNSProvider
):
1370 handle
= "now-dns.com"
1372 website
= "http://now-dns.com/"
1373 protocols
= ("ipv6", "ipv4")
1375 # Information about the format of the request is to be found
1376 # but only can be accessed by register an account and login
1377 # https://now-dns.com/?m=api
1379 url
= "https://now-dns.com/update"
1382 class DDNSProviderNsupdateINFO(DDNSProtocolDynDNS2
, DDNSProvider
):
1383 handle
= "nsupdate.info"
1384 name
= "nsupdate.info"
1385 website
= "http://nsupdate.info/"
1386 protocols
= ("ipv6", "ipv4",)
1388 # Information about the format of the HTTP request can be found
1389 # after login on the provider user interface and here:
1390 # http://nsupdateinfo.readthedocs.org/en/latest/user.html
1392 url
= "https://nsupdate.info/nic/update"
1394 # TODO nsupdate.info can actually do this, but the functionality
1395 # has not been implemented here, yet.
1396 can_remove_records
= False
1398 # After a failed update, there will be no retries
1399 # https://bugzilla.ipfire.org/show_bug.cgi?id=10603
1400 holdoff_failure_days
= None
1402 # Nsupdate.info uses the hostname as user part for the HTTP basic auth,
1403 # and for the password a so called secret.
1406 return self
.get("hostname")
1410 return self
.token
or self
.get("secret")
1412 def prepare_request_data(self
, proto
):
1414 "myip" : self
.get_address(proto
),
1420 class DDNSProviderOpenDNS(DDNSProtocolDynDNS2
, DDNSProvider
):
1421 handle
= "opendns.com"
1423 website
= "http://www.opendns.com"
1425 # Detailed information about the update request and possible
1426 # response codes can be obtained from here:
1427 # https://support.opendns.com/entries/23891440
1429 url
= "https://updates.opendns.com/nic/update"
1431 def prepare_request_data(self
, proto
):
1433 "hostname" : self
.hostname
,
1434 "myip" : self
.get_address(proto
),
1440 class DDNSProviderOVH(DDNSProtocolDynDNS2
, DDNSProvider
):
1443 website
= "http://www.ovh.com/"
1444 protocols
= ("ipv4",)
1446 # OVH only provides very limited information about how to
1447 # update a DynDNS host. They only provide the update url
1448 # on the their german subpage.
1450 # http://hilfe.ovh.de/DomainDynHost
1452 url
= "https://www.ovh.com/nic/update"
1454 def prepare_request_data(self
, proto
):
1455 data
= DDNSProtocolDynDNS2
.prepare_request_data(self
, proto
)
1457 "system" : "dyndns",
1463 class DDNSProviderRegfish(DDNSProvider
):
1464 handle
= "regfish.com"
1465 name
= "Regfish GmbH"
1466 website
= "http://www.regfish.com/"
1468 # A full documentation to the providers api can be found here
1469 # but is only available in german.
1470 # https://www.regfish.de/domains/dyndns/dokumentation
1472 url
= "https://dyndns.regfish.de/"
1473 can_remove_records
= False
1477 "fqdn" : self
.hostname
,
1480 # Check if we update an IPv6 address.
1481 address6
= self
.get_address("ipv6")
1483 data
["ipv6"] = address6
1485 # Check if we update an IPv4 address.
1486 address4
= self
.get_address("ipv4")
1488 data
["ipv4"] = address4
1490 # Raise an error if none address is given.
1491 if not data
.has_key("ipv6") and not data
.has_key("ipv4"):
1492 raise DDNSConfigurationError
1494 # Check if a token has been set.
1496 data
["token"] = self
.token
1498 # Raise an error if no token and no useranem and password
1500 elif not self
.username
and not self
.password
:
1501 raise DDNSConfigurationError(_("No Auth details specified"))
1503 # HTTP Basic Auth is only allowed if no token is used.
1505 # Send update to the server.
1506 response
= self
.send_request(self
.url
, data
=data
)
1508 # Send update to the server.
1509 response
= self
.send_request(self
.url
, username
=self
.username
, password
=self
.password
,
1512 # Get the full response message.
1513 output
= response
.read()
1515 # Handle success messages.
1516 if "100" in output
or "101" in output
:
1519 # Handle error codes.
1520 if "401" or "402" in output
:
1521 raise DDNSAuthenticationError
1522 elif "408" in output
:
1523 raise DDNSRequestError(_("Invalid IPv4 address has been sent"))
1524 elif "409" in output
:
1525 raise DDNSRequestError(_("Invalid IPv6 address has been sent"))
1526 elif "412" in output
:
1527 raise DDNSRequestError(_("No valid FQDN was given"))
1528 elif "414" in output
:
1529 raise DDNSInternalServerError
1531 # If we got here, some other update error happened.
1532 raise DDNSUpdateError
1535 class DDNSProviderSchokokeksDNS(DDNSProtocolDynDNS2
, DDNSProvider
):
1536 handle
= "schokokeks.org"
1538 website
= "http://www.schokokeks.org/"
1539 protocols
= ("ipv4",)
1541 # Information about the format of the request is to be found
1542 # https://wiki.schokokeks.org/DynDNS
1543 url
= "https://dyndns.schokokeks.org/nic/update"
1546 class DDNSProviderSelfhost(DDNSProtocolDynDNS2
, DDNSProvider
):
1547 handle
= "selfhost.de"
1548 name
= "Selfhost.de"
1549 website
= "http://www.selfhost.de/"
1550 protocols
= ("ipv4",)
1552 url
= "https://carol.selfhost.de/nic/update"
1554 def prepare_request_data(self
, proto
):
1555 data
= DDNSProtocolDynDNS2
.prepare_request_data(self
, proto
)
1563 class DDNSProviderServercow(DDNSProvider
):
1564 handle
= "servercow.de"
1565 name
= "servercow.de"
1566 website
= "https://servercow.de/"
1567 protocols
= ("ipv4", "ipv6")
1569 url
= "https://www.servercow.de/dnsupdate/update.php"
1570 can_remove_records
= False
1572 def update_protocol(self
, proto
):
1574 "ipaddr" : self
.get_address(proto
),
1575 "hostname" : self
.hostname
,
1576 "username" : self
.username
,
1577 "pass" : self
.password
,
1580 # Send request to provider
1581 response
= self
.send_request(self
.url
, data
=data
)
1584 output
= response
.read()
1586 # Server responds with OK if update was successful
1587 if output
.startswith("OK"):
1591 elif output
.startswith("FAILED - Authentication failed"):
1592 raise DDNSAuthenticationError
1594 # If we got here, some other update error happened
1595 raise DDNSUpdateError(output
)
1598 class DDNSProviderSPDNS(DDNSProtocolDynDNS2
, DDNSProvider
):
1599 handle
= "spdns.org"
1601 website
= "https://www.spdyn.de/"
1603 # Detailed information about request and response codes are provided
1604 # by the vendor. They are using almost the same mechanism and status
1605 # codes as dyndns.org so we can inherit all those stuff.
1607 # http://wiki.securepoint.de/index.php/SPDNS_FAQ
1608 # http://wiki.securepoint.de/index.php/SPDNS_Update-Tokens
1610 url
= "https://update.spdyn.de/nic/update"
1614 return self
.get("username") or self
.hostname
1618 return self
.get("password") or self
.token
1621 class DDNSProviderStrato(DDNSProtocolDynDNS2
, DDNSProvider
):
1622 handle
= "strato.com"
1624 website
= "http:/www.strato.com/"
1625 protocols
= ("ipv4",)
1627 # Information about the request and response can be obtained here:
1628 # http://www.strato-faq.de/article/671/So-einfach-richten-Sie-DynDNS-f%C3%BCr-Ihre-Domains-ein.html
1630 url
= "https://dyndns.strato.com/nic/update"
1632 def prepare_request_data(self
, proto
):
1633 data
= DDNSProtocolDynDNS2
.prepare_request_data(self
, proto
)
1636 "backupmx" : "NOCHG"
1642 class DDNSProviderTwoDNS(DDNSProtocolDynDNS2
, DDNSProvider
):
1643 handle
= "twodns.de"
1645 website
= "http://www.twodns.de"
1646 protocols
= ("ipv4",)
1648 # Detailed information about the request can be found here
1649 # http://twodns.de/en/faqs
1650 # http://twodns.de/en/api
1652 url
= "https://update.twodns.de/update"
1654 def prepare_request_data(self
, proto
):
1655 assert proto
== "ipv4"
1658 "ip" : self
.get_address(proto
),
1659 "hostname" : self
.hostname
1665 class DDNSProviderUdmedia(DDNSProtocolDynDNS2
, DDNSProvider
):
1666 handle
= "udmedia.de"
1667 name
= "Udmedia GmbH"
1668 website
= "http://www.udmedia.de"
1669 protocols
= ("ipv4",)
1671 # Information about the request can be found here
1672 # http://www.udmedia.de/faq/content/47/288/de/wie-lege-ich-einen-dyndns_eintrag-an.html
1674 url
= "https://www.udmedia.de/nic/update"
1677 class DDNSProviderVariomedia(DDNSProtocolDynDNS2
, DDNSProvider
):
1678 handle
= "variomedia.de"
1680 website
= "http://www.variomedia.de/"
1681 protocols
= ("ipv6", "ipv4",)
1683 # Detailed information about the request can be found here
1684 # https://dyndns.variomedia.de/
1686 url
= "https://dyndns.variomedia.de/nic/update"
1688 def prepare_request_data(self
, proto
):
1690 "hostname" : self
.hostname
,
1691 "myip" : self
.get_address(proto
),
1697 class DDNSProviderXLhost(DDNSProtocolDynDNS2
, DDNSProvider
):
1698 handle
= "xlhost.de"
1700 website
= "http://xlhost.de/"
1701 protocols
= ("ipv4",)
1703 # Information about the format of the HTTP request is to be found
1704 # here: https://xlhost.de/faq/index_html?topicId=CQA2ELIPO4SQ
1706 url
= "https://nsupdate.xlhost.de/"
1709 class DDNSProviderZoneedit(DDNSProvider
):
1710 handle
= "zoneedit.com"
1712 website
= "http://www.zoneedit.com"
1713 protocols
= ("ipv4",)
1715 # Detailed information about the request and the response codes can be
1717 # http://www.zoneedit.com/doc/api/other.html
1718 # http://www.zoneedit.com/faq.html
1720 url
= "https://dynamic.zoneedit.com/auth/dynamic.html"
1722 def update_protocol(self
, proto
):
1724 "dnsto" : self
.get_address(proto
),
1725 "host" : self
.hostname
1728 # Send update to the server.
1729 response
= self
.send_request(self
.url
, username
=self
.username
, password
=self
.password
,
1732 # Get the full response message.
1733 output
= response
.read()
1735 # Handle success messages.
1736 if output
.startswith("<SUCCESS"):
1739 # Handle error codes.
1740 if output
.startswith("invalid login"):
1741 raise DDNSAuthenticationError
1742 elif output
.startswith("<ERROR CODE=\"704\""):
1743 raise DDNSRequestError(_("No valid FQDN was given"))
1744 elif output
.startswith("<ERROR CODE=\"702\""):
1745 raise DDNSRequestError(_("Too frequent update requests have been sent"))
1747 # If we got here, some other update error happened.
1748 raise DDNSUpdateError
1751 class DDNSProviderDNSmadeEasy(DDNSProvider
):
1752 handle
= "dnsmadeeasy.com"
1753 name
= "DNSmadeEasy.com"
1754 website
= "http://www.dnsmadeeasy.com/"
1755 protocols
= ("ipv4",)
1757 # DNS Made Easy Nameserver Provider also offering Dynamic DNS
1758 # Documentation can be found here:
1759 # http://www.dnsmadeeasy.com/dynamic-dns/
1761 url
= "https://cp.dnsmadeeasy.com/servlet/updateip?"
1762 can_remove_records
= False
1764 def update_protocol(self
, proto
):
1766 "ip" : self
.get_address(proto
),
1767 "id" : self
.hostname
,
1768 "username" : self
.username
,
1769 "password" : self
.password
,
1772 # Send update to the server.
1773 response
= self
.send_request(self
.url
, data
=data
)
1775 # Get the full response message.
1776 output
= response
.read()
1778 # Handle success messages.
1779 if output
.startswith("success") or output
.startswith("error-record-ip-same"):
1782 # Handle error codes.
1783 if output
.startswith("error-auth-suspend"):
1784 raise DDNSRequestError(_("Account has been suspended"))
1786 elif output
.startswith("error-auth-voided"):
1787 raise DDNSRequestError(_("Account has been revoked"))
1789 elif output
.startswith("error-record-invalid"):
1790 raise DDNSRequestError(_("Specified host does not exist"))
1792 elif output
.startswith("error-auth"):
1793 raise DDNSAuthenticationError
1795 # If we got here, some other update error happened.
1796 raise DDNSUpdateError(_("Server response: %s") % output
)
1799 class DDNSProviderZZZZ(DDNSProvider
):
1802 website
= "https://zzzz.io"
1803 protocols
= ("ipv6", "ipv4",)
1805 # Detailed information about the update request can be found here:
1806 # https://zzzz.io/faq/
1808 # Details about the possible response codes have been provided in the bugtracker:
1809 # https://bugzilla.ipfire.org/show_bug.cgi?id=10584#c2
1811 url
= "https://zzzz.io/api/v1/update"
1812 can_remove_records
= False
1814 def update_protocol(self
, proto
):
1816 "ip" : self
.get_address(proto
),
1817 "token" : self
.token
,
1821 data
["type"] = "aaaa"
1823 # zzzz uses the host from the full hostname as part
1824 # of the update url.
1825 host
, domain
= self
.hostname
.split(".", 1)
1827 # Add host value to the update url.
1828 url
= "%s/%s" % (self
.url
, host
)
1830 # Send update to the server.
1832 response
= self
.send_request(url
, data
=data
)
1834 # Handle error codes.
1835 except DDNSNotFound
:
1836 raise DDNSRequestError(_("Invalid hostname specified"))
1838 # Handle success messages.
1839 if response
.code
== 200:
1842 # If we got here, some other update error happened.
1843 raise DDNSUpdateError